1/* Parse expressions for GDB. 2 Copyright 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 3 1998, 1999, 2000, 2001 Free Software Foundation, Inc. 4 Modified from expread.y by the Department of Computer Science at the 5 State University of New York at Buffalo, 1991. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24/* Parse an expression from text in a string, 25 and return the result as a struct expression pointer. 26 That structure contains arithmetic operations in reverse polish, 27 with constants represented by operations that are followed by special data. 28 See expression.h for the details of the format. 29 What is important here is that it can be built up sequentially 30 during the process of parsing; the lower levels of the tree always 31 come first in the result. */ 32 33#include <ctype.h> 34 35#include "defs.h" 36#include "gdb_string.h" 37#include "symtab.h" 38#include "gdbtypes.h" 39#include "frame.h" 40#include "expression.h" 41#include "value.h" 42#include "command.h" 43#include "language.h" 44#include "parser-defs.h" 45#include "gdbcmd.h" 46#include "symfile.h" /* for overlay functions */ 47#include "inferior.h" /* for NUM_PSEUDO_REGS. NOTE: replace 48 with "gdbarch.h" when appropriate. */ 49#include "doublest.h" 50#include "gdb_assert.h" 51#include "block.h" 52 53/* Standard set of definitions for printing, dumping, prefixifying, 54 * and evaluating expressions. */ 55 56const struct exp_descriptor exp_descriptor_standard = 57 { 58 print_subexp_standard, 59 operator_length_standard, 60 op_name_standard, 61 dump_subexp_body_standard, 62 evaluate_subexp_standard 63 }; 64 65/* Symbols which architectures can redefine. */ 66 67/* Some systems have routines whose names start with `$'. Giving this 68 macro a non-zero value tells GDB's expression parser to check for 69 such routines when parsing tokens that begin with `$'. 70 71 On HP-UX, certain system routines (millicode) have names beginning 72 with `$' or `$$'. For example, `$$dyncall' is a millicode routine 73 that handles inter-space procedure calls on PA-RISC. */ 74#ifndef SYMBOLS_CAN_START_WITH_DOLLAR 75#define SYMBOLS_CAN_START_WITH_DOLLAR (0) 76#endif 77 78 79 80/* Global variables declared in parser-defs.h (and commented there). */ 81struct expression *expout; 82int expout_size; 83int expout_ptr; 84struct block *expression_context_block; 85CORE_ADDR expression_context_pc; 86struct block *innermost_block; 87int arglist_len; 88union type_stack_elt *type_stack; 89int type_stack_depth, type_stack_size; 90char *lexptr; 91char *prev_lexptr; 92char *namecopy; 93int paren_depth; 94int comma_terminates; 95 96static int expressiondebug = 0; 97 98extern int hp_som_som_object_present; 99 100static void free_funcalls (void *ignore); 101 102static void prefixify_expression (struct expression *); 103 104static void prefixify_subexp (struct expression *, struct expression *, int, 105 int); 106 107void _initialize_parse (void); 108 109/* Data structure for saving values of arglist_len for function calls whose 110 arguments contain other function calls. */ 111 112struct funcall 113 { 114 struct funcall *next; 115 int arglist_len; 116 }; 117 118static struct funcall *funcall_chain; 119 120/* Begin counting arguments for a function call, 121 saving the data about any containing call. */ 122 123void 124start_arglist (void) 125{ 126 struct funcall *new; 127 128 new = (struct funcall *) xmalloc (sizeof (struct funcall)); 129 new->next = funcall_chain; 130 new->arglist_len = arglist_len; 131 arglist_len = 0; 132 funcall_chain = new; 133} 134 135/* Return the number of arguments in a function call just terminated, 136 and restore the data for the containing function call. */ 137 138int 139end_arglist (void) 140{ 141 int val = arglist_len; 142 struct funcall *call = funcall_chain; 143 funcall_chain = call->next; 144 arglist_len = call->arglist_len; 145 xfree (call); 146 return val; 147} 148 149/* Free everything in the funcall chain. 150 Used when there is an error inside parsing. */ 151 152static void 153free_funcalls (void *ignore) 154{ 155 struct funcall *call, *next; 156 157 for (call = funcall_chain; call; call = next) 158 { 159 next = call->next; 160 xfree (call); 161 } 162} 163 164/* This page contains the functions for adding data to the struct expression 165 being constructed. */ 166 167/* Add one element to the end of the expression. */ 168 169/* To avoid a bug in the Sun 4 compiler, we pass things that can fit into 170 a register through here */ 171 172void 173write_exp_elt (union exp_element expelt) 174{ 175 if (expout_ptr >= expout_size) 176 { 177 expout_size *= 2; 178 expout = (struct expression *) 179 xrealloc ((char *) expout, sizeof (struct expression) 180 + EXP_ELEM_TO_BYTES (expout_size)); 181 } 182 expout->elts[expout_ptr++] = expelt; 183} 184 185void 186write_exp_elt_opcode (enum exp_opcode expelt) 187{ 188 union exp_element tmp; 189 190 tmp.opcode = expelt; 191 192 write_exp_elt (tmp); 193} 194 195void 196write_exp_elt_sym (struct symbol *expelt) 197{ 198 union exp_element tmp; 199 200 tmp.symbol = expelt; 201 202 write_exp_elt (tmp); 203} 204 205void 206write_exp_elt_block (struct block *b) 207{ 208 union exp_element tmp; 209 tmp.block = b; 210 write_exp_elt (tmp); 211} 212 213void 214write_exp_elt_longcst (LONGEST expelt) 215{ 216 union exp_element tmp; 217 218 tmp.longconst = expelt; 219 220 write_exp_elt (tmp); 221} 222 223void 224write_exp_elt_dblcst (DOUBLEST expelt) 225{ 226 union exp_element tmp; 227 228 tmp.doubleconst = expelt; 229 230 write_exp_elt (tmp); 231} 232 233void 234write_exp_elt_type (struct type *expelt) 235{ 236 union exp_element tmp; 237 238 tmp.type = expelt; 239 240 write_exp_elt (tmp); 241} 242 243void 244write_exp_elt_intern (struct internalvar *expelt) 245{ 246 union exp_element tmp; 247 248 tmp.internalvar = expelt; 249 250 write_exp_elt (tmp); 251} 252 253/* Add a string constant to the end of the expression. 254 255 String constants are stored by first writing an expression element 256 that contains the length of the string, then stuffing the string 257 constant itself into however many expression elements are needed 258 to hold it, and then writing another expression element that contains 259 the length of the string. I.E. an expression element at each end of 260 the string records the string length, so you can skip over the 261 expression elements containing the actual string bytes from either 262 end of the string. Note that this also allows gdb to handle 263 strings with embedded null bytes, as is required for some languages. 264 265 Don't be fooled by the fact that the string is null byte terminated, 266 this is strictly for the convenience of debugging gdb itself. Gdb 267 Gdb does not depend up the string being null terminated, since the 268 actual length is recorded in expression elements at each end of the 269 string. The null byte is taken into consideration when computing how 270 many expression elements are required to hold the string constant, of 271 course. */ 272 273 274void 275write_exp_string (struct stoken str) 276{ 277 int len = str.length; 278 int lenelt; 279 char *strdata; 280 281 /* Compute the number of expression elements required to hold the string 282 (including a null byte terminator), along with one expression element 283 at each end to record the actual string length (not including the 284 null byte terminator). */ 285 286 lenelt = 2 + BYTES_TO_EXP_ELEM (len + 1); 287 288 /* Ensure that we have enough available expression elements to store 289 everything. */ 290 291 if ((expout_ptr + lenelt) >= expout_size) 292 { 293 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10); 294 expout = (struct expression *) 295 xrealloc ((char *) expout, (sizeof (struct expression) 296 + EXP_ELEM_TO_BYTES (expout_size))); 297 } 298 299 /* Write the leading length expression element (which advances the current 300 expression element index), then write the string constant followed by a 301 terminating null byte, and then write the trailing length expression 302 element. */ 303 304 write_exp_elt_longcst ((LONGEST) len); 305 strdata = (char *) &expout->elts[expout_ptr]; 306 memcpy (strdata, str.ptr, len); 307 *(strdata + len) = '\0'; 308 expout_ptr += lenelt - 2; 309 write_exp_elt_longcst ((LONGEST) len); 310} 311 312/* Add a bitstring constant to the end of the expression. 313 314 Bitstring constants are stored by first writing an expression element 315 that contains the length of the bitstring (in bits), then stuffing the 316 bitstring constant itself into however many expression elements are 317 needed to hold it, and then writing another expression element that 318 contains the length of the bitstring. I.E. an expression element at 319 each end of the bitstring records the bitstring length, so you can skip 320 over the expression elements containing the actual bitstring bytes from 321 either end of the bitstring. */ 322 323void 324write_exp_bitstring (struct stoken str) 325{ 326 int bits = str.length; /* length in bits */ 327 int len = (bits + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT; 328 int lenelt; 329 char *strdata; 330 331 /* Compute the number of expression elements required to hold the bitstring, 332 along with one expression element at each end to record the actual 333 bitstring length in bits. */ 334 335 lenelt = 2 + BYTES_TO_EXP_ELEM (len); 336 337 /* Ensure that we have enough available expression elements to store 338 everything. */ 339 340 if ((expout_ptr + lenelt) >= expout_size) 341 { 342 expout_size = max (expout_size * 2, expout_ptr + lenelt + 10); 343 expout = (struct expression *) 344 xrealloc ((char *) expout, (sizeof (struct expression) 345 + EXP_ELEM_TO_BYTES (expout_size))); 346 } 347 348 /* Write the leading length expression element (which advances the current 349 expression element index), then write the bitstring constant, and then 350 write the trailing length expression element. */ 351 352 write_exp_elt_longcst ((LONGEST) bits); 353 strdata = (char *) &expout->elts[expout_ptr]; 354 memcpy (strdata, str.ptr, len); 355 expout_ptr += lenelt - 2; 356 write_exp_elt_longcst ((LONGEST) bits); 357} 358 359/* Add the appropriate elements for a minimal symbol to the end of 360 the expression. The rationale behind passing in text_symbol_type and 361 data_symbol_type was so that Modula-2 could pass in WORD for 362 data_symbol_type. Perhaps it still is useful to have those types vary 363 based on the language, but they no longer have names like "int", so 364 the initial rationale is gone. */ 365 366static struct type *msym_text_symbol_type; 367static struct type *msym_data_symbol_type; 368static struct type *msym_unknown_symbol_type; 369 370void 371write_exp_msymbol (struct minimal_symbol *msymbol, 372 struct type *text_symbol_type, 373 struct type *data_symbol_type) 374{ 375 CORE_ADDR addr; 376 377 write_exp_elt_opcode (OP_LONG); 378 /* Let's make the type big enough to hold a 64-bit address. */ 379 write_exp_elt_type (builtin_type_CORE_ADDR); 380 381 addr = SYMBOL_VALUE_ADDRESS (msymbol); 382 if (overlay_debugging) 383 addr = symbol_overlayed_address (addr, SYMBOL_BFD_SECTION (msymbol)); 384 write_exp_elt_longcst ((LONGEST) addr); 385 386 write_exp_elt_opcode (OP_LONG); 387 388 write_exp_elt_opcode (UNOP_MEMVAL); 389 switch (msymbol->type) 390 { 391 case mst_text: 392 case mst_file_text: 393 case mst_solib_trampoline: 394 write_exp_elt_type (msym_text_symbol_type); 395 break; 396 397 case mst_data: 398 case mst_file_data: 399 case mst_bss: 400 case mst_file_bss: 401 write_exp_elt_type (msym_data_symbol_type); 402 break; 403 404 default: 405 write_exp_elt_type (msym_unknown_symbol_type); 406 break; 407 } 408 write_exp_elt_opcode (UNOP_MEMVAL); 409} 410 411/* Recognize tokens that start with '$'. These include: 412 413 $regname A native register name or a "standard 414 register name". 415 416 $variable A convenience variable with a name chosen 417 by the user. 418 419 $digits Value history with index <digits>, starting 420 from the first value which has index 1. 421 422 $$digits Value history with index <digits> relative 423 to the last value. I.E. $$0 is the last 424 value, $$1 is the one previous to that, $$2 425 is the one previous to $$1, etc. 426 427 $ | $0 | $$0 The last value in the value history. 428 429 $$ An abbreviation for the second to the last 430 value in the value history, I.E. $$1 431 432 */ 433 434void 435write_dollar_variable (struct stoken str) 436{ 437 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1) 438 and $$digits (equivalent to $<-digits> if you could type that). */ 439 440 int negate = 0; 441 int i = 1; 442 /* Double dollar means negate the number and add -1 as well. 443 Thus $$ alone means -1. */ 444 if (str.length >= 2 && str.ptr[1] == '$') 445 { 446 negate = 1; 447 i = 2; 448 } 449 if (i == str.length) 450 { 451 /* Just dollars (one or two) */ 452 i = -negate; 453 goto handle_last; 454 } 455 /* Is the rest of the token digits? */ 456 for (; i < str.length; i++) 457 if (!(str.ptr[i] >= '0' && str.ptr[i] <= '9')) 458 break; 459 if (i == str.length) 460 { 461 i = atoi (str.ptr + 1 + negate); 462 if (negate) 463 i = -i; 464 goto handle_last; 465 } 466 467 /* Handle tokens that refer to machine registers: 468 $ followed by a register name. */ 469 i = frame_map_name_to_regnum (deprecated_selected_frame, 470 str.ptr + 1, str.length - 1); 471 if (i >= 0) 472 goto handle_register; 473 474 if (SYMBOLS_CAN_START_WITH_DOLLAR) 475 { 476 struct symbol *sym = NULL; 477 struct minimal_symbol *msym = NULL; 478 479 /* On HP-UX, certain system routines (millicode) have names beginning 480 with $ or $$, e.g. $$dyncall, which handles inter-space procedure 481 calls on PA-RISC. Check for those, first. */ 482 483 /* This code is not enabled on non HP-UX systems, since worst case 484 symbol table lookup performance is awful, to put it mildly. */ 485 486 sym = lookup_symbol (copy_name (str), (struct block *) NULL, 487 VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL); 488 if (sym) 489 { 490 write_exp_elt_opcode (OP_VAR_VALUE); 491 write_exp_elt_block (block_found); /* set by lookup_symbol */ 492 write_exp_elt_sym (sym); 493 write_exp_elt_opcode (OP_VAR_VALUE); 494 return; 495 } 496 msym = lookup_minimal_symbol (copy_name (str), NULL, NULL); 497 if (msym) 498 { 499 write_exp_msymbol (msym, 500 lookup_function_type (builtin_type_int), 501 builtin_type_int); 502 return; 503 } 504 } 505 506 /* Any other names starting in $ are debugger internal variables. */ 507 508 write_exp_elt_opcode (OP_INTERNALVAR); 509 write_exp_elt_intern (lookup_internalvar (copy_name (str) + 1)); 510 write_exp_elt_opcode (OP_INTERNALVAR); 511 return; 512handle_last: 513 write_exp_elt_opcode (OP_LAST); 514 write_exp_elt_longcst ((LONGEST) i); 515 write_exp_elt_opcode (OP_LAST); 516 return; 517handle_register: 518 write_exp_elt_opcode (OP_REGISTER); 519 write_exp_elt_longcst (i); 520 write_exp_elt_opcode (OP_REGISTER); 521 return; 522} 523 524 525/* Parse a string that is possibly a namespace / nested class 526 specification, i.e., something of the form A::B::C::x. Input 527 (NAME) is the entire string; LEN is the current valid length; the 528 output is a string, TOKEN, which points to the largest recognized 529 prefix which is a series of namespaces or classes. CLASS_PREFIX is 530 another output, which records whether a nested class spec was 531 recognized (= 1) or a fully qualified variable name was found (= 532 0). ARGPTR is side-effected (if non-NULL) to point to beyond the 533 string recognized and consumed by this routine. 534 535 The return value is a pointer to the symbol for the base class or 536 variable if found, or NULL if not found. Callers must check this 537 first -- if NULL, the outputs may not be correct. 538 539 This function is used c-exp.y. This is used specifically to get 540 around HP aCC (and possibly other compilers), which insists on 541 generating names with embedded colons for namespace or nested class 542 members. 543 544 (Argument LEN is currently unused. 1997-08-27) 545 546 Callers must free memory allocated for the output string TOKEN. */ 547 548static const char coloncolon[2] = 549{':', ':'}; 550 551struct symbol * 552parse_nested_classes_for_hpacc (char *name, int len, char **token, 553 int *class_prefix, char **argptr) 554{ 555 /* Comment below comes from decode_line_1 which has very similar 556 code, which is called for "break" command parsing. */ 557 558 /* We have what looks like a class or namespace 559 scope specification (A::B), possibly with many 560 levels of namespaces or classes (A::B::C::D). 561 562 Some versions of the HP ANSI C++ compiler (as also possibly 563 other compilers) generate class/function/member names with 564 embedded double-colons if they are inside namespaces. To 565 handle this, we loop a few times, considering larger and 566 larger prefixes of the string as though they were single 567 symbols. So, if the initially supplied string is 568 A::B::C::D::foo, we have to look up "A", then "A::B", 569 then "A::B::C", then "A::B::C::D", and finally 570 "A::B::C::D::foo" as single, monolithic symbols, because 571 A, B, C or D may be namespaces. 572 573 Note that namespaces can nest only inside other 574 namespaces, and not inside classes. So we need only 575 consider *prefixes* of the string; there is no need to look up 576 "B::C" separately as a symbol in the previous example. */ 577 578 char *p; 579 char *start, *end; 580 char *prefix = NULL; 581 char *tmp; 582 struct symbol *sym_class = NULL; 583 struct symbol *sym_var = NULL; 584 struct type *t; 585 int prefix_len = 0; 586 int done = 0; 587 char *q; 588 589 /* Check for HP-compiled executable -- in other cases 590 return NULL, and caller must default to standard GDB 591 behaviour. */ 592 593 if (!hp_som_som_object_present) 594 return (struct symbol *) NULL; 595 596 p = name; 597 598 /* Skip over whitespace and possible global "::" */ 599 while (*p && (*p == ' ' || *p == '\t')) 600 p++; 601 if (p[0] == ':' && p[1] == ':') 602 p += 2; 603 while (*p && (*p == ' ' || *p == '\t')) 604 p++; 605 606 while (1) 607 { 608 /* Get to the end of the next namespace or class spec. */ 609 /* If we're looking at some non-token, fail immediately */ 610 start = p; 611 if (!(isalpha (*p) || *p == '$' || *p == '_')) 612 return (struct symbol *) NULL; 613 p++; 614 while (*p && (isalnum (*p) || *p == '$' || *p == '_')) 615 p++; 616 617 if (*p == '<') 618 { 619 /* If we have the start of a template specification, 620 scan right ahead to its end */ 621 q = find_template_name_end (p); 622 if (q) 623 p = q; 624 } 625 626 end = p; 627 628 /* Skip over "::" and whitespace for next time around */ 629 while (*p && (*p == ' ' || *p == '\t')) 630 p++; 631 if (p[0] == ':' && p[1] == ':') 632 p += 2; 633 while (*p && (*p == ' ' || *p == '\t')) 634 p++; 635 636 /* Done with tokens? */ 637 if (!*p || !(isalpha (*p) || *p == '$' || *p == '_')) 638 done = 1; 639 640 tmp = (char *) alloca (prefix_len + end - start + 3); 641 if (prefix) 642 { 643 memcpy (tmp, prefix, prefix_len); 644 memcpy (tmp + prefix_len, coloncolon, 2); 645 memcpy (tmp + prefix_len + 2, start, end - start); 646 tmp[prefix_len + 2 + end - start] = '\000'; 647 } 648 else 649 { 650 memcpy (tmp, start, end - start); 651 tmp[end - start] = '\000'; 652 } 653 654 prefix = tmp; 655 prefix_len = strlen (prefix); 656 657 /* See if the prefix we have now is something we know about */ 658 659 if (!done) 660 { 661 /* More tokens to process, so this must be a class/namespace */ 662 sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN, 663 0, (struct symtab **) NULL); 664 } 665 else 666 { 667 /* No more tokens, so try as a variable first */ 668 sym_var = lookup_symbol (prefix, 0, VAR_DOMAIN, 669 0, (struct symtab **) NULL); 670 /* If failed, try as class/namespace */ 671 if (!sym_var) 672 sym_class = lookup_symbol (prefix, 0, STRUCT_DOMAIN, 673 0, (struct symtab **) NULL); 674 } 675 676 if (sym_var || 677 (sym_class && 678 (t = check_typedef (SYMBOL_TYPE (sym_class)), 679 (TYPE_CODE (t) == TYPE_CODE_STRUCT 680 || TYPE_CODE (t) == TYPE_CODE_UNION)))) 681 { 682 /* We found a valid token */ 683 *token = (char *) xmalloc (prefix_len + 1); 684 memcpy (*token, prefix, prefix_len); 685 (*token)[prefix_len] = '\000'; 686 break; 687 } 688 689 /* No variable or class/namespace found, no more tokens */ 690 if (done) 691 return (struct symbol *) NULL; 692 } 693 694 /* Out of loop, so we must have found a valid token */ 695 if (sym_var) 696 *class_prefix = 0; 697 else 698 *class_prefix = 1; 699 700 if (argptr) 701 *argptr = done ? p : end; 702 703 return sym_var ? sym_var : sym_class; /* found */ 704} 705 706char * 707find_template_name_end (char *p) 708{ 709 int depth = 1; 710 int just_seen_right = 0; 711 int just_seen_colon = 0; 712 int just_seen_space = 0; 713 714 if (!p || (*p != '<')) 715 return 0; 716 717 while (*++p) 718 { 719 switch (*p) 720 { 721 case '\'': 722 case '\"': 723 case '{': 724 case '}': 725 /* In future, may want to allow these?? */ 726 return 0; 727 case '<': 728 depth++; /* start nested template */ 729 if (just_seen_colon || just_seen_right || just_seen_space) 730 return 0; /* but not after : or :: or > or space */ 731 break; 732 case '>': 733 if (just_seen_colon || just_seen_right) 734 return 0; /* end a (nested?) template */ 735 just_seen_right = 1; /* but not after : or :: */ 736 if (--depth == 0) /* also disallow >>, insist on > > */ 737 return ++p; /* if outermost ended, return */ 738 break; 739 case ':': 740 if (just_seen_space || (just_seen_colon > 1)) 741 return 0; /* nested class spec coming up */ 742 just_seen_colon++; /* we allow :: but not :::: */ 743 break; 744 case ' ': 745 break; 746 default: 747 if (!((*p >= 'a' && *p <= 'z') || /* allow token chars */ 748 (*p >= 'A' && *p <= 'Z') || 749 (*p >= '0' && *p <= '9') || 750 (*p == '_') || (*p == ',') || /* commas for template args */ 751 (*p == '&') || (*p == '*') || /* pointer and ref types */ 752 (*p == '(') || (*p == ')') || /* function types */ 753 (*p == '[') || (*p == ']'))) /* array types */ 754 return 0; 755 } 756 if (*p != ' ') 757 just_seen_space = 0; 758 if (*p != ':') 759 just_seen_colon = 0; 760 if (*p != '>') 761 just_seen_right = 0; 762 } 763 return 0; 764} 765 766 767 768/* Return a null-terminated temporary copy of the name 769 of a string token. */ 770 771char * 772copy_name (struct stoken token) 773{ 774 memcpy (namecopy, token.ptr, token.length); 775 namecopy[token.length] = 0; 776 return namecopy; 777} 778 779/* Reverse an expression from suffix form (in which it is constructed) 780 to prefix form (in which we can conveniently print or execute it). */ 781 782static void 783prefixify_expression (struct expression *expr) 784{ 785 int len = 786 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expr->nelts); 787 struct expression *temp; 788 int inpos = expr->nelts, outpos = 0; 789 790 temp = (struct expression *) alloca (len); 791 792 /* Copy the original expression into temp. */ 793 memcpy (temp, expr, len); 794 795 prefixify_subexp (temp, expr, inpos, outpos); 796} 797 798/* Return the number of exp_elements in the postfix subexpression 799 of EXPR whose operator is at index ENDPOS - 1 in EXPR. */ 800 801int 802length_of_subexp (struct expression *expr, int endpos) 803{ 804 int oplen, args, i; 805 806 operator_length (expr, endpos, &oplen, &args); 807 808 while (args > 0) 809 { 810 oplen += length_of_subexp (expr, endpos - oplen); 811 args--; 812 } 813 814 return oplen; 815} 816 817/* Sets *OPLENP to the length of the operator whose (last) index is 818 ENDPOS - 1 in EXPR, and sets *ARGSP to the number of arguments that 819 operator takes. */ 820 821void 822operator_length (struct expression *expr, int endpos, int *oplenp, int *argsp) 823{ 824 expr->language_defn->la_exp_desc->operator_length (expr, endpos, 825 oplenp, argsp); 826} 827 828/* Default value for operator_length in exp_descriptor vectors. */ 829 830void 831operator_length_standard (struct expression *expr, int endpos, 832 int *oplenp, int *argsp) 833{ 834 int oplen = 1; 835 int args = 0; 836 int i; 837 838 if (endpos < 1) 839 error ("?error in operator_length_standard"); 840 841 i = (int) expr->elts[endpos - 1].opcode; 842 843 switch (i) 844 { 845 /* C++ */ 846 case OP_SCOPE: 847 oplen = longest_to_int (expr->elts[endpos - 2].longconst); 848 oplen = 5 + BYTES_TO_EXP_ELEM (oplen + 1); 849 break; 850 851 case OP_LONG: 852 case OP_DOUBLE: 853 case OP_VAR_VALUE: 854 oplen = 4; 855 break; 856 857 case OP_TYPE: 858 case OP_BOOL: 859 case OP_LAST: 860 case OP_REGISTER: 861 case OP_INTERNALVAR: 862 oplen = 3; 863 break; 864 865 case OP_COMPLEX: 866 oplen = 1; 867 args = 2; 868 break; 869 870 case OP_FUNCALL: 871 case OP_F77_UNDETERMINED_ARGLIST: 872 oplen = 3; 873 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst); 874 break; 875 876 case OP_OBJC_MSGCALL: /* Objective C message (method) call */ 877 oplen = 4; 878 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst); 879 break; 880 881 case UNOP_MAX: 882 case UNOP_MIN: 883 oplen = 3; 884 break; 885 886 case BINOP_VAL: 887 case UNOP_CAST: 888 case UNOP_MEMVAL: 889 oplen = 3; 890 args = 1; 891 break; 892 893 case UNOP_ABS: 894 case UNOP_CAP: 895 case UNOP_CHR: 896 case UNOP_FLOAT: 897 case UNOP_HIGH: 898 case UNOP_ODD: 899 case UNOP_ORD: 900 case UNOP_TRUNC: 901 oplen = 1; 902 args = 1; 903 break; 904 905 case OP_LABELED: 906 case STRUCTOP_STRUCT: 907 case STRUCTOP_PTR: 908 args = 1; 909 /* fall through */ 910 case OP_M2_STRING: 911 case OP_STRING: 912 case OP_OBJC_NSSTRING: /* Objective C Foundation Class NSString constant */ 913 case OP_OBJC_SELECTOR: /* Objective C "@selector" pseudo-op */ 914 case OP_NAME: 915 case OP_EXPRSTRING: 916 oplen = longest_to_int (expr->elts[endpos - 2].longconst); 917 oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1); 918 break; 919 920 case OP_BITSTRING: 921 oplen = longest_to_int (expr->elts[endpos - 2].longconst); 922 oplen = (oplen + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT; 923 oplen = 4 + BYTES_TO_EXP_ELEM (oplen); 924 break; 925 926 case OP_ARRAY: 927 oplen = 4; 928 args = longest_to_int (expr->elts[endpos - 2].longconst); 929 args -= longest_to_int (expr->elts[endpos - 3].longconst); 930 args += 1; 931 break; 932 933 case TERNOP_COND: 934 case TERNOP_SLICE: 935 case TERNOP_SLICE_COUNT: 936 args = 3; 937 break; 938 939 /* Modula-2 */ 940 case MULTI_SUBSCRIPT: 941 oplen = 3; 942 args = 1 + longest_to_int (expr->elts[endpos - 2].longconst); 943 break; 944 945 case BINOP_ASSIGN_MODIFY: 946 oplen = 3; 947 args = 2; 948 break; 949 950 /* C++ */ 951 case OP_THIS: 952 case OP_OBJC_SELF: 953 oplen = 2; 954 break; 955 956 default: 957 args = 1 + (i < (int) BINOP_END); 958 } 959 960 *oplenp = oplen; 961 *argsp = args; 962} 963 964/* Copy the subexpression ending just before index INEND in INEXPR 965 into OUTEXPR, starting at index OUTBEG. 966 In the process, convert it from suffix to prefix form. */ 967 968static void 969prefixify_subexp (struct expression *inexpr, 970 struct expression *outexpr, int inend, int outbeg) 971{ 972 int oplen; 973 int args; 974 int i; 975 int *arglens; 976 enum exp_opcode opcode; 977 978 operator_length (inexpr, inend, &oplen, &args); 979 980 /* Copy the final operator itself, from the end of the input 981 to the beginning of the output. */ 982 inend -= oplen; 983 memcpy (&outexpr->elts[outbeg], &inexpr->elts[inend], 984 EXP_ELEM_TO_BYTES (oplen)); 985 outbeg += oplen; 986 987 /* Find the lengths of the arg subexpressions. */ 988 arglens = (int *) alloca (args * sizeof (int)); 989 for (i = args - 1; i >= 0; i--) 990 { 991 oplen = length_of_subexp (inexpr, inend); 992 arglens[i] = oplen; 993 inend -= oplen; 994 } 995 996 /* Now copy each subexpression, preserving the order of 997 the subexpressions, but prefixifying each one. 998 In this loop, inend starts at the beginning of 999 the expression this level is working on 1000 and marches forward over the arguments. 1001 outbeg does similarly in the output. */ 1002 for (i = 0; i < args; i++) 1003 { 1004 oplen = arglens[i]; 1005 inend += oplen; 1006 prefixify_subexp (inexpr, outexpr, inend, outbeg); 1007 outbeg += oplen; 1008 } 1009} 1010 1011/* This page contains the two entry points to this file. */ 1012 1013/* Read an expression from the string *STRINGPTR points to, 1014 parse it, and return a pointer to a struct expression that we malloc. 1015 Use block BLOCK as the lexical context for variable names; 1016 if BLOCK is zero, use the block of the selected stack frame. 1017 Meanwhile, advance *STRINGPTR to point after the expression, 1018 at the first nonwhite character that is not part of the expression 1019 (possibly a null character). 1020 1021 If COMMA is nonzero, stop if a comma is reached. */ 1022 1023struct expression * 1024parse_exp_1 (char **stringptr, struct block *block, int comma) 1025{ 1026 struct cleanup *old_chain; 1027 1028 lexptr = *stringptr; 1029 prev_lexptr = NULL; 1030 1031 paren_depth = 0; 1032 type_stack_depth = 0; 1033 1034 comma_terminates = comma; 1035 1036 if (lexptr == 0 || *lexptr == 0) 1037 error_no_arg ("expression to compute"); 1038 1039 old_chain = make_cleanup (free_funcalls, 0 /*ignore*/); 1040 funcall_chain = 0; 1041 1042 if (block) 1043 { 1044 expression_context_block = block; 1045 expression_context_pc = BLOCK_START (block); 1046 } 1047 else 1048 expression_context_block = get_selected_block (&expression_context_pc); 1049 1050 namecopy = (char *) alloca (strlen (lexptr) + 1); 1051 expout_size = 10; 1052 expout_ptr = 0; 1053 expout = (struct expression *) 1054 xmalloc (sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_size)); 1055 expout->language_defn = current_language; 1056 make_cleanup (free_current_contents, &expout); 1057 1058 if (current_language->la_parser ()) 1059 current_language->la_error (NULL); 1060 1061 discard_cleanups (old_chain); 1062 1063 /* Record the actual number of expression elements, and then 1064 reallocate the expression memory so that we free up any 1065 excess elements. */ 1066 1067 expout->nelts = expout_ptr; 1068 expout = (struct expression *) 1069 xrealloc ((char *) expout, 1070 sizeof (struct expression) + EXP_ELEM_TO_BYTES (expout_ptr));; 1071 1072 /* Convert expression from postfix form as generated by yacc 1073 parser, to a prefix form. */ 1074 1075 if (expressiondebug) 1076 dump_raw_expression (expout, gdb_stdlog, 1077 "before conversion to prefix form"); 1078 1079 prefixify_expression (expout); 1080 1081 if (expressiondebug) 1082 dump_prefix_expression (expout, gdb_stdlog); 1083 1084 *stringptr = lexptr; 1085 return expout; 1086} 1087 1088/* Parse STRING as an expression, and complain if this fails 1089 to use up all of the contents of STRING. */ 1090 1091struct expression * 1092parse_expression (char *string) 1093{ 1094 struct expression *exp; 1095 exp = parse_exp_1 (&string, 0, 0); 1096 if (*string) 1097 error ("Junk after end of expression."); 1098 return exp; 1099} 1100 1101/* Stuff for maintaining a stack of types. Currently just used by C, but 1102 probably useful for any language which declares its types "backwards". */ 1103 1104static void 1105check_type_stack_depth (void) 1106{ 1107 if (type_stack_depth == type_stack_size) 1108 { 1109 type_stack_size *= 2; 1110 type_stack = (union type_stack_elt *) 1111 xrealloc ((char *) type_stack, type_stack_size * sizeof (*type_stack)); 1112 } 1113} 1114 1115void 1116push_type (enum type_pieces tp) 1117{ 1118 check_type_stack_depth (); 1119 type_stack[type_stack_depth++].piece = tp; 1120} 1121 1122void 1123push_type_int (int n) 1124{ 1125 check_type_stack_depth (); 1126 type_stack[type_stack_depth++].int_val = n; 1127} 1128 1129void 1130push_type_address_space (char *string) 1131{ 1132 push_type_int (address_space_name_to_int (string)); 1133} 1134 1135enum type_pieces 1136pop_type (void) 1137{ 1138 if (type_stack_depth) 1139 return type_stack[--type_stack_depth].piece; 1140 return tp_end; 1141} 1142 1143int 1144pop_type_int (void) 1145{ 1146 if (type_stack_depth) 1147 return type_stack[--type_stack_depth].int_val; 1148 /* "Can't happen". */ 1149 return 0; 1150} 1151 1152/* Pop the type stack and return the type which corresponds to FOLLOW_TYPE 1153 as modified by all the stuff on the stack. */ 1154struct type * 1155follow_types (struct type *follow_type) 1156{ 1157 int done = 0; 1158 int make_const = 0; 1159 int make_volatile = 0; 1160 int make_addr_space = 0; 1161 int array_size; 1162 struct type *range_type; 1163 1164 while (!done) 1165 switch (pop_type ()) 1166 { 1167 case tp_end: 1168 done = 1; 1169 if (make_const) 1170 follow_type = make_cvr_type (make_const, 1171 TYPE_VOLATILE (follow_type), 1172 TYPE_RESTRICT (follow_type), 1173 follow_type, 0); 1174 if (make_volatile) 1175 follow_type = make_cvr_type (TYPE_CONST (follow_type), 1176 make_volatile, 1177 TYPE_RESTRICT (follow_type), 1178 follow_type, 0); 1179 if (make_addr_space) 1180 follow_type = make_type_with_address_space (follow_type, 1181 make_addr_space); 1182 make_const = make_volatile = 0; 1183 make_addr_space = 0; 1184 break; 1185 case tp_const: 1186 make_const = 1; 1187 break; 1188 case tp_volatile: 1189 make_volatile = 1; 1190 break; 1191 case tp_space_identifier: 1192 make_addr_space = pop_type_int (); 1193 break; 1194 case tp_pointer: 1195 follow_type = lookup_pointer_type (follow_type); 1196 if (make_const) 1197 follow_type = make_cvr_type (make_const, 1198 TYPE_VOLATILE (follow_type), 1199 TYPE_RESTRICT (follow_type), 1200 follow_type, 0); 1201 if (make_volatile) 1202 follow_type = make_cvr_type (TYPE_CONST (follow_type), 1203 make_volatile, 1204 TYPE_RESTRICT (follow_type), 1205 follow_type, 0); 1206 if (make_addr_space) 1207 follow_type = make_type_with_address_space (follow_type, 1208 make_addr_space); 1209 make_const = make_volatile = 0; 1210 make_addr_space = 0; 1211 break; 1212 case tp_reference: 1213 follow_type = lookup_reference_type (follow_type); 1214 if (make_const) 1215 follow_type = make_cvr_type (make_const, 1216 TYPE_VOLATILE (follow_type), 1217 TYPE_RESTRICT (follow_type), 1218 follow_type, 0); 1219 if (make_volatile) 1220 follow_type = make_cvr_type (TYPE_CONST (follow_type), 1221 make_volatile, 1222 TYPE_RESTRICT (follow_type), 1223 follow_type, 0); 1224 if (make_addr_space) 1225 follow_type = make_type_with_address_space (follow_type, 1226 make_addr_space); 1227 make_const = make_volatile = 0; 1228 make_addr_space = 0; 1229 break; 1230 case tp_array: 1231 array_size = pop_type_int (); 1232 /* FIXME-type-allocation: need a way to free this type when we are 1233 done with it. */ 1234 range_type = 1235 create_range_type ((struct type *) NULL, 1236 builtin_type_int, 0, 1237 array_size >= 0 ? array_size - 1 : 0); 1238 follow_type = 1239 create_array_type ((struct type *) NULL, 1240 follow_type, range_type); 1241 if (array_size < 0) 1242 TYPE_ARRAY_UPPER_BOUND_TYPE (follow_type) 1243 = BOUND_CANNOT_BE_DETERMINED; 1244 break; 1245 case tp_function: 1246 /* FIXME-type-allocation: need a way to free this type when we are 1247 done with it. */ 1248 follow_type = lookup_function_type (follow_type); 1249 break; 1250 } 1251 return follow_type; 1252} 1253 1254static void build_parse (void); 1255static void 1256build_parse (void) 1257{ 1258 int i; 1259 1260 msym_text_symbol_type = 1261 init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL); 1262 TYPE_TARGET_TYPE (msym_text_symbol_type) = builtin_type_int; 1263 msym_data_symbol_type = 1264 init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0, 1265 "<data variable, no debug info>", NULL); 1266 msym_unknown_symbol_type = 1267 init_type (TYPE_CODE_INT, 1, 0, 1268 "<variable (not text or data), no debug info>", 1269 NULL); 1270} 1271 1272/* This function avoids direct calls to fprintf 1273 in the parser generated debug code. */ 1274void 1275parser_fprintf (FILE *x, const char *y, ...) 1276{ 1277 va_list args; 1278 va_start (args, y); 1279 if (x == stderr) 1280 vfprintf_unfiltered (gdb_stderr, y, args); 1281 else 1282 { 1283 fprintf_unfiltered (gdb_stderr, " Unknown FILE used.\n"); 1284 vfprintf_unfiltered (gdb_stderr, y, args); 1285 } 1286 va_end (args); 1287} 1288 1289void 1290_initialize_parse (void) 1291{ 1292 type_stack_size = 80; 1293 type_stack_depth = 0; 1294 type_stack = (union type_stack_elt *) 1295 xmalloc (type_stack_size * sizeof (*type_stack)); 1296 1297 build_parse (); 1298 1299 /* FIXME - For the moment, handle types by swapping them in and out. 1300 Should be using the per-architecture data-pointer and a large 1301 struct. */ 1302 DEPRECATED_REGISTER_GDBARCH_SWAP (msym_text_symbol_type); 1303 DEPRECATED_REGISTER_GDBARCH_SWAP (msym_data_symbol_type); 1304 DEPRECATED_REGISTER_GDBARCH_SWAP (msym_unknown_symbol_type); 1305 deprecated_register_gdbarch_swap (NULL, 0, build_parse); 1306 1307 add_show_from_set ( 1308 add_set_cmd ("expression", class_maintenance, var_zinteger, 1309 (char *) &expressiondebug, 1310 "Set expression debugging.\n\ 1311When non-zero, the internal representation of expressions will be printed.", 1312 &setdebuglist), 1313 &showdebuglist); 1314} 1315