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