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