1 /* YACC parser for Pascal expressions, for GDB. 2 Copyright (C) 2000, 2006-2012 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 /* This file is derived from c-exp.y */ 20 21 /* Parse a Pascal expression from text in a string, 22 and return the result as a struct expression pointer. 23 That structure contains arithmetic operations in reverse polish, 24 with constants represented by operations that are followed by special data. 25 See expression.h for the details of the format. 26 What is important here is that it can be built up sequentially 27 during the process of parsing; the lower levels of the tree always 28 come first in the result. 29 30 Note that malloc's and realloc's in this file are transformed to 31 xmalloc and xrealloc respectively by the same sed command in the 32 makefile that remaps any other malloc/realloc inserted by the parser 33 generator. Doing this with #defines and trying to control the interaction 34 with include files (<malloc.h> and <stdlib.h> for example) just became 35 too messy, particularly when such includes can be inserted at random 36 times by the parser generator. */ 37 38 /* Known bugs or limitations: 39 - pascal string operations are not supported at all. 40 - there are some problems with boolean types. 41 - Pascal type hexadecimal constants are not supported 42 because they conflict with the internal variables format. 43 Probably also lots of other problems, less well defined PM. */ 44 %{ 45 46 #include "defs.h" 47 #include "gdb_string.h" 48 #include <ctype.h> 49 #include "expression.h" 50 #include "value.h" 51 #include "parser-defs.h" 52 #include "language.h" 53 #include "p-lang.h" 54 #include "bfd.h" /* Required by objfiles.h. */ 55 #include "symfile.h" /* Required by objfiles.h. */ 56 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols. */ 57 #include "block.h" 58 59 #define parse_type builtin_type (parse_gdbarch) 60 61 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 62 as well as gratuitiously global symbol names, so we can have multiple 63 yacc generated parsers in gdb. Note that these are only the variables 64 produced by yacc. If other parser generators (bison, byacc, etc) produce 65 additional global names that conflict at link time, then those parser 66 generators need to be fixed instead of adding those names to this list. */ 67 68 #define yymaxdepth pascal_maxdepth 69 #define yyparse pascal_parse 70 #define yylex pascal_lex 71 #define yyerror pascal_error 72 #define yylval pascal_lval 73 #define yychar pascal_char 74 #define yydebug pascal_debug 75 #define yypact pascal_pact 76 #define yyr1 pascal_r1 77 #define yyr2 pascal_r2 78 #define yydef pascal_def 79 #define yychk pascal_chk 80 #define yypgo pascal_pgo 81 #define yyact pascal_act 82 #define yyexca pascal_exca 83 #define yyerrflag pascal_errflag 84 #define yynerrs pascal_nerrs 85 #define yyps pascal_ps 86 #define yypv pascal_pv 87 #define yys pascal_s 88 #define yy_yys pascal_yys 89 #define yystate pascal_state 90 #define yytmp pascal_tmp 91 #define yyv pascal_v 92 #define yy_yyv pascal_yyv 93 #define yyval pascal_val 94 #define yylloc pascal_lloc 95 #define yyreds pascal_reds /* With YYDEBUG defined */ 96 #define yytoks pascal_toks /* With YYDEBUG defined */ 97 #define yyname pascal_name /* With YYDEBUG defined */ 98 #define yyrule pascal_rule /* With YYDEBUG defined */ 99 #define yylhs pascal_yylhs 100 #define yylen pascal_yylen 101 #define yydefred pascal_yydefred 102 #define yydgoto pascal_yydgoto 103 #define yysindex pascal_yysindex 104 #define yyrindex pascal_yyrindex 105 #define yygindex pascal_yygindex 106 #define yytable pascal_yytable 107 #define yycheck pascal_yycheck 108 109 #ifndef YYDEBUG 110 #define YYDEBUG 1 /* Default to yydebug support */ 111 #endif 112 113 #define YYFPRINTF parser_fprintf 114 115 int yyparse (void); 116 117 static int yylex (void); 118 119 void yyerror (char *); 120 121 static char * uptok (char *, int); 122 %} 123 124 /* Although the yacc "value" of an expression is not used, 125 since the result is stored in the structure being created, 126 other node types do have values. */ 127 128 %union 129 { 130 LONGEST lval; 131 struct { 132 LONGEST val; 133 struct type *type; 134 } typed_val_int; 135 struct { 136 DOUBLEST dval; 137 struct type *type; 138 } typed_val_float; 139 struct symbol *sym; 140 struct type *tval; 141 struct stoken sval; 142 struct ttype tsym; 143 struct symtoken ssym; 144 int voidval; 145 struct block *bval; 146 enum exp_opcode opcode; 147 struct internalvar *ivar; 148 149 struct type **tvec; 150 int *ivec; 151 } 152 153 %{ 154 /* YYSTYPE gets defined by %union */ 155 static int parse_number (char *, int, int, YYSTYPE *); 156 157 static struct type *current_type; 158 static struct internalvar *intvar; 159 static int leftdiv_is_integer; 160 static void push_current_type (void); 161 static void pop_current_type (void); 162 static int search_field; 163 %} 164 165 %type <voidval> exp exp1 type_exp start normal_start variable qualified_name 166 %type <tval> type typebase 167 /* %type <bval> block */ 168 169 /* Fancy type parsing. */ 170 %type <tval> ptype 171 172 %token <typed_val_int> INT 173 %token <typed_val_float> FLOAT 174 175 /* Both NAME and TYPENAME tokens represent symbols in the input, 176 and both convey their data as strings. 177 But a TYPENAME is a string that happens to be defined as a typedef 178 or builtin type name (such as int or char) 179 and a NAME is any other symbol. 180 Contexts where this distinction is not important can use the 181 nonterminal "name", which matches either NAME or TYPENAME. */ 182 183 %token <sval> STRING 184 %token <sval> FIELDNAME 185 %token <voidval> COMPLETE 186 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */ 187 %token <tsym> TYPENAME 188 %type <sval> name 189 %type <ssym> name_not_typename 190 191 /* A NAME_OR_INT is a symbol which is not known in the symbol table, 192 but which would parse as a valid number in the current input radix. 193 E.g. "c" when input_radix==16. Depending on the parse, it will be 194 turned into a name or into a number. */ 195 196 %token <ssym> NAME_OR_INT 197 198 %token STRUCT CLASS SIZEOF COLONCOLON 199 %token ERROR 200 201 /* Special type cases, put in to allow the parser to distinguish different 202 legal basetypes. */ 203 204 %token <voidval> VARIABLE 205 206 207 /* Object pascal */ 208 %token THIS 209 %token <lval> TRUEKEYWORD FALSEKEYWORD 210 211 %left ',' 212 %left ABOVE_COMMA 213 %right ASSIGN 214 %left NOT 215 %left OR 216 %left XOR 217 %left ANDAND 218 %left '=' NOTEQUAL 219 %left '<' '>' LEQ GEQ 220 %left LSH RSH DIV MOD 221 %left '@' 222 %left '+' '-' 223 %left '*' '/' 224 %right UNARY INCREMENT DECREMENT 225 %right ARROW '.' '[' '(' 226 %left '^' 227 %token <ssym> BLOCKNAME 228 %type <bval> block 229 %left COLONCOLON 230 231 232 %% 233 234 start : { current_type = NULL; 235 intvar = NULL; 236 search_field = 0; 237 leftdiv_is_integer = 0; 238 } 239 normal_start {} 240 ; 241 242 normal_start : 243 exp1 244 | type_exp 245 ; 246 247 type_exp: type 248 { write_exp_elt_opcode(OP_TYPE); 249 write_exp_elt_type($1); 250 write_exp_elt_opcode(OP_TYPE); 251 current_type = $1; } ; 252 253 /* Expressions, including the comma operator. */ 254 exp1 : exp 255 | exp1 ',' exp 256 { write_exp_elt_opcode (BINOP_COMMA); } 257 ; 258 259 /* Expressions, not including the comma operator. */ 260 exp : exp '^' %prec UNARY 261 { write_exp_elt_opcode (UNOP_IND); 262 if (current_type) 263 current_type = TYPE_TARGET_TYPE (current_type); } 264 ; 265 266 exp : '@' exp %prec UNARY 267 { write_exp_elt_opcode (UNOP_ADDR); 268 if (current_type) 269 current_type = TYPE_POINTER_TYPE (current_type); } 270 ; 271 272 exp : '-' exp %prec UNARY 273 { write_exp_elt_opcode (UNOP_NEG); } 274 ; 275 276 exp : NOT exp %prec UNARY 277 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } 278 ; 279 280 exp : INCREMENT '(' exp ')' %prec UNARY 281 { write_exp_elt_opcode (UNOP_PREINCREMENT); } 282 ; 283 284 exp : DECREMENT '(' exp ')' %prec UNARY 285 { write_exp_elt_opcode (UNOP_PREDECREMENT); } 286 ; 287 288 289 field_exp : exp '.' %prec UNARY 290 { search_field = 1; } 291 ; 292 293 exp : field_exp FIELDNAME 294 { write_exp_elt_opcode (STRUCTOP_STRUCT); 295 write_exp_string ($2); 296 write_exp_elt_opcode (STRUCTOP_STRUCT); 297 search_field = 0; 298 if (current_type) 299 { 300 while (TYPE_CODE (current_type) 301 == TYPE_CODE_PTR) 302 current_type = 303 TYPE_TARGET_TYPE (current_type); 304 current_type = lookup_struct_elt_type ( 305 current_type, $2.ptr, 0); 306 } 307 } 308 ; 309 310 311 exp : field_exp name 312 { mark_struct_expression (); 313 write_exp_elt_opcode (STRUCTOP_STRUCT); 314 write_exp_string ($2); 315 write_exp_elt_opcode (STRUCTOP_STRUCT); 316 search_field = 0; 317 if (current_type) 318 { 319 while (TYPE_CODE (current_type) 320 == TYPE_CODE_PTR) 321 current_type = 322 TYPE_TARGET_TYPE (current_type); 323 current_type = lookup_struct_elt_type ( 324 current_type, $2.ptr, 0); 325 } 326 } 327 ; 328 329 exp : field_exp COMPLETE 330 { struct stoken s; 331 mark_struct_expression (); 332 write_exp_elt_opcode (STRUCTOP_STRUCT); 333 s.ptr = ""; 334 s.length = 0; 335 write_exp_string (s); 336 write_exp_elt_opcode (STRUCTOP_STRUCT); } 337 ; 338 339 exp : exp '[' 340 /* We need to save the current_type value. */ 341 { char *arrayname; 342 int arrayfieldindex; 343 arrayfieldindex = is_pascal_string_type ( 344 current_type, NULL, NULL, 345 NULL, NULL, &arrayname); 346 if (arrayfieldindex) 347 { 348 struct stoken stringsval; 349 stringsval.ptr = alloca (strlen (arrayname) + 1); 350 stringsval.length = strlen (arrayname); 351 strcpy (stringsval.ptr, arrayname); 352 current_type = TYPE_FIELD_TYPE (current_type, 353 arrayfieldindex - 1); 354 write_exp_elt_opcode (STRUCTOP_STRUCT); 355 write_exp_string (stringsval); 356 write_exp_elt_opcode (STRUCTOP_STRUCT); 357 } 358 push_current_type (); } 359 exp1 ']' 360 { pop_current_type (); 361 write_exp_elt_opcode (BINOP_SUBSCRIPT); 362 if (current_type) 363 current_type = TYPE_TARGET_TYPE (current_type); } 364 ; 365 366 exp : exp '(' 367 /* This is to save the value of arglist_len 368 being accumulated by an outer function call. */ 369 { push_current_type (); 370 start_arglist (); } 371 arglist ')' %prec ARROW 372 { write_exp_elt_opcode (OP_FUNCALL); 373 write_exp_elt_longcst ((LONGEST) end_arglist ()); 374 write_exp_elt_opcode (OP_FUNCALL); 375 pop_current_type (); 376 if (current_type) 377 current_type = TYPE_TARGET_TYPE (current_type); 378 } 379 ; 380 381 arglist : 382 | exp 383 { arglist_len = 1; } 384 | arglist ',' exp %prec ABOVE_COMMA 385 { arglist_len++; } 386 ; 387 388 exp : type '(' exp ')' %prec UNARY 389 { if (current_type) 390 { 391 /* Allow automatic dereference of classes. */ 392 if ((TYPE_CODE (current_type) == TYPE_CODE_PTR) 393 && (TYPE_CODE (TYPE_TARGET_TYPE (current_type)) == TYPE_CODE_CLASS) 394 && (TYPE_CODE ($1) == TYPE_CODE_CLASS)) 395 write_exp_elt_opcode (UNOP_IND); 396 } 397 write_exp_elt_opcode (UNOP_CAST); 398 write_exp_elt_type ($1); 399 write_exp_elt_opcode (UNOP_CAST); 400 current_type = $1; } 401 ; 402 403 exp : '(' exp1 ')' 404 { } 405 ; 406 407 /* Binary operators in order of decreasing precedence. */ 408 409 exp : exp '*' exp 410 { write_exp_elt_opcode (BINOP_MUL); } 411 ; 412 413 exp : exp '/' { 414 if (current_type && is_integral_type (current_type)) 415 leftdiv_is_integer = 1; 416 } 417 exp 418 { 419 if (leftdiv_is_integer && current_type 420 && is_integral_type (current_type)) 421 { 422 write_exp_elt_opcode (UNOP_CAST); 423 write_exp_elt_type (parse_type->builtin_long_double); 424 current_type = parse_type->builtin_long_double; 425 write_exp_elt_opcode (UNOP_CAST); 426 leftdiv_is_integer = 0; 427 } 428 429 write_exp_elt_opcode (BINOP_DIV); 430 } 431 ; 432 433 exp : exp DIV exp 434 { write_exp_elt_opcode (BINOP_INTDIV); } 435 ; 436 437 exp : exp MOD exp 438 { write_exp_elt_opcode (BINOP_REM); } 439 ; 440 441 exp : exp '+' exp 442 { write_exp_elt_opcode (BINOP_ADD); } 443 ; 444 445 exp : exp '-' exp 446 { write_exp_elt_opcode (BINOP_SUB); } 447 ; 448 449 exp : exp LSH exp 450 { write_exp_elt_opcode (BINOP_LSH); } 451 ; 452 453 exp : exp RSH exp 454 { write_exp_elt_opcode (BINOP_RSH); } 455 ; 456 457 exp : exp '=' exp 458 { write_exp_elt_opcode (BINOP_EQUAL); 459 current_type = parse_type->builtin_bool; 460 } 461 ; 462 463 exp : exp NOTEQUAL exp 464 { write_exp_elt_opcode (BINOP_NOTEQUAL); 465 current_type = parse_type->builtin_bool; 466 } 467 ; 468 469 exp : exp LEQ exp 470 { write_exp_elt_opcode (BINOP_LEQ); 471 current_type = parse_type->builtin_bool; 472 } 473 ; 474 475 exp : exp GEQ exp 476 { write_exp_elt_opcode (BINOP_GEQ); 477 current_type = parse_type->builtin_bool; 478 } 479 ; 480 481 exp : exp '<' exp 482 { write_exp_elt_opcode (BINOP_LESS); 483 current_type = parse_type->builtin_bool; 484 } 485 ; 486 487 exp : exp '>' exp 488 { write_exp_elt_opcode (BINOP_GTR); 489 current_type = parse_type->builtin_bool; 490 } 491 ; 492 493 exp : exp ANDAND exp 494 { write_exp_elt_opcode (BINOP_BITWISE_AND); } 495 ; 496 497 exp : exp XOR exp 498 { write_exp_elt_opcode (BINOP_BITWISE_XOR); } 499 ; 500 501 exp : exp OR exp 502 { write_exp_elt_opcode (BINOP_BITWISE_IOR); } 503 ; 504 505 exp : exp ASSIGN exp 506 { write_exp_elt_opcode (BINOP_ASSIGN); } 507 ; 508 509 exp : TRUEKEYWORD 510 { write_exp_elt_opcode (OP_BOOL); 511 write_exp_elt_longcst ((LONGEST) $1); 512 current_type = parse_type->builtin_bool; 513 write_exp_elt_opcode (OP_BOOL); } 514 ; 515 516 exp : FALSEKEYWORD 517 { write_exp_elt_opcode (OP_BOOL); 518 write_exp_elt_longcst ((LONGEST) $1); 519 current_type = parse_type->builtin_bool; 520 write_exp_elt_opcode (OP_BOOL); } 521 ; 522 523 exp : INT 524 { write_exp_elt_opcode (OP_LONG); 525 write_exp_elt_type ($1.type); 526 current_type = $1.type; 527 write_exp_elt_longcst ((LONGEST)($1.val)); 528 write_exp_elt_opcode (OP_LONG); } 529 ; 530 531 exp : NAME_OR_INT 532 { YYSTYPE val; 533 parse_number ($1.stoken.ptr, 534 $1.stoken.length, 0, &val); 535 write_exp_elt_opcode (OP_LONG); 536 write_exp_elt_type (val.typed_val_int.type); 537 current_type = val.typed_val_int.type; 538 write_exp_elt_longcst ((LONGEST) 539 val.typed_val_int.val); 540 write_exp_elt_opcode (OP_LONG); 541 } 542 ; 543 544 545 exp : FLOAT 546 { write_exp_elt_opcode (OP_DOUBLE); 547 write_exp_elt_type ($1.type); 548 current_type = $1.type; 549 write_exp_elt_dblcst ($1.dval); 550 write_exp_elt_opcode (OP_DOUBLE); } 551 ; 552 553 exp : variable 554 ; 555 556 exp : VARIABLE 557 /* Already written by write_dollar_variable. 558 Handle current_type. */ 559 { if (intvar) { 560 struct value * val, * mark; 561 562 mark = value_mark (); 563 val = value_of_internalvar (parse_gdbarch, 564 intvar); 565 current_type = value_type (val); 566 value_release_to_mark (mark); 567 } 568 } 569 ; 570 571 exp : SIZEOF '(' type ')' %prec UNARY 572 { write_exp_elt_opcode (OP_LONG); 573 write_exp_elt_type (parse_type->builtin_int); 574 CHECK_TYPEDEF ($3); 575 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3)); 576 write_exp_elt_opcode (OP_LONG); } 577 ; 578 579 exp : SIZEOF '(' exp ')' %prec UNARY 580 { write_exp_elt_opcode (UNOP_SIZEOF); } 581 582 exp : STRING 583 { /* C strings are converted into array constants with 584 an explicit null byte added at the end. Thus 585 the array upper bound is the string length. 586 There is no such thing in C as a completely empty 587 string. */ 588 char *sp = $1.ptr; int count = $1.length; 589 while (count-- > 0) 590 { 591 write_exp_elt_opcode (OP_LONG); 592 write_exp_elt_type (parse_type->builtin_char); 593 write_exp_elt_longcst ((LONGEST)(*sp++)); 594 write_exp_elt_opcode (OP_LONG); 595 } 596 write_exp_elt_opcode (OP_LONG); 597 write_exp_elt_type (parse_type->builtin_char); 598 write_exp_elt_longcst ((LONGEST)'\0'); 599 write_exp_elt_opcode (OP_LONG); 600 write_exp_elt_opcode (OP_ARRAY); 601 write_exp_elt_longcst ((LONGEST) 0); 602 write_exp_elt_longcst ((LONGEST) ($1.length)); 603 write_exp_elt_opcode (OP_ARRAY); } 604 ; 605 606 /* Object pascal */ 607 exp : THIS 608 { 609 struct value * this_val; 610 struct type * this_type; 611 write_exp_elt_opcode (OP_THIS); 612 write_exp_elt_opcode (OP_THIS); 613 /* We need type of this. */ 614 this_val = value_of_this_silent (parse_language); 615 if (this_val) 616 this_type = value_type (this_val); 617 else 618 this_type = NULL; 619 if (this_type) 620 { 621 if (TYPE_CODE (this_type) == TYPE_CODE_PTR) 622 { 623 this_type = TYPE_TARGET_TYPE (this_type); 624 write_exp_elt_opcode (UNOP_IND); 625 } 626 } 627 628 current_type = this_type; 629 } 630 ; 631 632 /* end of object pascal. */ 633 634 block : BLOCKNAME 635 { 636 if ($1.sym != 0) 637 $$ = SYMBOL_BLOCK_VALUE ($1.sym); 638 else 639 { 640 struct symtab *tem = 641 lookup_symtab (copy_name ($1.stoken)); 642 if (tem) 643 $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 644 STATIC_BLOCK); 645 else 646 error (_("No file or function \"%s\"."), 647 copy_name ($1.stoken)); 648 } 649 } 650 ; 651 652 block : block COLONCOLON name 653 { struct symbol *tem 654 = lookup_symbol (copy_name ($3), $1, 655 VAR_DOMAIN, (int *) NULL); 656 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) 657 error (_("No function \"%s\" in specified context."), 658 copy_name ($3)); 659 $$ = SYMBOL_BLOCK_VALUE (tem); } 660 ; 661 662 variable: block COLONCOLON name 663 { struct symbol *sym; 664 sym = lookup_symbol (copy_name ($3), $1, 665 VAR_DOMAIN, (int *) NULL); 666 if (sym == 0) 667 error (_("No symbol \"%s\" in specified context."), 668 copy_name ($3)); 669 670 write_exp_elt_opcode (OP_VAR_VALUE); 671 /* block_found is set by lookup_symbol. */ 672 write_exp_elt_block (block_found); 673 write_exp_elt_sym (sym); 674 write_exp_elt_opcode (OP_VAR_VALUE); } 675 ; 676 677 qualified_name: typebase COLONCOLON name 678 { 679 struct type *type = $1; 680 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 681 && TYPE_CODE (type) != TYPE_CODE_UNION) 682 error (_("`%s' is not defined as an aggregate type."), 683 TYPE_NAME (type)); 684 685 write_exp_elt_opcode (OP_SCOPE); 686 write_exp_elt_type (type); 687 write_exp_string ($3); 688 write_exp_elt_opcode (OP_SCOPE); 689 } 690 ; 691 692 variable: qualified_name 693 | COLONCOLON name 694 { 695 char *name = copy_name ($2); 696 struct symbol *sym; 697 struct minimal_symbol *msymbol; 698 699 sym = 700 lookup_symbol (name, (const struct block *) NULL, 701 VAR_DOMAIN, (int *) NULL); 702 if (sym) 703 { 704 write_exp_elt_opcode (OP_VAR_VALUE); 705 write_exp_elt_block (NULL); 706 write_exp_elt_sym (sym); 707 write_exp_elt_opcode (OP_VAR_VALUE); 708 break; 709 } 710 711 msymbol = lookup_minimal_symbol (name, NULL, NULL); 712 if (msymbol != NULL) 713 write_exp_msymbol (msymbol); 714 else if (!have_full_symbols () 715 && !have_partial_symbols ()) 716 error (_("No symbol table is loaded. " 717 "Use the \"file\" command.")); 718 else 719 error (_("No symbol \"%s\" in current context."), 720 name); 721 } 722 ; 723 724 variable: name_not_typename 725 { struct symbol *sym = $1.sym; 726 727 if (sym) 728 { 729 if (symbol_read_needs_frame (sym)) 730 { 731 if (innermost_block == 0 732 || contained_in (block_found, 733 innermost_block)) 734 innermost_block = block_found; 735 } 736 737 write_exp_elt_opcode (OP_VAR_VALUE); 738 /* We want to use the selected frame, not 739 another more inner frame which happens to 740 be in the same block. */ 741 write_exp_elt_block (NULL); 742 write_exp_elt_sym (sym); 743 write_exp_elt_opcode (OP_VAR_VALUE); 744 current_type = sym->type; } 745 else if ($1.is_a_field_of_this) 746 { 747 struct value * this_val; 748 struct type * this_type; 749 /* Object pascal: it hangs off of `this'. Must 750 not inadvertently convert from a method call 751 to data ref. */ 752 if (innermost_block == 0 753 || contained_in (block_found, 754 innermost_block)) 755 innermost_block = block_found; 756 write_exp_elt_opcode (OP_THIS); 757 write_exp_elt_opcode (OP_THIS); 758 write_exp_elt_opcode (STRUCTOP_PTR); 759 write_exp_string ($1.stoken); 760 write_exp_elt_opcode (STRUCTOP_PTR); 761 /* We need type of this. */ 762 this_val = value_of_this_silent (parse_language); 763 if (this_val) 764 this_type = value_type (this_val); 765 else 766 this_type = NULL; 767 if (this_type) 768 current_type = lookup_struct_elt_type ( 769 this_type, 770 copy_name ($1.stoken), 0); 771 else 772 current_type = NULL; 773 } 774 else 775 { 776 struct minimal_symbol *msymbol; 777 char *arg = copy_name ($1.stoken); 778 779 msymbol = 780 lookup_minimal_symbol (arg, NULL, NULL); 781 if (msymbol != NULL) 782 write_exp_msymbol (msymbol); 783 else if (!have_full_symbols () 784 && !have_partial_symbols ()) 785 error (_("No symbol table is loaded. " 786 "Use the \"file\" command.")); 787 else 788 error (_("No symbol \"%s\" in current context."), 789 copy_name ($1.stoken)); 790 } 791 } 792 ; 793 794 795 ptype : typebase 796 ; 797 798 /* We used to try to recognize more pointer to member types here, but 799 that didn't work (shift/reduce conflicts meant that these rules never 800 got executed). The problem is that 801 int (foo::bar::baz::bizzle) 802 is a function type but 803 int (foo::bar::baz::bizzle::*) 804 is a pointer to member type. Stroustrup loses again! */ 805 806 type : ptype 807 ; 808 809 typebase /* Implements (approximately): (type-qualifier)* type-specifier */ 810 : '^' typebase 811 { $$ = lookup_pointer_type ($2); } 812 | TYPENAME 813 { $$ = $1.type; } 814 | STRUCT name 815 { $$ = lookup_struct (copy_name ($2), 816 expression_context_block); } 817 | CLASS name 818 { $$ = lookup_struct (copy_name ($2), 819 expression_context_block); } 820 /* "const" and "volatile" are curently ignored. A type qualifier 821 after the type is handled in the ptype rule. I think these could 822 be too. */ 823 ; 824 825 name : NAME { $$ = $1.stoken; } 826 | BLOCKNAME { $$ = $1.stoken; } 827 | TYPENAME { $$ = $1.stoken; } 828 | NAME_OR_INT { $$ = $1.stoken; } 829 ; 830 831 name_not_typename : NAME 832 | BLOCKNAME 833 /* These would be useful if name_not_typename was useful, but it is just 834 a fake for "variable", so these cause reduce/reduce conflicts because 835 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable, 836 =exp) or just an exp. If name_not_typename was ever used in an lvalue 837 context where only a name could occur, this might be useful. 838 | NAME_OR_INT 839 */ 840 ; 841 842 %% 843 844 /* Take care of parsing a number (anything that starts with a digit). 845 Set yylval and return the token type; update lexptr. 846 LEN is the number of characters in it. */ 847 848 /*** Needs some error checking for the float case ***/ 849 850 static int 851 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) 852 { 853 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values 854 here, and we do kind of silly things like cast to unsigned. */ 855 LONGEST n = 0; 856 LONGEST prevn = 0; 857 ULONGEST un; 858 859 int i = 0; 860 int c; 861 int base = input_radix; 862 int unsigned_p = 0; 863 864 /* Number of "L" suffixes encountered. */ 865 int long_p = 0; 866 867 /* We have found a "L" or "U" suffix. */ 868 int found_suffix = 0; 869 870 ULONGEST high_bit; 871 struct type *signed_type; 872 struct type *unsigned_type; 873 874 if (parsed_float) 875 { 876 if (! parse_c_float (parse_gdbarch, p, len, 877 &putithere->typed_val_float.dval, 878 &putithere->typed_val_float.type)) 879 return ERROR; 880 return FLOAT; 881 } 882 883 /* Handle base-switching prefixes 0x, 0t, 0d, 0. */ 884 if (p[0] == '0') 885 switch (p[1]) 886 { 887 case 'x': 888 case 'X': 889 if (len >= 3) 890 { 891 p += 2; 892 base = 16; 893 len -= 2; 894 } 895 break; 896 897 case 't': 898 case 'T': 899 case 'd': 900 case 'D': 901 if (len >= 3) 902 { 903 p += 2; 904 base = 10; 905 len -= 2; 906 } 907 break; 908 909 default: 910 base = 8; 911 break; 912 } 913 914 while (len-- > 0) 915 { 916 c = *p++; 917 if (c >= 'A' && c <= 'Z') 918 c += 'a' - 'A'; 919 if (c != 'l' && c != 'u') 920 n *= base; 921 if (c >= '0' && c <= '9') 922 { 923 if (found_suffix) 924 return ERROR; 925 n += i = c - '0'; 926 } 927 else 928 { 929 if (base > 10 && c >= 'a' && c <= 'f') 930 { 931 if (found_suffix) 932 return ERROR; 933 n += i = c - 'a' + 10; 934 } 935 else if (c == 'l') 936 { 937 ++long_p; 938 found_suffix = 1; 939 } 940 else if (c == 'u') 941 { 942 unsigned_p = 1; 943 found_suffix = 1; 944 } 945 else 946 return ERROR; /* Char not a digit */ 947 } 948 if (i >= base) 949 return ERROR; /* Invalid digit in this base. */ 950 951 /* Portably test for overflow (only works for nonzero values, so make 952 a second check for zero). FIXME: Can't we just make n and prevn 953 unsigned and avoid this? */ 954 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0) 955 unsigned_p = 1; /* Try something unsigned. */ 956 957 /* Portably test for unsigned overflow. 958 FIXME: This check is wrong; for example it doesn't find overflow 959 on 0x123456789 when LONGEST is 32 bits. */ 960 if (c != 'l' && c != 'u' && n != 0) 961 { 962 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n)) 963 error (_("Numeric constant too large.")); 964 } 965 prevn = n; 966 } 967 968 /* An integer constant is an int, a long, or a long long. An L 969 suffix forces it to be long; an LL suffix forces it to be long 970 long. If not forced to a larger size, it gets the first type of 971 the above that it fits in. To figure out whether it fits, we 972 shift it right and see whether anything remains. Note that we 973 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one 974 operation, because many compilers will warn about such a shift 975 (which always produces a zero result). Sometimes gdbarch_int_bit 976 or gdbarch_long_bit will be that big, sometimes not. To deal with 977 the case where it is we just always shift the value more than 978 once, with fewer bits each time. */ 979 980 un = (ULONGEST)n >> 2; 981 if (long_p == 0 982 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0) 983 { 984 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1); 985 986 /* A large decimal (not hex or octal) constant (between INT_MAX 987 and UINT_MAX) is a long or unsigned long, according to ANSI, 988 never an unsigned int, but this code treats it as unsigned 989 int. This probably should be fixed. GCC gives a warning on 990 such constants. */ 991 992 unsigned_type = parse_type->builtin_unsigned_int; 993 signed_type = parse_type->builtin_int; 994 } 995 else if (long_p <= 1 996 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0) 997 { 998 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1); 999 unsigned_type = parse_type->builtin_unsigned_long; 1000 signed_type = parse_type->builtin_long; 1001 } 1002 else 1003 { 1004 int shift; 1005 if (sizeof (ULONGEST) * HOST_CHAR_BIT 1006 < gdbarch_long_long_bit (parse_gdbarch)) 1007 /* A long long does not fit in a LONGEST. */ 1008 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1); 1009 else 1010 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1); 1011 high_bit = (ULONGEST) 1 << shift; 1012 unsigned_type = parse_type->builtin_unsigned_long_long; 1013 signed_type = parse_type->builtin_long_long; 1014 } 1015 1016 putithere->typed_val_int.val = n; 1017 1018 /* If the high bit of the worked out type is set then this number 1019 has to be unsigned. */ 1020 1021 if (unsigned_p || (n & high_bit)) 1022 { 1023 putithere->typed_val_int.type = unsigned_type; 1024 } 1025 else 1026 { 1027 putithere->typed_val_int.type = signed_type; 1028 } 1029 1030 return INT; 1031 } 1032 1033 1034 struct type_push 1035 { 1036 struct type *stored; 1037 struct type_push *next; 1038 }; 1039 1040 static struct type_push *tp_top = NULL; 1041 1042 static void 1043 push_current_type (void) 1044 { 1045 struct type_push *tpnew; 1046 tpnew = (struct type_push *) malloc (sizeof (struct type_push)); 1047 tpnew->next = tp_top; 1048 tpnew->stored = current_type; 1049 current_type = NULL; 1050 tp_top = tpnew; 1051 } 1052 1053 static void 1054 pop_current_type (void) 1055 { 1056 struct type_push *tp = tp_top; 1057 if (tp) 1058 { 1059 current_type = tp->stored; 1060 tp_top = tp->next; 1061 free (tp); 1062 } 1063 } 1064 1065 struct token 1066 { 1067 char *operator; 1068 int token; 1069 enum exp_opcode opcode; 1070 }; 1071 1072 static const struct token tokentab3[] = 1073 { 1074 {"shr", RSH, BINOP_END}, 1075 {"shl", LSH, BINOP_END}, 1076 {"and", ANDAND, BINOP_END}, 1077 {"div", DIV, BINOP_END}, 1078 {"not", NOT, BINOP_END}, 1079 {"mod", MOD, BINOP_END}, 1080 {"inc", INCREMENT, BINOP_END}, 1081 {"dec", DECREMENT, BINOP_END}, 1082 {"xor", XOR, BINOP_END} 1083 }; 1084 1085 static const struct token tokentab2[] = 1086 { 1087 {"or", OR, BINOP_END}, 1088 {"<>", NOTEQUAL, BINOP_END}, 1089 {"<=", LEQ, BINOP_END}, 1090 {">=", GEQ, BINOP_END}, 1091 {":=", ASSIGN, BINOP_END}, 1092 {"::", COLONCOLON, BINOP_END} }; 1093 1094 /* Allocate uppercased var: */ 1095 /* make an uppercased copy of tokstart. */ 1096 static char * uptok (tokstart, namelen) 1097 char *tokstart; 1098 int namelen; 1099 { 1100 int i; 1101 char *uptokstart = (char *)malloc(namelen+1); 1102 for (i = 0;i <= namelen;i++) 1103 { 1104 if ((tokstart[i]>='a' && tokstart[i]<='z')) 1105 uptokstart[i] = tokstart[i]-('a'-'A'); 1106 else 1107 uptokstart[i] = tokstart[i]; 1108 } 1109 uptokstart[namelen]='\0'; 1110 return uptokstart; 1111 } 1112 1113 /* This is set if the previously-returned token was a structure 1114 operator '.'. This is used only when parsing to 1115 do field name completion. */ 1116 static int last_was_structop; 1117 1118 /* Read one token, getting characters through lexptr. */ 1119 1120 static int 1121 yylex (void) 1122 { 1123 int c; 1124 int namelen; 1125 unsigned int i; 1126 char *tokstart; 1127 char *uptokstart; 1128 char *tokptr; 1129 int explen, tempbufindex; 1130 static char *tempbuf; 1131 static int tempbufsize; 1132 int saw_structop = last_was_structop; 1133 1134 last_was_structop = 0; 1135 retry: 1136 1137 prev_lexptr = lexptr; 1138 1139 tokstart = lexptr; 1140 explen = strlen (lexptr); 1141 /* See if it is a special token of length 3. */ 1142 if (explen > 2) 1143 for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++) 1144 if (strncasecmp (tokstart, tokentab3[i].operator, 3) == 0 1145 && (!isalpha (tokentab3[i].operator[0]) || explen == 3 1146 || (!isalpha (tokstart[3]) 1147 && !isdigit (tokstart[3]) && tokstart[3] != '_'))) 1148 { 1149 lexptr += 3; 1150 yylval.opcode = tokentab3[i].opcode; 1151 return tokentab3[i].token; 1152 } 1153 1154 /* See if it is a special token of length 2. */ 1155 if (explen > 1) 1156 for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++) 1157 if (strncasecmp (tokstart, tokentab2[i].operator, 2) == 0 1158 && (!isalpha (tokentab2[i].operator[0]) || explen == 2 1159 || (!isalpha (tokstart[2]) 1160 && !isdigit (tokstart[2]) && tokstart[2] != '_'))) 1161 { 1162 lexptr += 2; 1163 yylval.opcode = tokentab2[i].opcode; 1164 return tokentab2[i].token; 1165 } 1166 1167 switch (c = *tokstart) 1168 { 1169 case 0: 1170 if (saw_structop && search_field) 1171 return COMPLETE; 1172 else 1173 return 0; 1174 1175 case ' ': 1176 case '\t': 1177 case '\n': 1178 lexptr++; 1179 goto retry; 1180 1181 case '\'': 1182 /* We either have a character constant ('0' or '\177' for example) 1183 or we have a quoted symbol reference ('foo(int,int)' in object pascal 1184 for example). */ 1185 lexptr++; 1186 c = *lexptr++; 1187 if (c == '\\') 1188 c = parse_escape (parse_gdbarch, &lexptr); 1189 else if (c == '\'') 1190 error (_("Empty character constant.")); 1191 1192 yylval.typed_val_int.val = c; 1193 yylval.typed_val_int.type = parse_type->builtin_char; 1194 1195 c = *lexptr++; 1196 if (c != '\'') 1197 { 1198 namelen = skip_quoted (tokstart) - tokstart; 1199 if (namelen > 2) 1200 { 1201 lexptr = tokstart + namelen; 1202 if (lexptr[-1] != '\'') 1203 error (_("Unmatched single quote.")); 1204 namelen -= 2; 1205 tokstart++; 1206 uptokstart = uptok(tokstart,namelen); 1207 goto tryname; 1208 } 1209 error (_("Invalid character constant.")); 1210 } 1211 return INT; 1212 1213 case '(': 1214 paren_depth++; 1215 lexptr++; 1216 return c; 1217 1218 case ')': 1219 if (paren_depth == 0) 1220 return 0; 1221 paren_depth--; 1222 lexptr++; 1223 return c; 1224 1225 case ',': 1226 if (comma_terminates && paren_depth == 0) 1227 return 0; 1228 lexptr++; 1229 return c; 1230 1231 case '.': 1232 /* Might be a floating point number. */ 1233 if (lexptr[1] < '0' || lexptr[1] > '9') 1234 { 1235 if (in_parse_field) 1236 last_was_structop = 1; 1237 goto symbol; /* Nope, must be a symbol. */ 1238 } 1239 1240 /* FALL THRU into number case. */ 1241 1242 case '0': 1243 case '1': 1244 case '2': 1245 case '3': 1246 case '4': 1247 case '5': 1248 case '6': 1249 case '7': 1250 case '8': 1251 case '9': 1252 { 1253 /* It's a number. */ 1254 int got_dot = 0, got_e = 0, toktype; 1255 char *p = tokstart; 1256 int hex = input_radix > 10; 1257 1258 if (c == '0' && (p[1] == 'x' || p[1] == 'X')) 1259 { 1260 p += 2; 1261 hex = 1; 1262 } 1263 else if (c == '0' && (p[1]=='t' || p[1]=='T' 1264 || p[1]=='d' || p[1]=='D')) 1265 { 1266 p += 2; 1267 hex = 0; 1268 } 1269 1270 for (;; ++p) 1271 { 1272 /* This test includes !hex because 'e' is a valid hex digit 1273 and thus does not indicate a floating point number when 1274 the radix is hex. */ 1275 if (!hex && !got_e && (*p == 'e' || *p == 'E')) 1276 got_dot = got_e = 1; 1277 /* This test does not include !hex, because a '.' always indicates 1278 a decimal floating point number regardless of the radix. */ 1279 else if (!got_dot && *p == '.') 1280 got_dot = 1; 1281 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 1282 && (*p == '-' || *p == '+')) 1283 /* This is the sign of the exponent, not the end of the 1284 number. */ 1285 continue; 1286 /* We will take any letters or digits. parse_number will 1287 complain if past the radix, or if L or U are not final. */ 1288 else if ((*p < '0' || *p > '9') 1289 && ((*p < 'a' || *p > 'z') 1290 && (*p < 'A' || *p > 'Z'))) 1291 break; 1292 } 1293 toktype = parse_number (tokstart, 1294 p - tokstart, got_dot | got_e, &yylval); 1295 if (toktype == ERROR) 1296 { 1297 char *err_copy = (char *) alloca (p - tokstart + 1); 1298 1299 memcpy (err_copy, tokstart, p - tokstart); 1300 err_copy[p - tokstart] = 0; 1301 error (_("Invalid number \"%s\"."), err_copy); 1302 } 1303 lexptr = p; 1304 return toktype; 1305 } 1306 1307 case '+': 1308 case '-': 1309 case '*': 1310 case '/': 1311 case '|': 1312 case '&': 1313 case '^': 1314 case '~': 1315 case '!': 1316 case '@': 1317 case '<': 1318 case '>': 1319 case '[': 1320 case ']': 1321 case '?': 1322 case ':': 1323 case '=': 1324 case '{': 1325 case '}': 1326 symbol: 1327 lexptr++; 1328 return c; 1329 1330 case '"': 1331 1332 /* Build the gdb internal form of the input string in tempbuf, 1333 translating any standard C escape forms seen. Note that the 1334 buffer is null byte terminated *only* for the convenience of 1335 debugging gdb itself and printing the buffer contents when 1336 the buffer contains no embedded nulls. Gdb does not depend 1337 upon the buffer being null byte terminated, it uses the length 1338 string instead. This allows gdb to handle C strings (as well 1339 as strings in other languages) with embedded null bytes. */ 1340 1341 tokptr = ++tokstart; 1342 tempbufindex = 0; 1343 1344 do { 1345 /* Grow the static temp buffer if necessary, including allocating 1346 the first one on demand. */ 1347 if (tempbufindex + 1 >= tempbufsize) 1348 { 1349 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64); 1350 } 1351 1352 switch (*tokptr) 1353 { 1354 case '\0': 1355 case '"': 1356 /* Do nothing, loop will terminate. */ 1357 break; 1358 case '\\': 1359 tokptr++; 1360 c = parse_escape (parse_gdbarch, &tokptr); 1361 if (c == -1) 1362 { 1363 continue; 1364 } 1365 tempbuf[tempbufindex++] = c; 1366 break; 1367 default: 1368 tempbuf[tempbufindex++] = *tokptr++; 1369 break; 1370 } 1371 } while ((*tokptr != '"') && (*tokptr != '\0')); 1372 if (*tokptr++ != '"') 1373 { 1374 error (_("Unterminated string in expression.")); 1375 } 1376 tempbuf[tempbufindex] = '\0'; /* See note above. */ 1377 yylval.sval.ptr = tempbuf; 1378 yylval.sval.length = tempbufindex; 1379 lexptr = tokptr; 1380 return (STRING); 1381 } 1382 1383 if (!(c == '_' || c == '$' 1384 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 1385 /* We must have come across a bad character (e.g. ';'). */ 1386 error (_("Invalid character '%c' in expression."), c); 1387 1388 /* It's a name. See how long it is. */ 1389 namelen = 0; 1390 for (c = tokstart[namelen]; 1391 (c == '_' || c == '$' || (c >= '0' && c <= '9') 1392 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');) 1393 { 1394 /* Template parameter lists are part of the name. 1395 FIXME: This mishandles `print $a<4&&$a>3'. */ 1396 if (c == '<') 1397 { 1398 int i = namelen; 1399 int nesting_level = 1; 1400 while (tokstart[++i]) 1401 { 1402 if (tokstart[i] == '<') 1403 nesting_level++; 1404 else if (tokstart[i] == '>') 1405 { 1406 if (--nesting_level == 0) 1407 break; 1408 } 1409 } 1410 if (tokstart[i] == '>') 1411 namelen = i; 1412 else 1413 break; 1414 } 1415 1416 /* do NOT uppercase internals because of registers !!! */ 1417 c = tokstart[++namelen]; 1418 } 1419 1420 uptokstart = uptok(tokstart,namelen); 1421 1422 /* The token "if" terminates the expression and is NOT 1423 removed from the input stream. */ 1424 if (namelen == 2 && uptokstart[0] == 'I' && uptokstart[1] == 'F') 1425 { 1426 free (uptokstart); 1427 return 0; 1428 } 1429 1430 lexptr += namelen; 1431 1432 tryname: 1433 1434 /* Catch specific keywords. Should be done with a data structure. */ 1435 switch (namelen) 1436 { 1437 case 6: 1438 if (strcmp (uptokstart, "OBJECT") == 0) 1439 { 1440 free (uptokstart); 1441 return CLASS; 1442 } 1443 if (strcmp (uptokstart, "RECORD") == 0) 1444 { 1445 free (uptokstart); 1446 return STRUCT; 1447 } 1448 if (strcmp (uptokstart, "SIZEOF") == 0) 1449 { 1450 free (uptokstart); 1451 return SIZEOF; 1452 } 1453 break; 1454 case 5: 1455 if (strcmp (uptokstart, "CLASS") == 0) 1456 { 1457 free (uptokstart); 1458 return CLASS; 1459 } 1460 if (strcmp (uptokstart, "FALSE") == 0) 1461 { 1462 yylval.lval = 0; 1463 free (uptokstart); 1464 return FALSEKEYWORD; 1465 } 1466 break; 1467 case 4: 1468 if (strcmp (uptokstart, "TRUE") == 0) 1469 { 1470 yylval.lval = 1; 1471 free (uptokstart); 1472 return TRUEKEYWORD; 1473 } 1474 if (strcmp (uptokstart, "SELF") == 0) 1475 { 1476 /* Here we search for 'this' like 1477 inserted in FPC stabs debug info. */ 1478 static const char this_name[] = "this"; 1479 1480 if (lookup_symbol (this_name, expression_context_block, 1481 VAR_DOMAIN, (int *) NULL)) 1482 { 1483 free (uptokstart); 1484 return THIS; 1485 } 1486 } 1487 break; 1488 default: 1489 break; 1490 } 1491 1492 yylval.sval.ptr = tokstart; 1493 yylval.sval.length = namelen; 1494 1495 if (*tokstart == '$') 1496 { 1497 char c; 1498 /* $ is the normal prefix for pascal hexadecimal values 1499 but this conflicts with the GDB use for debugger variables 1500 so in expression to enter hexadecimal values 1501 we still need to use C syntax with 0xff */ 1502 write_dollar_variable (yylval.sval); 1503 c = tokstart[namelen]; 1504 tokstart[namelen] = 0; 1505 intvar = lookup_only_internalvar (++tokstart); 1506 --tokstart; 1507 tokstart[namelen] = c; 1508 free (uptokstart); 1509 return VARIABLE; 1510 } 1511 1512 /* Use token-type BLOCKNAME for symbols that happen to be defined as 1513 functions or symtabs. If this is not so, then ... 1514 Use token-type TYPENAME for symbols that happen to be defined 1515 currently as names of types; NAME for other symbols. 1516 The caller is not constrained to care about the distinction. */ 1517 { 1518 char *tmp = copy_name (yylval.sval); 1519 struct symbol *sym; 1520 int is_a_field_of_this = 0; 1521 int is_a_field = 0; 1522 int hextype; 1523 1524 1525 if (search_field && current_type) 1526 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL); 1527 if (is_a_field || in_parse_field) 1528 sym = NULL; 1529 else 1530 sym = lookup_symbol (tmp, expression_context_block, 1531 VAR_DOMAIN, &is_a_field_of_this); 1532 /* second chance uppercased (as Free Pascal does). */ 1533 if (!sym && !is_a_field_of_this && !is_a_field) 1534 { 1535 for (i = 0; i <= namelen; i++) 1536 { 1537 if ((tmp[i] >= 'a' && tmp[i] <= 'z')) 1538 tmp[i] -= ('a'-'A'); 1539 } 1540 if (search_field && current_type) 1541 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL); 1542 if (is_a_field || in_parse_field) 1543 sym = NULL; 1544 else 1545 sym = lookup_symbol (tmp, expression_context_block, 1546 VAR_DOMAIN, &is_a_field_of_this); 1547 if (sym || is_a_field_of_this || is_a_field) 1548 for (i = 0; i <= namelen; i++) 1549 { 1550 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z')) 1551 tokstart[i] -= ('a'-'A'); 1552 } 1553 } 1554 /* Third chance Capitalized (as GPC does). */ 1555 if (!sym && !is_a_field_of_this && !is_a_field) 1556 { 1557 for (i = 0; i <= namelen; i++) 1558 { 1559 if (i == 0) 1560 { 1561 if ((tmp[i] >= 'a' && tmp[i] <= 'z')) 1562 tmp[i] -= ('a'-'A'); 1563 } 1564 else 1565 if ((tmp[i] >= 'A' && tmp[i] <= 'Z')) 1566 tmp[i] -= ('A'-'a'); 1567 } 1568 if (search_field && current_type) 1569 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL); 1570 if (is_a_field || in_parse_field) 1571 sym = NULL; 1572 else 1573 sym = lookup_symbol (tmp, expression_context_block, 1574 VAR_DOMAIN, &is_a_field_of_this); 1575 if (sym || is_a_field_of_this || is_a_field) 1576 for (i = 0; i <= namelen; i++) 1577 { 1578 if (i == 0) 1579 { 1580 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z')) 1581 tokstart[i] -= ('a'-'A'); 1582 } 1583 else 1584 if ((tokstart[i] >= 'A' && tokstart[i] <= 'Z')) 1585 tokstart[i] -= ('A'-'a'); 1586 } 1587 } 1588 1589 if (is_a_field) 1590 { 1591 tempbuf = (char *) realloc (tempbuf, namelen + 1); 1592 strncpy (tempbuf, tokstart, namelen); tempbuf [namelen] = 0; 1593 yylval.sval.ptr = tempbuf; 1594 yylval.sval.length = namelen; 1595 free (uptokstart); 1596 return FIELDNAME; 1597 } 1598 /* Call lookup_symtab, not lookup_partial_symtab, in case there are 1599 no psymtabs (coff, xcoff, or some future change to blow away the 1600 psymtabs once once symbols are read). */ 1601 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) 1602 || lookup_symtab (tmp)) 1603 { 1604 yylval.ssym.sym = sym; 1605 yylval.ssym.is_a_field_of_this = is_a_field_of_this; 1606 free (uptokstart); 1607 return BLOCKNAME; 1608 } 1609 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF) 1610 { 1611 #if 1 1612 /* Despite the following flaw, we need to keep this code enabled. 1613 Because we can get called from check_stub_method, if we don't 1614 handle nested types then it screws many operations in any 1615 program which uses nested types. */ 1616 /* In "A::x", if x is a member function of A and there happens 1617 to be a type (nested or not, since the stabs don't make that 1618 distinction) named x, then this code incorrectly thinks we 1619 are dealing with nested types rather than a member function. */ 1620 1621 char *p; 1622 char *namestart; 1623 struct symbol *best_sym; 1624 1625 /* Look ahead to detect nested types. This probably should be 1626 done in the grammar, but trying seemed to introduce a lot 1627 of shift/reduce and reduce/reduce conflicts. It's possible 1628 that it could be done, though. Or perhaps a non-grammar, but 1629 less ad hoc, approach would work well. */ 1630 1631 /* Since we do not currently have any way of distinguishing 1632 a nested type from a non-nested one (the stabs don't tell 1633 us whether a type is nested), we just ignore the 1634 containing type. */ 1635 1636 p = lexptr; 1637 best_sym = sym; 1638 while (1) 1639 { 1640 /* Skip whitespace. */ 1641 while (*p == ' ' || *p == '\t' || *p == '\n') 1642 ++p; 1643 if (*p == ':' && p[1] == ':') 1644 { 1645 /* Skip the `::'. */ 1646 p += 2; 1647 /* Skip whitespace. */ 1648 while (*p == ' ' || *p == '\t' || *p == '\n') 1649 ++p; 1650 namestart = p; 1651 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9') 1652 || (*p >= 'a' && *p <= 'z') 1653 || (*p >= 'A' && *p <= 'Z')) 1654 ++p; 1655 if (p != namestart) 1656 { 1657 struct symbol *cur_sym; 1658 /* As big as the whole rest of the expression, which is 1659 at least big enough. */ 1660 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3); 1661 char *tmp1; 1662 1663 tmp1 = ncopy; 1664 memcpy (tmp1, tmp, strlen (tmp)); 1665 tmp1 += strlen (tmp); 1666 memcpy (tmp1, "::", 2); 1667 tmp1 += 2; 1668 memcpy (tmp1, namestart, p - namestart); 1669 tmp1[p - namestart] = '\0'; 1670 cur_sym = lookup_symbol (ncopy, expression_context_block, 1671 VAR_DOMAIN, (int *) NULL); 1672 if (cur_sym) 1673 { 1674 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF) 1675 { 1676 best_sym = cur_sym; 1677 lexptr = p; 1678 } 1679 else 1680 break; 1681 } 1682 else 1683 break; 1684 } 1685 else 1686 break; 1687 } 1688 else 1689 break; 1690 } 1691 1692 yylval.tsym.type = SYMBOL_TYPE (best_sym); 1693 #else /* not 0 */ 1694 yylval.tsym.type = SYMBOL_TYPE (sym); 1695 #endif /* not 0 */ 1696 free (uptokstart); 1697 return TYPENAME; 1698 } 1699 yylval.tsym.type 1700 = language_lookup_primitive_type_by_name (parse_language, 1701 parse_gdbarch, tmp); 1702 if (yylval.tsym.type != NULL) 1703 { 1704 free (uptokstart); 1705 return TYPENAME; 1706 } 1707 1708 /* Input names that aren't symbols but ARE valid hex numbers, 1709 when the input radix permits them, can be names or numbers 1710 depending on the parse. Note we support radixes > 16 here. */ 1711 if (!sym 1712 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) 1713 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))) 1714 { 1715 YYSTYPE newlval; /* Its value is ignored. */ 1716 hextype = parse_number (tokstart, namelen, 0, &newlval); 1717 if (hextype == INT) 1718 { 1719 yylval.ssym.sym = sym; 1720 yylval.ssym.is_a_field_of_this = is_a_field_of_this; 1721 free (uptokstart); 1722 return NAME_OR_INT; 1723 } 1724 } 1725 1726 free(uptokstart); 1727 /* Any other kind of symbol. */ 1728 yylval.ssym.sym = sym; 1729 yylval.ssym.is_a_field_of_this = is_a_field_of_this; 1730 return NAME; 1731 } 1732 } 1733 1734 void 1735 yyerror (msg) 1736 char *msg; 1737 { 1738 if (prev_lexptr) 1739 lexptr = prev_lexptr; 1740 1741 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr); 1742 } 1743