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