1 /* YACC parser for C expressions, for GDB. 2 Copyright (C) 1986-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 /* Parse a C expression from text in a string, 20 and return the result as a struct expression pointer. 21 That structure contains arithmetic operations in reverse polish, 22 with constants represented by operations that are followed by special data. 23 See expression.h for the details of the format. 24 What is important here is that it can be built up sequentially 25 during the process of parsing; the lower levels of the tree always 26 come first in the result. 27 28 Note that malloc's and realloc's in this file are transformed to 29 xmalloc and xrealloc respectively by the same sed command in the 30 makefile that remaps any other malloc/realloc inserted by the parser 31 generator. Doing this with #defines and trying to control the interaction 32 with include files (<malloc.h> and <stdlib.h> for example) just became 33 too messy, particularly when such includes can be inserted at random 34 times by the parser generator. */ 35 36 %{ 37 38 #include "defs.h" 39 #include "gdb_string.h" 40 #include <ctype.h> 41 #include "expression.h" 42 #include "value.h" 43 #include "parser-defs.h" 44 #include "language.h" 45 #include "c-lang.h" 46 #include "bfd.h" /* Required by objfiles.h. */ 47 #include "symfile.h" /* Required by objfiles.h. */ 48 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 49 #include "charset.h" 50 #include "block.h" 51 #include "cp-support.h" 52 #include "dfp.h" 53 #include "gdb_assert.h" 54 #include "macroscope.h" 55 #include "objc-lang.h" 56 #include "typeprint.h" 57 #include "cp-abi.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 c_maxdepth 69 #define yyparse c_parse_internal 70 #define yylex c_lex 71 #define yyerror c_error 72 #define yylval c_lval 73 #define yychar c_char 74 #define yydebug c_debug 75 #define yypact c_pact 76 #define yyr1 c_r1 77 #define yyr2 c_r2 78 #define yydef c_def 79 #define yychk c_chk 80 #define yypgo c_pgo 81 #define yyact c_act 82 #define yyexca c_exca 83 #define yyerrflag c_errflag 84 #define yynerrs c_nerrs 85 #define yyps c_ps 86 #define yypv c_pv 87 #define yys c_s 88 #define yy_yys c_yys 89 #define yystate c_state 90 #define yytmp c_tmp 91 #define yyv c_v 92 #define yy_yyv c_yyv 93 #define yyval c_val 94 #define yylloc c_lloc 95 #define yyreds c_reds /* With YYDEBUG defined */ 96 #define yytoks c_toks /* With YYDEBUG defined */ 97 #define yyname c_name /* With YYDEBUG defined */ 98 #define yyrule c_rule /* With YYDEBUG defined */ 99 #define yylhs c_yylhs 100 #define yylen c_yylen 101 #define yydefred c_yydefred 102 #define yydgoto c_yydgoto 103 #define yysindex c_yysindex 104 #define yyrindex c_yyrindex 105 #define yygindex c_yygindex 106 #define yytable c_yytable 107 #define yycheck c_yycheck 108 #define yyss c_yyss 109 #define yysslim c_yysslim 110 #define yyssp c_yyssp 111 #define yystacksize c_yystacksize 112 #define yyvs c_yyvs 113 #define yyvsp c_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 %} 128 129 /* Although the yacc "value" of an expression is not used, 130 since the result is stored in the structure being created, 131 other node types do have values. */ 132 133 %union 134 { 135 LONGEST lval; 136 struct { 137 LONGEST val; 138 struct type *type; 139 } typed_val_int; 140 struct { 141 DOUBLEST dval; 142 struct type *type; 143 } typed_val_float; 144 struct { 145 gdb_byte val[16]; 146 struct type *type; 147 } typed_val_decfloat; 148 struct symbol *sym; 149 struct type *tval; 150 struct stoken sval; 151 struct typed_stoken tsval; 152 struct ttype tsym; 153 struct symtoken ssym; 154 int voidval; 155 struct block *bval; 156 enum exp_opcode opcode; 157 struct internalvar *ivar; 158 159 struct stoken_vector svec; 160 VEC (type_ptr) *tvec; 161 int *ivec; 162 163 struct type_stack *type_stack; 164 165 struct objc_class_str class; 166 } 167 168 %{ 169 /* YYSTYPE gets defined by %union */ 170 static int parse_number (char *, int, int, YYSTYPE *); 171 static struct stoken operator_stoken (const char *); 172 static void check_parameter_typelist (VEC (type_ptr) *); 173 %} 174 175 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly 176 %type <lval> rcurly 177 %type <tval> type typebase 178 %type <tvec> nonempty_typelist func_mod parameter_typelist 179 /* %type <bval> block */ 180 181 /* Fancy type parsing. */ 182 %type <tval> ptype 183 %type <lval> array_mod 184 %type <tval> conversion_type_id 185 186 %type <type_stack> ptr_operator_ts abs_decl direct_abs_decl 187 188 %token <typed_val_int> INT 189 %token <typed_val_float> FLOAT 190 %token <typed_val_decfloat> DECFLOAT 191 192 /* Both NAME and TYPENAME tokens represent symbols in the input, 193 and both convey their data as strings. 194 But a TYPENAME is a string that happens to be defined as a typedef 195 or builtin type name (such as int or char) 196 and a NAME is any other symbol. 197 Contexts where this distinction is not important can use the 198 nonterminal "name", which matches either NAME or TYPENAME. */ 199 200 %token <tsval> STRING 201 %token <sval> NSSTRING /* ObjC Foundation "NSString" literal */ 202 %token SELECTOR /* ObjC "@selector" pseudo-operator */ 203 %token <tsval> CHAR 204 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */ 205 %token <ssym> UNKNOWN_CPP_NAME 206 %token <voidval> COMPLETE 207 %token <tsym> TYPENAME 208 %token <class> CLASSNAME /* ObjC Class name */ 209 %type <sval> name 210 %type <svec> string_exp 211 %type <ssym> name_not_typename 212 %type <tsym> typename 213 214 /* This is like a '[' token, but is only generated when parsing 215 Objective C. This lets us reuse the same parser without 216 erroneously parsing ObjC-specific expressions in C. */ 217 %token OBJC_LBRAC 218 219 /* A NAME_OR_INT is a symbol which is not known in the symbol table, 220 but which would parse as a valid number in the current input radix. 221 E.g. "c" when input_radix==16. Depending on the parse, it will be 222 turned into a name or into a number. */ 223 224 %token <ssym> NAME_OR_INT 225 226 %token OPERATOR 227 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON 228 %token TEMPLATE 229 %token ERROR 230 %token NEW DELETE 231 %type <sval> operator 232 %token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST 233 %token ENTRY 234 %token TYPEOF 235 %token DECLTYPE 236 237 /* Special type cases, put in to allow the parser to distinguish different 238 legal basetypes. */ 239 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD 240 241 %token <sval> VARIABLE 242 243 %token <opcode> ASSIGN_MODIFY 244 245 /* C++ */ 246 %token TRUEKEYWORD 247 %token FALSEKEYWORD 248 249 250 %left ',' 251 %left ABOVE_COMMA 252 %right '=' ASSIGN_MODIFY 253 %right '?' 254 %left OROR 255 %left ANDAND 256 %left '|' 257 %left '^' 258 %left '&' 259 %left EQUAL NOTEQUAL 260 %left '<' '>' LEQ GEQ 261 %left LSH RSH 262 %left '@' 263 %left '+' '-' 264 %left '*' '/' '%' 265 %right UNARY INCREMENT DECREMENT 266 %right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '(' 267 %token <ssym> BLOCKNAME 268 %token <bval> FILENAME 269 %type <bval> block 270 %left COLONCOLON 271 272 %token DOTDOTDOT 273 274 275 %% 276 277 start : exp1 278 | type_exp 279 ; 280 281 type_exp: type 282 { write_exp_elt_opcode(OP_TYPE); 283 write_exp_elt_type($1); 284 write_exp_elt_opcode(OP_TYPE);} 285 | TYPEOF '(' exp ')' 286 { 287 write_exp_elt_opcode (OP_TYPEOF); 288 } 289 | TYPEOF '(' type ')' 290 { 291 write_exp_elt_opcode (OP_TYPE); 292 write_exp_elt_type ($3); 293 write_exp_elt_opcode (OP_TYPE); 294 } 295 | DECLTYPE '(' exp ')' 296 { 297 write_exp_elt_opcode (OP_DECLTYPE); 298 } 299 ; 300 301 /* Expressions, including the comma operator. */ 302 exp1 : exp 303 | exp1 ',' exp 304 { write_exp_elt_opcode (BINOP_COMMA); } 305 ; 306 307 /* Expressions, not including the comma operator. */ 308 exp : '*' exp %prec UNARY 309 { write_exp_elt_opcode (UNOP_IND); } 310 ; 311 312 exp : '&' exp %prec UNARY 313 { write_exp_elt_opcode (UNOP_ADDR); } 314 ; 315 316 exp : '-' exp %prec UNARY 317 { write_exp_elt_opcode (UNOP_NEG); } 318 ; 319 320 exp : '+' exp %prec UNARY 321 { write_exp_elt_opcode (UNOP_PLUS); } 322 ; 323 324 exp : '!' exp %prec UNARY 325 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } 326 ; 327 328 exp : '~' exp %prec UNARY 329 { write_exp_elt_opcode (UNOP_COMPLEMENT); } 330 ; 331 332 exp : INCREMENT exp %prec UNARY 333 { write_exp_elt_opcode (UNOP_PREINCREMENT); } 334 ; 335 336 exp : DECREMENT exp %prec UNARY 337 { write_exp_elt_opcode (UNOP_PREDECREMENT); } 338 ; 339 340 exp : exp INCREMENT %prec UNARY 341 { write_exp_elt_opcode (UNOP_POSTINCREMENT); } 342 ; 343 344 exp : exp DECREMENT %prec UNARY 345 { write_exp_elt_opcode (UNOP_POSTDECREMENT); } 346 ; 347 348 exp : SIZEOF exp %prec UNARY 349 { write_exp_elt_opcode (UNOP_SIZEOF); } 350 ; 351 352 exp : exp ARROW name 353 { write_exp_elt_opcode (STRUCTOP_PTR); 354 write_exp_string ($3); 355 write_exp_elt_opcode (STRUCTOP_PTR); } 356 ; 357 358 exp : exp ARROW name COMPLETE 359 { mark_struct_expression (); 360 write_exp_elt_opcode (STRUCTOP_PTR); 361 write_exp_string ($3); 362 write_exp_elt_opcode (STRUCTOP_PTR); } 363 ; 364 365 exp : exp ARROW COMPLETE 366 { struct stoken s; 367 mark_struct_expression (); 368 write_exp_elt_opcode (STRUCTOP_PTR); 369 s.ptr = ""; 370 s.length = 0; 371 write_exp_string (s); 372 write_exp_elt_opcode (STRUCTOP_PTR); } 373 ; 374 375 exp : exp ARROW qualified_name 376 { /* exp->type::name becomes exp->*(&type::name) */ 377 /* Note: this doesn't work if name is a 378 static member! FIXME */ 379 write_exp_elt_opcode (UNOP_ADDR); 380 write_exp_elt_opcode (STRUCTOP_MPTR); } 381 ; 382 383 exp : exp ARROW_STAR exp 384 { write_exp_elt_opcode (STRUCTOP_MPTR); } 385 ; 386 387 exp : exp '.' name 388 { write_exp_elt_opcode (STRUCTOP_STRUCT); 389 write_exp_string ($3); 390 write_exp_elt_opcode (STRUCTOP_STRUCT); } 391 ; 392 393 exp : exp '.' name COMPLETE 394 { mark_struct_expression (); 395 write_exp_elt_opcode (STRUCTOP_STRUCT); 396 write_exp_string ($3); 397 write_exp_elt_opcode (STRUCTOP_STRUCT); } 398 ; 399 400 exp : exp '.' COMPLETE 401 { struct stoken s; 402 mark_struct_expression (); 403 write_exp_elt_opcode (STRUCTOP_STRUCT); 404 s.ptr = ""; 405 s.length = 0; 406 write_exp_string (s); 407 write_exp_elt_opcode (STRUCTOP_STRUCT); } 408 ; 409 410 exp : exp '.' qualified_name 411 { /* exp.type::name becomes exp.*(&type::name) */ 412 /* Note: this doesn't work if name is a 413 static member! FIXME */ 414 write_exp_elt_opcode (UNOP_ADDR); 415 write_exp_elt_opcode (STRUCTOP_MEMBER); } 416 ; 417 418 exp : exp DOT_STAR exp 419 { write_exp_elt_opcode (STRUCTOP_MEMBER); } 420 ; 421 422 exp : exp '[' exp1 ']' 423 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 424 ; 425 426 exp : exp OBJC_LBRAC exp1 ']' 427 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 428 ; 429 430 /* 431 * The rules below parse ObjC message calls of the form: 432 * '[' target selector {':' argument}* ']' 433 */ 434 435 exp : OBJC_LBRAC TYPENAME 436 { 437 CORE_ADDR class; 438 439 class = lookup_objc_class (parse_gdbarch, 440 copy_name ($2.stoken)); 441 if (class == 0) 442 error (_("%s is not an ObjC Class"), 443 copy_name ($2.stoken)); 444 write_exp_elt_opcode (OP_LONG); 445 write_exp_elt_type (parse_type->builtin_int); 446 write_exp_elt_longcst ((LONGEST) class); 447 write_exp_elt_opcode (OP_LONG); 448 start_msglist(); 449 } 450 msglist ']' 451 { write_exp_elt_opcode (OP_OBJC_MSGCALL); 452 end_msglist(); 453 write_exp_elt_opcode (OP_OBJC_MSGCALL); 454 } 455 ; 456 457 exp : OBJC_LBRAC CLASSNAME 458 { 459 write_exp_elt_opcode (OP_LONG); 460 write_exp_elt_type (parse_type->builtin_int); 461 write_exp_elt_longcst ((LONGEST) $2.class); 462 write_exp_elt_opcode (OP_LONG); 463 start_msglist(); 464 } 465 msglist ']' 466 { write_exp_elt_opcode (OP_OBJC_MSGCALL); 467 end_msglist(); 468 write_exp_elt_opcode (OP_OBJC_MSGCALL); 469 } 470 ; 471 472 exp : OBJC_LBRAC exp 473 { start_msglist(); } 474 msglist ']' 475 { write_exp_elt_opcode (OP_OBJC_MSGCALL); 476 end_msglist(); 477 write_exp_elt_opcode (OP_OBJC_MSGCALL); 478 } 479 ; 480 481 msglist : name 482 { add_msglist(&$1, 0); } 483 | msgarglist 484 ; 485 486 msgarglist : msgarg 487 | msgarglist msgarg 488 ; 489 490 msgarg : name ':' exp 491 { add_msglist(&$1, 1); } 492 | ':' exp /* Unnamed arg. */ 493 { add_msglist(0, 1); } 494 | ',' exp /* Variable number of args. */ 495 { add_msglist(0, 0); } 496 ; 497 498 exp : exp '(' 499 /* This is to save the value of arglist_len 500 being accumulated by an outer function call. */ 501 { start_arglist (); } 502 arglist ')' %prec ARROW 503 { write_exp_elt_opcode (OP_FUNCALL); 504 write_exp_elt_longcst ((LONGEST) end_arglist ()); 505 write_exp_elt_opcode (OP_FUNCALL); } 506 ; 507 508 exp : UNKNOWN_CPP_NAME '(' 509 { 510 /* This could potentially be a an argument defined 511 lookup function (Koenig). */ 512 write_exp_elt_opcode (OP_ADL_FUNC); 513 write_exp_elt_block (expression_context_block); 514 write_exp_elt_sym (NULL); /* Placeholder. */ 515 write_exp_string ($1.stoken); 516 write_exp_elt_opcode (OP_ADL_FUNC); 517 518 /* This is to save the value of arglist_len 519 being accumulated by an outer function call. */ 520 521 start_arglist (); 522 } 523 arglist ')' %prec ARROW 524 { 525 write_exp_elt_opcode (OP_FUNCALL); 526 write_exp_elt_longcst ((LONGEST) end_arglist ()); 527 write_exp_elt_opcode (OP_FUNCALL); 528 } 529 ; 530 531 lcurly : '{' 532 { start_arglist (); } 533 ; 534 535 arglist : 536 ; 537 538 arglist : exp 539 { arglist_len = 1; } 540 ; 541 542 arglist : arglist ',' exp %prec ABOVE_COMMA 543 { arglist_len++; } 544 ; 545 546 exp : exp '(' parameter_typelist ')' const_or_volatile 547 { int i; 548 VEC (type_ptr) *type_list = $3; 549 struct type *type_elt; 550 LONGEST len = VEC_length (type_ptr, type_list); 551 552 write_exp_elt_opcode (TYPE_INSTANCE); 553 write_exp_elt_longcst (len); 554 for (i = 0; 555 VEC_iterate (type_ptr, type_list, i, type_elt); 556 ++i) 557 write_exp_elt_type (type_elt); 558 write_exp_elt_longcst(len); 559 write_exp_elt_opcode (TYPE_INSTANCE); 560 VEC_free (type_ptr, type_list); 561 } 562 ; 563 564 rcurly : '}' 565 { $$ = end_arglist () - 1; } 566 ; 567 exp : lcurly arglist rcurly %prec ARROW 568 { write_exp_elt_opcode (OP_ARRAY); 569 write_exp_elt_longcst ((LONGEST) 0); 570 write_exp_elt_longcst ((LONGEST) $3); 571 write_exp_elt_opcode (OP_ARRAY); } 572 ; 573 574 exp : lcurly type_exp rcurly exp %prec UNARY 575 { write_exp_elt_opcode (UNOP_MEMVAL_TYPE); } 576 ; 577 578 exp : '(' type_exp ')' exp %prec UNARY 579 { write_exp_elt_opcode (UNOP_CAST_TYPE); } 580 ; 581 582 exp : '(' exp1 ')' 583 { } 584 ; 585 586 /* Binary operators in order of decreasing precedence. */ 587 588 exp : exp '@' exp 589 { write_exp_elt_opcode (BINOP_REPEAT); } 590 ; 591 592 exp : exp '*' exp 593 { write_exp_elt_opcode (BINOP_MUL); } 594 ; 595 596 exp : exp '/' exp 597 { write_exp_elt_opcode (BINOP_DIV); } 598 ; 599 600 exp : exp '%' exp 601 { write_exp_elt_opcode (BINOP_REM); } 602 ; 603 604 exp : exp '+' exp 605 { write_exp_elt_opcode (BINOP_ADD); } 606 ; 607 608 exp : exp '-' exp 609 { write_exp_elt_opcode (BINOP_SUB); } 610 ; 611 612 exp : exp LSH exp 613 { write_exp_elt_opcode (BINOP_LSH); } 614 ; 615 616 exp : exp RSH exp 617 { write_exp_elt_opcode (BINOP_RSH); } 618 ; 619 620 exp : exp EQUAL exp 621 { write_exp_elt_opcode (BINOP_EQUAL); } 622 ; 623 624 exp : exp NOTEQUAL exp 625 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 626 ; 627 628 exp : exp LEQ exp 629 { write_exp_elt_opcode (BINOP_LEQ); } 630 ; 631 632 exp : exp GEQ exp 633 { write_exp_elt_opcode (BINOP_GEQ); } 634 ; 635 636 exp : exp '<' exp 637 { write_exp_elt_opcode (BINOP_LESS); } 638 ; 639 640 exp : exp '>' exp 641 { write_exp_elt_opcode (BINOP_GTR); } 642 ; 643 644 exp : exp '&' exp 645 { write_exp_elt_opcode (BINOP_BITWISE_AND); } 646 ; 647 648 exp : exp '^' exp 649 { write_exp_elt_opcode (BINOP_BITWISE_XOR); } 650 ; 651 652 exp : exp '|' exp 653 { write_exp_elt_opcode (BINOP_BITWISE_IOR); } 654 ; 655 656 exp : exp ANDAND exp 657 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 658 ; 659 660 exp : exp OROR exp 661 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 662 ; 663 664 exp : exp '?' exp ':' exp %prec '?' 665 { write_exp_elt_opcode (TERNOP_COND); } 666 ; 667 668 exp : exp '=' exp 669 { write_exp_elt_opcode (BINOP_ASSIGN); } 670 ; 671 672 exp : exp ASSIGN_MODIFY exp 673 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); 674 write_exp_elt_opcode ($2); 675 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } 676 ; 677 678 exp : INT 679 { write_exp_elt_opcode (OP_LONG); 680 write_exp_elt_type ($1.type); 681 write_exp_elt_longcst ((LONGEST)($1.val)); 682 write_exp_elt_opcode (OP_LONG); } 683 ; 684 685 exp : CHAR 686 { 687 struct stoken_vector vec; 688 vec.len = 1; 689 vec.tokens = &$1; 690 write_exp_string_vector ($1.type, &vec); 691 } 692 ; 693 694 exp : NAME_OR_INT 695 { YYSTYPE val; 696 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val); 697 write_exp_elt_opcode (OP_LONG); 698 write_exp_elt_type (val.typed_val_int.type); 699 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val); 700 write_exp_elt_opcode (OP_LONG); 701 } 702 ; 703 704 705 exp : FLOAT 706 { write_exp_elt_opcode (OP_DOUBLE); 707 write_exp_elt_type ($1.type); 708 write_exp_elt_dblcst ($1.dval); 709 write_exp_elt_opcode (OP_DOUBLE); } 710 ; 711 712 exp : DECFLOAT 713 { write_exp_elt_opcode (OP_DECFLOAT); 714 write_exp_elt_type ($1.type); 715 write_exp_elt_decfloatcst ($1.val); 716 write_exp_elt_opcode (OP_DECFLOAT); } 717 ; 718 719 exp : variable 720 ; 721 722 exp : VARIABLE 723 { 724 write_dollar_variable ($1); 725 } 726 ; 727 728 exp : SELECTOR '(' name ')' 729 { 730 write_exp_elt_opcode (OP_OBJC_SELECTOR); 731 write_exp_string ($3); 732 write_exp_elt_opcode (OP_OBJC_SELECTOR); } 733 ; 734 735 exp : SIZEOF '(' type ')' %prec UNARY 736 { write_exp_elt_opcode (OP_LONG); 737 write_exp_elt_type (lookup_signed_typename 738 (parse_language, parse_gdbarch, 739 "int")); 740 CHECK_TYPEDEF ($3); 741 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3)); 742 write_exp_elt_opcode (OP_LONG); } 743 ; 744 745 exp : REINTERPRET_CAST '<' type_exp '>' '(' exp ')' %prec UNARY 746 { write_exp_elt_opcode (UNOP_REINTERPRET_CAST); } 747 ; 748 749 exp : STATIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY 750 { write_exp_elt_opcode (UNOP_CAST_TYPE); } 751 ; 752 753 exp : DYNAMIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY 754 { write_exp_elt_opcode (UNOP_DYNAMIC_CAST); } 755 ; 756 757 exp : CONST_CAST '<' type_exp '>' '(' exp ')' %prec UNARY 758 { /* We could do more error checking here, but 759 it doesn't seem worthwhile. */ 760 write_exp_elt_opcode (UNOP_CAST_TYPE); } 761 ; 762 763 string_exp: 764 STRING 765 { 766 /* We copy the string here, and not in the 767 lexer, to guarantee that we do not leak a 768 string. Note that we follow the 769 NUL-termination convention of the 770 lexer. */ 771 struct typed_stoken *vec = XNEW (struct typed_stoken); 772 $$.len = 1; 773 $$.tokens = vec; 774 775 vec->type = $1.type; 776 vec->length = $1.length; 777 vec->ptr = malloc ($1.length + 1); 778 memcpy (vec->ptr, $1.ptr, $1.length + 1); 779 } 780 781 | string_exp STRING 782 { 783 /* Note that we NUL-terminate here, but just 784 for convenience. */ 785 char *p; 786 ++$$.len; 787 $$.tokens = realloc ($$.tokens, 788 $$.len * sizeof (struct typed_stoken)); 789 790 p = malloc ($2.length + 1); 791 memcpy (p, $2.ptr, $2.length + 1); 792 793 $$.tokens[$$.len - 1].type = $2.type; 794 $$.tokens[$$.len - 1].length = $2.length; 795 $$.tokens[$$.len - 1].ptr = p; 796 } 797 ; 798 799 exp : string_exp 800 { 801 int i; 802 enum c_string_type type = C_STRING; 803 804 for (i = 0; i < $1.len; ++i) 805 { 806 switch ($1.tokens[i].type) 807 { 808 case C_STRING: 809 break; 810 case C_WIDE_STRING: 811 case C_STRING_16: 812 case C_STRING_32: 813 if (type != C_STRING 814 && type != $1.tokens[i].type) 815 error (_("Undefined string concatenation.")); 816 type = $1.tokens[i].type; 817 break; 818 default: 819 /* internal error */ 820 internal_error (__FILE__, __LINE__, 821 "unrecognized type in string concatenation"); 822 } 823 } 824 825 write_exp_string_vector (type, &$1); 826 for (i = 0; i < $1.len; ++i) 827 free ($1.tokens[i].ptr); 828 free ($1.tokens); 829 } 830 ; 831 832 exp : NSSTRING /* ObjC NextStep NSString constant 833 * of the form '@' '"' string '"'. 834 */ 835 { write_exp_elt_opcode (OP_OBJC_NSSTRING); 836 write_exp_string ($1); 837 write_exp_elt_opcode (OP_OBJC_NSSTRING); } 838 ; 839 840 /* C++. */ 841 exp : TRUEKEYWORD 842 { write_exp_elt_opcode (OP_LONG); 843 write_exp_elt_type (parse_type->builtin_bool); 844 write_exp_elt_longcst ((LONGEST) 1); 845 write_exp_elt_opcode (OP_LONG); } 846 ; 847 848 exp : FALSEKEYWORD 849 { write_exp_elt_opcode (OP_LONG); 850 write_exp_elt_type (parse_type->builtin_bool); 851 write_exp_elt_longcst ((LONGEST) 0); 852 write_exp_elt_opcode (OP_LONG); } 853 ; 854 855 /* end of C++. */ 856 857 block : BLOCKNAME 858 { 859 if ($1.sym) 860 $$ = SYMBOL_BLOCK_VALUE ($1.sym); 861 else 862 error (_("No file or function \"%s\"."), 863 copy_name ($1.stoken)); 864 } 865 | FILENAME 866 { 867 $$ = $1; 868 } 869 ; 870 871 block : block COLONCOLON name 872 { struct symbol *tem 873 = lookup_symbol (copy_name ($3), $1, 874 VAR_DOMAIN, NULL); 875 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) 876 error (_("No function \"%s\" in specified context."), 877 copy_name ($3)); 878 $$ = SYMBOL_BLOCK_VALUE (tem); } 879 ; 880 881 variable: name_not_typename ENTRY 882 { struct symbol *sym = $1.sym; 883 884 if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym) 885 || !symbol_read_needs_frame (sym)) 886 error (_("@entry can be used only for function " 887 "parameters, not for \"%s\""), 888 copy_name ($1.stoken)); 889 890 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); 891 write_exp_elt_sym (sym); 892 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); 893 } 894 ; 895 896 variable: block COLONCOLON name 897 { struct symbol *sym; 898 sym = lookup_symbol (copy_name ($3), $1, 899 VAR_DOMAIN, NULL); 900 if (sym == 0) 901 error (_("No symbol \"%s\" in specified context."), 902 copy_name ($3)); 903 if (symbol_read_needs_frame (sym)) 904 { 905 if (innermost_block == 0 906 || contained_in (block_found, 907 innermost_block)) 908 innermost_block = block_found; 909 } 910 911 write_exp_elt_opcode (OP_VAR_VALUE); 912 /* block_found is set by lookup_symbol. */ 913 write_exp_elt_block (block_found); 914 write_exp_elt_sym (sym); 915 write_exp_elt_opcode (OP_VAR_VALUE); } 916 ; 917 918 qualified_name: TYPENAME COLONCOLON name 919 { 920 struct type *type = $1.type; 921 CHECK_TYPEDEF (type); 922 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 923 && TYPE_CODE (type) != TYPE_CODE_UNION 924 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE) 925 error (_("`%s' is not defined as an aggregate type."), 926 TYPE_SAFE_NAME (type)); 927 928 write_exp_elt_opcode (OP_SCOPE); 929 write_exp_elt_type (type); 930 write_exp_string ($3); 931 write_exp_elt_opcode (OP_SCOPE); 932 } 933 | TYPENAME COLONCOLON '~' name 934 { 935 struct type *type = $1.type; 936 struct stoken tmp_token; 937 CHECK_TYPEDEF (type); 938 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 939 && TYPE_CODE (type) != TYPE_CODE_UNION 940 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE) 941 error (_("`%s' is not defined as an aggregate type."), 942 TYPE_SAFE_NAME (type)); 943 944 tmp_token.ptr = (char*) alloca ($4.length + 2); 945 tmp_token.length = $4.length + 1; 946 tmp_token.ptr[0] = '~'; 947 memcpy (tmp_token.ptr+1, $4.ptr, $4.length); 948 tmp_token.ptr[tmp_token.length] = 0; 949 950 /* Check for valid destructor name. */ 951 destructor_name_p (tmp_token.ptr, $1.type); 952 write_exp_elt_opcode (OP_SCOPE); 953 write_exp_elt_type (type); 954 write_exp_string (tmp_token); 955 write_exp_elt_opcode (OP_SCOPE); 956 } 957 | TYPENAME COLONCOLON name COLONCOLON name 958 { 959 char *copy = copy_name ($3); 960 error (_("No type \"%s\" within class " 961 "or namespace \"%s\"."), 962 copy, TYPE_SAFE_NAME ($1.type)); 963 } 964 ; 965 966 variable: qualified_name 967 | COLONCOLON name_not_typename 968 { 969 char *name = copy_name ($2.stoken); 970 struct symbol *sym; 971 struct minimal_symbol *msymbol; 972 973 sym = 974 lookup_symbol (name, (const struct block *) NULL, 975 VAR_DOMAIN, NULL); 976 if (sym) 977 { 978 write_exp_elt_opcode (OP_VAR_VALUE); 979 write_exp_elt_block (NULL); 980 write_exp_elt_sym (sym); 981 write_exp_elt_opcode (OP_VAR_VALUE); 982 break; 983 } 984 985 msymbol = lookup_minimal_symbol (name, NULL, NULL); 986 if (msymbol != NULL) 987 write_exp_msymbol (msymbol); 988 else if (!have_full_symbols () && !have_partial_symbols ()) 989 error (_("No symbol table is loaded. Use the \"file\" command.")); 990 else 991 error (_("No symbol \"%s\" in current context."), name); 992 } 993 ; 994 995 variable: name_not_typename 996 { struct symbol *sym = $1.sym; 997 998 if (sym) 999 { 1000 if (symbol_read_needs_frame (sym)) 1001 { 1002 if (innermost_block == 0 1003 || contained_in (block_found, 1004 innermost_block)) 1005 innermost_block = block_found; 1006 } 1007 1008 write_exp_elt_opcode (OP_VAR_VALUE); 1009 /* We want to use the selected frame, not 1010 another more inner frame which happens to 1011 be in the same block. */ 1012 write_exp_elt_block (NULL); 1013 write_exp_elt_sym (sym); 1014 write_exp_elt_opcode (OP_VAR_VALUE); 1015 } 1016 else if ($1.is_a_field_of_this) 1017 { 1018 /* C++: it hangs off of `this'. Must 1019 not inadvertently convert from a method call 1020 to data ref. */ 1021 if (innermost_block == 0 1022 || contained_in (block_found, 1023 innermost_block)) 1024 innermost_block = block_found; 1025 write_exp_elt_opcode (OP_THIS); 1026 write_exp_elt_opcode (OP_THIS); 1027 write_exp_elt_opcode (STRUCTOP_PTR); 1028 write_exp_string ($1.stoken); 1029 write_exp_elt_opcode (STRUCTOP_PTR); 1030 } 1031 else 1032 { 1033 struct minimal_symbol *msymbol; 1034 char *arg = copy_name ($1.stoken); 1035 1036 msymbol = 1037 lookup_minimal_symbol (arg, NULL, NULL); 1038 if (msymbol != NULL) 1039 write_exp_msymbol (msymbol); 1040 else if (!have_full_symbols () && !have_partial_symbols ()) 1041 error (_("No symbol table is loaded. Use the \"file\" command.")); 1042 else 1043 error (_("No symbol \"%s\" in current context."), 1044 copy_name ($1.stoken)); 1045 } 1046 } 1047 ; 1048 1049 space_identifier : '@' NAME 1050 { insert_type_address_space (copy_name ($2.stoken)); } 1051 ; 1052 1053 const_or_volatile: const_or_volatile_noopt 1054 | 1055 ; 1056 1057 cv_with_space_id : const_or_volatile space_identifier const_or_volatile 1058 ; 1059 1060 const_or_volatile_or_space_identifier_noopt: cv_with_space_id 1061 | const_or_volatile_noopt 1062 ; 1063 1064 const_or_volatile_or_space_identifier: 1065 const_or_volatile_or_space_identifier_noopt 1066 | 1067 ; 1068 1069 ptr_operator: 1070 ptr_operator '*' 1071 { insert_type (tp_pointer); } 1072 const_or_volatile_or_space_identifier 1073 | '*' 1074 { insert_type (tp_pointer); } 1075 const_or_volatile_or_space_identifier 1076 | '&' 1077 { insert_type (tp_reference); } 1078 | '&' ptr_operator 1079 { insert_type (tp_reference); } 1080 ; 1081 1082 ptr_operator_ts: ptr_operator 1083 { 1084 $$ = get_type_stack (); 1085 /* This cleanup is eventually run by 1086 c_parse. */ 1087 make_cleanup (type_stack_cleanup, $$); 1088 } 1089 ; 1090 1091 abs_decl: ptr_operator_ts direct_abs_decl 1092 { $$ = append_type_stack ($2, $1); } 1093 | ptr_operator_ts 1094 | direct_abs_decl 1095 ; 1096 1097 direct_abs_decl: '(' abs_decl ')' 1098 { $$ = $2; } 1099 | direct_abs_decl array_mod 1100 { 1101 push_type_stack ($1); 1102 push_type_int ($2); 1103 push_type (tp_array); 1104 $$ = get_type_stack (); 1105 } 1106 | array_mod 1107 { 1108 push_type_int ($1); 1109 push_type (tp_array); 1110 $$ = get_type_stack (); 1111 } 1112 1113 | direct_abs_decl func_mod 1114 { 1115 push_type_stack ($1); 1116 push_typelist ($2); 1117 $$ = get_type_stack (); 1118 } 1119 | func_mod 1120 { 1121 push_typelist ($1); 1122 $$ = get_type_stack (); 1123 } 1124 ; 1125 1126 array_mod: '[' ']' 1127 { $$ = -1; } 1128 | OBJC_LBRAC ']' 1129 { $$ = -1; } 1130 | '[' INT ']' 1131 { $$ = $2.val; } 1132 | OBJC_LBRAC INT ']' 1133 { $$ = $2.val; } 1134 ; 1135 1136 func_mod: '(' ')' 1137 { $$ = NULL; } 1138 | '(' parameter_typelist ')' 1139 { $$ = $2; } 1140 ; 1141 1142 /* We used to try to recognize pointer to member types here, but 1143 that didn't work (shift/reduce conflicts meant that these rules never 1144 got executed). The problem is that 1145 int (foo::bar::baz::bizzle) 1146 is a function type but 1147 int (foo::bar::baz::bizzle::*) 1148 is a pointer to member type. Stroustrup loses again! */ 1149 1150 type : ptype 1151 ; 1152 1153 typebase /* Implements (approximately): (type-qualifier)* type-specifier */ 1154 : TYPENAME 1155 { $$ = $1.type; } 1156 | INT_KEYWORD 1157 { $$ = lookup_signed_typename (parse_language, 1158 parse_gdbarch, 1159 "int"); } 1160 | LONG 1161 { $$ = lookup_signed_typename (parse_language, 1162 parse_gdbarch, 1163 "long"); } 1164 | SHORT 1165 { $$ = lookup_signed_typename (parse_language, 1166 parse_gdbarch, 1167 "short"); } 1168 | LONG INT_KEYWORD 1169 { $$ = lookup_signed_typename (parse_language, 1170 parse_gdbarch, 1171 "long"); } 1172 | LONG SIGNED_KEYWORD INT_KEYWORD 1173 { $$ = lookup_signed_typename (parse_language, 1174 parse_gdbarch, 1175 "long"); } 1176 | LONG SIGNED_KEYWORD 1177 { $$ = lookup_signed_typename (parse_language, 1178 parse_gdbarch, 1179 "long"); } 1180 | SIGNED_KEYWORD LONG INT_KEYWORD 1181 { $$ = lookup_signed_typename (parse_language, 1182 parse_gdbarch, 1183 "long"); } 1184 | UNSIGNED LONG INT_KEYWORD 1185 { $$ = lookup_unsigned_typename (parse_language, 1186 parse_gdbarch, 1187 "long"); } 1188 | LONG UNSIGNED INT_KEYWORD 1189 { $$ = lookup_unsigned_typename (parse_language, 1190 parse_gdbarch, 1191 "long"); } 1192 | LONG UNSIGNED 1193 { $$ = lookup_unsigned_typename (parse_language, 1194 parse_gdbarch, 1195 "long"); } 1196 | LONG LONG 1197 { $$ = lookup_signed_typename (parse_language, 1198 parse_gdbarch, 1199 "long long"); } 1200 | LONG LONG INT_KEYWORD 1201 { $$ = lookup_signed_typename (parse_language, 1202 parse_gdbarch, 1203 "long long"); } 1204 | LONG LONG SIGNED_KEYWORD INT_KEYWORD 1205 { $$ = lookup_signed_typename (parse_language, 1206 parse_gdbarch, 1207 "long long"); } 1208 | LONG LONG SIGNED_KEYWORD 1209 { $$ = lookup_signed_typename (parse_language, 1210 parse_gdbarch, 1211 "long long"); } 1212 | SIGNED_KEYWORD LONG LONG 1213 { $$ = lookup_signed_typename (parse_language, 1214 parse_gdbarch, 1215 "long long"); } 1216 | SIGNED_KEYWORD LONG LONG INT_KEYWORD 1217 { $$ = lookup_signed_typename (parse_language, 1218 parse_gdbarch, 1219 "long long"); } 1220 | UNSIGNED LONG LONG 1221 { $$ = lookup_unsigned_typename (parse_language, 1222 parse_gdbarch, 1223 "long long"); } 1224 | UNSIGNED LONG LONG INT_KEYWORD 1225 { $$ = lookup_unsigned_typename (parse_language, 1226 parse_gdbarch, 1227 "long long"); } 1228 | LONG LONG UNSIGNED 1229 { $$ = lookup_unsigned_typename (parse_language, 1230 parse_gdbarch, 1231 "long long"); } 1232 | LONG LONG UNSIGNED INT_KEYWORD 1233 { $$ = lookup_unsigned_typename (parse_language, 1234 parse_gdbarch, 1235 "long long"); } 1236 | SHORT INT_KEYWORD 1237 { $$ = lookup_signed_typename (parse_language, 1238 parse_gdbarch, 1239 "short"); } 1240 | SHORT SIGNED_KEYWORD INT_KEYWORD 1241 { $$ = lookup_signed_typename (parse_language, 1242 parse_gdbarch, 1243 "short"); } 1244 | SHORT SIGNED_KEYWORD 1245 { $$ = lookup_signed_typename (parse_language, 1246 parse_gdbarch, 1247 "short"); } 1248 | UNSIGNED SHORT INT_KEYWORD 1249 { $$ = lookup_unsigned_typename (parse_language, 1250 parse_gdbarch, 1251 "short"); } 1252 | SHORT UNSIGNED 1253 { $$ = lookup_unsigned_typename (parse_language, 1254 parse_gdbarch, 1255 "short"); } 1256 | SHORT UNSIGNED INT_KEYWORD 1257 { $$ = lookup_unsigned_typename (parse_language, 1258 parse_gdbarch, 1259 "short"); } 1260 | DOUBLE_KEYWORD 1261 { $$ = lookup_typename (parse_language, parse_gdbarch, 1262 "double", (struct block *) NULL, 1263 0); } 1264 | LONG DOUBLE_KEYWORD 1265 { $$ = lookup_typename (parse_language, parse_gdbarch, 1266 "long double", 1267 (struct block *) NULL, 0); } 1268 | STRUCT name 1269 { $$ = lookup_struct (copy_name ($2), 1270 expression_context_block); } 1271 | STRUCT COMPLETE 1272 { 1273 mark_completion_tag (TYPE_CODE_STRUCT, "", 0); 1274 $$ = NULL; 1275 } 1276 | STRUCT name COMPLETE 1277 { 1278 mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr, 1279 $2.length); 1280 $$ = NULL; 1281 } 1282 | CLASS name 1283 { $$ = lookup_struct (copy_name ($2), 1284 expression_context_block); } 1285 | CLASS COMPLETE 1286 { 1287 mark_completion_tag (TYPE_CODE_CLASS, "", 0); 1288 $$ = NULL; 1289 } 1290 | CLASS name COMPLETE 1291 { 1292 mark_completion_tag (TYPE_CODE_CLASS, $2.ptr, 1293 $2.length); 1294 $$ = NULL; 1295 } 1296 | UNION name 1297 { $$ = lookup_union (copy_name ($2), 1298 expression_context_block); } 1299 | UNION COMPLETE 1300 { 1301 mark_completion_tag (TYPE_CODE_UNION, "", 0); 1302 $$ = NULL; 1303 } 1304 | UNION name COMPLETE 1305 { 1306 mark_completion_tag (TYPE_CODE_UNION, $2.ptr, 1307 $2.length); 1308 $$ = NULL; 1309 } 1310 | ENUM name 1311 { $$ = lookup_enum (copy_name ($2), 1312 expression_context_block); } 1313 | ENUM COMPLETE 1314 { 1315 mark_completion_tag (TYPE_CODE_ENUM, "", 0); 1316 $$ = NULL; 1317 } 1318 | ENUM name COMPLETE 1319 { 1320 mark_completion_tag (TYPE_CODE_ENUM, $2.ptr, 1321 $2.length); 1322 $$ = NULL; 1323 } 1324 | UNSIGNED typename 1325 { $$ = lookup_unsigned_typename (parse_language, 1326 parse_gdbarch, 1327 TYPE_NAME($2.type)); } 1328 | UNSIGNED 1329 { $$ = lookup_unsigned_typename (parse_language, 1330 parse_gdbarch, 1331 "int"); } 1332 | SIGNED_KEYWORD typename 1333 { $$ = lookup_signed_typename (parse_language, 1334 parse_gdbarch, 1335 TYPE_NAME($2.type)); } 1336 | SIGNED_KEYWORD 1337 { $$ = lookup_signed_typename (parse_language, 1338 parse_gdbarch, 1339 "int"); } 1340 /* It appears that this rule for templates is never 1341 reduced; template recognition happens by lookahead 1342 in the token processing code in yylex. */ 1343 | TEMPLATE name '<' type '>' 1344 { $$ = lookup_template_type(copy_name($2), $4, 1345 expression_context_block); 1346 } 1347 | const_or_volatile_or_space_identifier_noopt typebase 1348 { $$ = follow_types ($2); } 1349 | typebase const_or_volatile_or_space_identifier_noopt 1350 { $$ = follow_types ($1); } 1351 ; 1352 1353 typename: TYPENAME 1354 | INT_KEYWORD 1355 { 1356 $$.stoken.ptr = "int"; 1357 $$.stoken.length = 3; 1358 $$.type = lookup_signed_typename (parse_language, 1359 parse_gdbarch, 1360 "int"); 1361 } 1362 | LONG 1363 { 1364 $$.stoken.ptr = "long"; 1365 $$.stoken.length = 4; 1366 $$.type = lookup_signed_typename (parse_language, 1367 parse_gdbarch, 1368 "long"); 1369 } 1370 | SHORT 1371 { 1372 $$.stoken.ptr = "short"; 1373 $$.stoken.length = 5; 1374 $$.type = lookup_signed_typename (parse_language, 1375 parse_gdbarch, 1376 "short"); 1377 } 1378 ; 1379 1380 parameter_typelist: 1381 nonempty_typelist 1382 { check_parameter_typelist ($1); } 1383 | nonempty_typelist ',' DOTDOTDOT 1384 { 1385 VEC_safe_push (type_ptr, $1, NULL); 1386 check_parameter_typelist ($1); 1387 $$ = $1; 1388 } 1389 ; 1390 1391 nonempty_typelist 1392 : type 1393 { 1394 VEC (type_ptr) *typelist = NULL; 1395 VEC_safe_push (type_ptr, typelist, $1); 1396 $$ = typelist; 1397 } 1398 | nonempty_typelist ',' type 1399 { 1400 VEC_safe_push (type_ptr, $1, $3); 1401 $$ = $1; 1402 } 1403 ; 1404 1405 ptype : typebase 1406 | ptype abs_decl 1407 { 1408 push_type_stack ($2); 1409 $$ = follow_types ($1); 1410 } 1411 ; 1412 1413 conversion_type_id: typebase conversion_declarator 1414 { $$ = follow_types ($1); } 1415 ; 1416 1417 conversion_declarator: /* Nothing. */ 1418 | ptr_operator conversion_declarator 1419 ; 1420 1421 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD 1422 | VOLATILE_KEYWORD CONST_KEYWORD 1423 ; 1424 1425 const_or_volatile_noopt: const_and_volatile 1426 { insert_type (tp_const); 1427 insert_type (tp_volatile); 1428 } 1429 | CONST_KEYWORD 1430 { insert_type (tp_const); } 1431 | VOLATILE_KEYWORD 1432 { insert_type (tp_volatile); } 1433 ; 1434 1435 operator: OPERATOR NEW 1436 { $$ = operator_stoken (" new"); } 1437 | OPERATOR DELETE 1438 { $$ = operator_stoken (" delete"); } 1439 | OPERATOR NEW '[' ']' 1440 { $$ = operator_stoken (" new[]"); } 1441 | OPERATOR DELETE '[' ']' 1442 { $$ = operator_stoken (" delete[]"); } 1443 | OPERATOR NEW OBJC_LBRAC ']' 1444 { $$ = operator_stoken (" new[]"); } 1445 | OPERATOR DELETE OBJC_LBRAC ']' 1446 { $$ = operator_stoken (" delete[]"); } 1447 | OPERATOR '+' 1448 { $$ = operator_stoken ("+"); } 1449 | OPERATOR '-' 1450 { $$ = operator_stoken ("-"); } 1451 | OPERATOR '*' 1452 { $$ = operator_stoken ("*"); } 1453 | OPERATOR '/' 1454 { $$ = operator_stoken ("/"); } 1455 | OPERATOR '%' 1456 { $$ = operator_stoken ("%"); } 1457 | OPERATOR '^' 1458 { $$ = operator_stoken ("^"); } 1459 | OPERATOR '&' 1460 { $$ = operator_stoken ("&"); } 1461 | OPERATOR '|' 1462 { $$ = operator_stoken ("|"); } 1463 | OPERATOR '~' 1464 { $$ = operator_stoken ("~"); } 1465 | OPERATOR '!' 1466 { $$ = operator_stoken ("!"); } 1467 | OPERATOR '=' 1468 { $$ = operator_stoken ("="); } 1469 | OPERATOR '<' 1470 { $$ = operator_stoken ("<"); } 1471 | OPERATOR '>' 1472 { $$ = operator_stoken (">"); } 1473 | OPERATOR ASSIGN_MODIFY 1474 { const char *op = "unknown"; 1475 switch ($2) 1476 { 1477 case BINOP_RSH: 1478 op = ">>="; 1479 break; 1480 case BINOP_LSH: 1481 op = "<<="; 1482 break; 1483 case BINOP_ADD: 1484 op = "+="; 1485 break; 1486 case BINOP_SUB: 1487 op = "-="; 1488 break; 1489 case BINOP_MUL: 1490 op = "*="; 1491 break; 1492 case BINOP_DIV: 1493 op = "/="; 1494 break; 1495 case BINOP_REM: 1496 op = "%="; 1497 break; 1498 case BINOP_BITWISE_IOR: 1499 op = "|="; 1500 break; 1501 case BINOP_BITWISE_AND: 1502 op = "&="; 1503 break; 1504 case BINOP_BITWISE_XOR: 1505 op = "^="; 1506 break; 1507 default: 1508 break; 1509 } 1510 1511 $$ = operator_stoken (op); 1512 } 1513 | OPERATOR LSH 1514 { $$ = operator_stoken ("<<"); } 1515 | OPERATOR RSH 1516 { $$ = operator_stoken (">>"); } 1517 | OPERATOR EQUAL 1518 { $$ = operator_stoken ("=="); } 1519 | OPERATOR NOTEQUAL 1520 { $$ = operator_stoken ("!="); } 1521 | OPERATOR LEQ 1522 { $$ = operator_stoken ("<="); } 1523 | OPERATOR GEQ 1524 { $$ = operator_stoken (">="); } 1525 | OPERATOR ANDAND 1526 { $$ = operator_stoken ("&&"); } 1527 | OPERATOR OROR 1528 { $$ = operator_stoken ("||"); } 1529 | OPERATOR INCREMENT 1530 { $$ = operator_stoken ("++"); } 1531 | OPERATOR DECREMENT 1532 { $$ = operator_stoken ("--"); } 1533 | OPERATOR ',' 1534 { $$ = operator_stoken (","); } 1535 | OPERATOR ARROW_STAR 1536 { $$ = operator_stoken ("->*"); } 1537 | OPERATOR ARROW 1538 { $$ = operator_stoken ("->"); } 1539 | OPERATOR '(' ')' 1540 { $$ = operator_stoken ("()"); } 1541 | OPERATOR '[' ']' 1542 { $$ = operator_stoken ("[]"); } 1543 | OPERATOR OBJC_LBRAC ']' 1544 { $$ = operator_stoken ("[]"); } 1545 | OPERATOR conversion_type_id 1546 { char *name; 1547 long length; 1548 struct ui_file *buf = mem_fileopen (); 1549 1550 c_print_type ($2, NULL, buf, -1, 0, 1551 &type_print_raw_options); 1552 name = ui_file_xstrdup (buf, &length); 1553 ui_file_delete (buf); 1554 $$ = operator_stoken (name); 1555 free (name); 1556 } 1557 ; 1558 1559 1560 1561 name : NAME { $$ = $1.stoken; } 1562 | BLOCKNAME { $$ = $1.stoken; } 1563 | TYPENAME { $$ = $1.stoken; } 1564 | NAME_OR_INT { $$ = $1.stoken; } 1565 | UNKNOWN_CPP_NAME { $$ = $1.stoken; } 1566 | operator { $$ = $1; } 1567 ; 1568 1569 name_not_typename : NAME 1570 | BLOCKNAME 1571 /* These would be useful if name_not_typename was useful, but it is just 1572 a fake for "variable", so these cause reduce/reduce conflicts because 1573 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable, 1574 =exp) or just an exp. If name_not_typename was ever used in an lvalue 1575 context where only a name could occur, this might be useful. 1576 | NAME_OR_INT 1577 */ 1578 | operator 1579 { 1580 struct field_of_this_result is_a_field_of_this; 1581 1582 $$.stoken = $1; 1583 $$.sym = lookup_symbol ($1.ptr, 1584 expression_context_block, 1585 VAR_DOMAIN, 1586 &is_a_field_of_this); 1587 $$.is_a_field_of_this 1588 = is_a_field_of_this.type != NULL; 1589 } 1590 | UNKNOWN_CPP_NAME 1591 ; 1592 1593 %% 1594 1595 /* Returns a stoken of the operator name given by OP (which does not 1596 include the string "operator"). */ 1597 static struct stoken 1598 operator_stoken (const char *op) 1599 { 1600 static const char *operator_string = "operator"; 1601 struct stoken st = { NULL, 0 }; 1602 st.length = strlen (operator_string) + strlen (op); 1603 st.ptr = malloc (st.length + 1); 1604 strcpy (st.ptr, operator_string); 1605 strcat (st.ptr, op); 1606 1607 /* The toplevel (c_parse) will free the memory allocated here. */ 1608 make_cleanup (free, st.ptr); 1609 return st; 1610 }; 1611 1612 /* Validate a parameter typelist. */ 1613 1614 static void 1615 check_parameter_typelist (VEC (type_ptr) *params) 1616 { 1617 struct type *type; 1618 int ix; 1619 1620 for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix) 1621 { 1622 if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID) 1623 { 1624 if (ix == 0) 1625 { 1626 if (VEC_length (type_ptr, params) == 1) 1627 { 1628 /* Ok. */ 1629 break; 1630 } 1631 VEC_free (type_ptr, params); 1632 error (_("parameter types following 'void'")); 1633 } 1634 else 1635 { 1636 VEC_free (type_ptr, params); 1637 error (_("'void' invalid as parameter type")); 1638 } 1639 } 1640 } 1641 } 1642 1643 /* Take care of parsing a number (anything that starts with a digit). 1644 Set yylval and return the token type; update lexptr. 1645 LEN is the number of characters in it. */ 1646 1647 /*** Needs some error checking for the float case ***/ 1648 1649 static int 1650 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) 1651 { 1652 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values 1653 here, and we do kind of silly things like cast to unsigned. */ 1654 LONGEST n = 0; 1655 LONGEST prevn = 0; 1656 ULONGEST un; 1657 1658 int i = 0; 1659 int c; 1660 int base = input_radix; 1661 int unsigned_p = 0; 1662 1663 /* Number of "L" suffixes encountered. */ 1664 int long_p = 0; 1665 1666 /* We have found a "L" or "U" suffix. */ 1667 int found_suffix = 0; 1668 1669 ULONGEST high_bit; 1670 struct type *signed_type; 1671 struct type *unsigned_type; 1672 1673 if (parsed_float) 1674 { 1675 /* If it ends at "df", "dd" or "dl", take it as type of decimal floating 1676 point. Return DECFLOAT. */ 1677 1678 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f') 1679 { 1680 p[len - 2] = '\0'; 1681 putithere->typed_val_decfloat.type 1682 = parse_type->builtin_decfloat; 1683 decimal_from_string (putithere->typed_val_decfloat.val, 4, 1684 gdbarch_byte_order (parse_gdbarch), p); 1685 p[len - 2] = 'd'; 1686 return DECFLOAT; 1687 } 1688 1689 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd') 1690 { 1691 p[len - 2] = '\0'; 1692 putithere->typed_val_decfloat.type 1693 = parse_type->builtin_decdouble; 1694 decimal_from_string (putithere->typed_val_decfloat.val, 8, 1695 gdbarch_byte_order (parse_gdbarch), p); 1696 p[len - 2] = 'd'; 1697 return DECFLOAT; 1698 } 1699 1700 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l') 1701 { 1702 p[len - 2] = '\0'; 1703 putithere->typed_val_decfloat.type 1704 = parse_type->builtin_declong; 1705 decimal_from_string (putithere->typed_val_decfloat.val, 16, 1706 gdbarch_byte_order (parse_gdbarch), p); 1707 p[len - 2] = 'd'; 1708 return DECFLOAT; 1709 } 1710 1711 if (! parse_c_float (parse_gdbarch, p, len, 1712 &putithere->typed_val_float.dval, 1713 &putithere->typed_val_float.type)) 1714 return ERROR; 1715 return FLOAT; 1716 } 1717 1718 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */ 1719 if (p[0] == '0') 1720 switch (p[1]) 1721 { 1722 case 'x': 1723 case 'X': 1724 if (len >= 3) 1725 { 1726 p += 2; 1727 base = 16; 1728 len -= 2; 1729 } 1730 break; 1731 1732 case 'b': 1733 case 'B': 1734 if (len >= 3) 1735 { 1736 p += 2; 1737 base = 2; 1738 len -= 2; 1739 } 1740 break; 1741 1742 case 't': 1743 case 'T': 1744 case 'd': 1745 case 'D': 1746 if (len >= 3) 1747 { 1748 p += 2; 1749 base = 10; 1750 len -= 2; 1751 } 1752 break; 1753 1754 default: 1755 base = 8; 1756 break; 1757 } 1758 1759 while (len-- > 0) 1760 { 1761 c = *p++; 1762 if (c >= 'A' && c <= 'Z') 1763 c += 'a' - 'A'; 1764 if (c != 'l' && c != 'u') 1765 n *= base; 1766 if (c >= '0' && c <= '9') 1767 { 1768 if (found_suffix) 1769 return ERROR; 1770 n += i = c - '0'; 1771 } 1772 else 1773 { 1774 if (base > 10 && c >= 'a' && c <= 'f') 1775 { 1776 if (found_suffix) 1777 return ERROR; 1778 n += i = c - 'a' + 10; 1779 } 1780 else if (c == 'l') 1781 { 1782 ++long_p; 1783 found_suffix = 1; 1784 } 1785 else if (c == 'u') 1786 { 1787 unsigned_p = 1; 1788 found_suffix = 1; 1789 } 1790 else 1791 return ERROR; /* Char not a digit */ 1792 } 1793 if (i >= base) 1794 return ERROR; /* Invalid digit in this base */ 1795 1796 /* Portably test for overflow (only works for nonzero values, so make 1797 a second check for zero). FIXME: Can't we just make n and prevn 1798 unsigned and avoid this? */ 1799 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0) 1800 unsigned_p = 1; /* Try something unsigned */ 1801 1802 /* Portably test for unsigned overflow. 1803 FIXME: This check is wrong; for example it doesn't find overflow 1804 on 0x123456789 when LONGEST is 32 bits. */ 1805 if (c != 'l' && c != 'u' && n != 0) 1806 { 1807 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n)) 1808 error (_("Numeric constant too large.")); 1809 } 1810 prevn = n; 1811 } 1812 1813 /* An integer constant is an int, a long, or a long long. An L 1814 suffix forces it to be long; an LL suffix forces it to be long 1815 long. If not forced to a larger size, it gets the first type of 1816 the above that it fits in. To figure out whether it fits, we 1817 shift it right and see whether anything remains. Note that we 1818 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one 1819 operation, because many compilers will warn about such a shift 1820 (which always produces a zero result). Sometimes gdbarch_int_bit 1821 or gdbarch_long_bit will be that big, sometimes not. To deal with 1822 the case where it is we just always shift the value more than 1823 once, with fewer bits each time. */ 1824 1825 un = (ULONGEST)n >> 2; 1826 if (long_p == 0 1827 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0) 1828 { 1829 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1); 1830 1831 /* A large decimal (not hex or octal) constant (between INT_MAX 1832 and UINT_MAX) is a long or unsigned long, according to ANSI, 1833 never an unsigned int, but this code treats it as unsigned 1834 int. This probably should be fixed. GCC gives a warning on 1835 such constants. */ 1836 1837 unsigned_type = parse_type->builtin_unsigned_int; 1838 signed_type = parse_type->builtin_int; 1839 } 1840 else if (long_p <= 1 1841 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0) 1842 { 1843 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1); 1844 unsigned_type = parse_type->builtin_unsigned_long; 1845 signed_type = parse_type->builtin_long; 1846 } 1847 else 1848 { 1849 int shift; 1850 if (sizeof (ULONGEST) * HOST_CHAR_BIT 1851 < gdbarch_long_long_bit (parse_gdbarch)) 1852 /* A long long does not fit in a LONGEST. */ 1853 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1); 1854 else 1855 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1); 1856 high_bit = (ULONGEST) 1 << shift; 1857 unsigned_type = parse_type->builtin_unsigned_long_long; 1858 signed_type = parse_type->builtin_long_long; 1859 } 1860 1861 putithere->typed_val_int.val = n; 1862 1863 /* If the high bit of the worked out type is set then this number 1864 has to be unsigned. */ 1865 1866 if (unsigned_p || (n & high_bit)) 1867 { 1868 putithere->typed_val_int.type = unsigned_type; 1869 } 1870 else 1871 { 1872 putithere->typed_val_int.type = signed_type; 1873 } 1874 1875 return INT; 1876 } 1877 1878 /* Temporary obstack used for holding strings. */ 1879 static struct obstack tempbuf; 1880 static int tempbuf_init; 1881 1882 /* Parse a C escape sequence. The initial backslash of the sequence 1883 is at (*PTR)[-1]. *PTR will be updated to point to just after the 1884 last character of the sequence. If OUTPUT is not NULL, the 1885 translated form of the escape sequence will be written there. If 1886 OUTPUT is NULL, no output is written and the call will only affect 1887 *PTR. If an escape sequence is expressed in target bytes, then the 1888 entire sequence will simply be copied to OUTPUT. Return 1 if any 1889 character was emitted, 0 otherwise. */ 1890 1891 int 1892 c_parse_escape (char **ptr, struct obstack *output) 1893 { 1894 char *tokptr = *ptr; 1895 int result = 1; 1896 1897 /* Some escape sequences undergo character set conversion. Those we 1898 translate here. */ 1899 switch (*tokptr) 1900 { 1901 /* Hex escapes do not undergo character set conversion, so keep 1902 the escape sequence for later. */ 1903 case 'x': 1904 if (output) 1905 obstack_grow_str (output, "\\x"); 1906 ++tokptr; 1907 if (!isxdigit (*tokptr)) 1908 error (_("\\x escape without a following hex digit")); 1909 while (isxdigit (*tokptr)) 1910 { 1911 if (output) 1912 obstack_1grow (output, *tokptr); 1913 ++tokptr; 1914 } 1915 break; 1916 1917 /* Octal escapes do not undergo character set conversion, so 1918 keep the escape sequence for later. */ 1919 case '0': 1920 case '1': 1921 case '2': 1922 case '3': 1923 case '4': 1924 case '5': 1925 case '6': 1926 case '7': 1927 { 1928 int i; 1929 if (output) 1930 obstack_grow_str (output, "\\"); 1931 for (i = 0; 1932 i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9'; 1933 ++i) 1934 { 1935 if (output) 1936 obstack_1grow (output, *tokptr); 1937 ++tokptr; 1938 } 1939 } 1940 break; 1941 1942 /* We handle UCNs later. We could handle them here, but that 1943 would mean a spurious error in the case where the UCN could 1944 be converted to the target charset but not the host 1945 charset. */ 1946 case 'u': 1947 case 'U': 1948 { 1949 char c = *tokptr; 1950 int i, len = c == 'U' ? 8 : 4; 1951 if (output) 1952 { 1953 obstack_1grow (output, '\\'); 1954 obstack_1grow (output, *tokptr); 1955 } 1956 ++tokptr; 1957 if (!isxdigit (*tokptr)) 1958 error (_("\\%c escape without a following hex digit"), c); 1959 for (i = 0; i < len && isxdigit (*tokptr); ++i) 1960 { 1961 if (output) 1962 obstack_1grow (output, *tokptr); 1963 ++tokptr; 1964 } 1965 } 1966 break; 1967 1968 /* We must pass backslash through so that it does not 1969 cause quoting during the second expansion. */ 1970 case '\\': 1971 if (output) 1972 obstack_grow_str (output, "\\\\"); 1973 ++tokptr; 1974 break; 1975 1976 /* Escapes which undergo conversion. */ 1977 case 'a': 1978 if (output) 1979 obstack_1grow (output, '\a'); 1980 ++tokptr; 1981 break; 1982 case 'b': 1983 if (output) 1984 obstack_1grow (output, '\b'); 1985 ++tokptr; 1986 break; 1987 case 'f': 1988 if (output) 1989 obstack_1grow (output, '\f'); 1990 ++tokptr; 1991 break; 1992 case 'n': 1993 if (output) 1994 obstack_1grow (output, '\n'); 1995 ++tokptr; 1996 break; 1997 case 'r': 1998 if (output) 1999 obstack_1grow (output, '\r'); 2000 ++tokptr; 2001 break; 2002 case 't': 2003 if (output) 2004 obstack_1grow (output, '\t'); 2005 ++tokptr; 2006 break; 2007 case 'v': 2008 if (output) 2009 obstack_1grow (output, '\v'); 2010 ++tokptr; 2011 break; 2012 2013 /* GCC extension. */ 2014 case 'e': 2015 if (output) 2016 obstack_1grow (output, HOST_ESCAPE_CHAR); 2017 ++tokptr; 2018 break; 2019 2020 /* Backslash-newline expands to nothing at all. */ 2021 case '\n': 2022 ++tokptr; 2023 result = 0; 2024 break; 2025 2026 /* A few escapes just expand to the character itself. */ 2027 case '\'': 2028 case '\"': 2029 case '?': 2030 /* GCC extensions. */ 2031 case '(': 2032 case '{': 2033 case '[': 2034 case '%': 2035 /* Unrecognized escapes turn into the character itself. */ 2036 default: 2037 if (output) 2038 obstack_1grow (output, *tokptr); 2039 ++tokptr; 2040 break; 2041 } 2042 *ptr = tokptr; 2043 return result; 2044 } 2045 2046 /* Parse a string or character literal from TOKPTR. The string or 2047 character may be wide or unicode. *OUTPTR is set to just after the 2048 end of the literal in the input string. The resulting token is 2049 stored in VALUE. This returns a token value, either STRING or 2050 CHAR, depending on what was parsed. *HOST_CHARS is set to the 2051 number of host characters in the literal. */ 2052 static int 2053 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value, 2054 int *host_chars) 2055 { 2056 int quote; 2057 enum c_string_type type; 2058 int is_objc = 0; 2059 2060 /* Build the gdb internal form of the input string in tempbuf. Note 2061 that the buffer is null byte terminated *only* for the 2062 convenience of debugging gdb itself and printing the buffer 2063 contents when the buffer contains no embedded nulls. Gdb does 2064 not depend upon the buffer being null byte terminated, it uses 2065 the length string instead. This allows gdb to handle C strings 2066 (as well as strings in other languages) with embedded null 2067 bytes */ 2068 2069 if (!tempbuf_init) 2070 tempbuf_init = 1; 2071 else 2072 obstack_free (&tempbuf, NULL); 2073 obstack_init (&tempbuf); 2074 2075 /* Record the string type. */ 2076 if (*tokptr == 'L') 2077 { 2078 type = C_WIDE_STRING; 2079 ++tokptr; 2080 } 2081 else if (*tokptr == 'u') 2082 { 2083 type = C_STRING_16; 2084 ++tokptr; 2085 } 2086 else if (*tokptr == 'U') 2087 { 2088 type = C_STRING_32; 2089 ++tokptr; 2090 } 2091 else if (*tokptr == '@') 2092 { 2093 /* An Objective C string. */ 2094 is_objc = 1; 2095 type = C_STRING; 2096 ++tokptr; 2097 } 2098 else 2099 type = C_STRING; 2100 2101 /* Skip the quote. */ 2102 quote = *tokptr; 2103 if (quote == '\'') 2104 type |= C_CHAR; 2105 ++tokptr; 2106 2107 *host_chars = 0; 2108 2109 while (*tokptr) 2110 { 2111 char c = *tokptr; 2112 if (c == '\\') 2113 { 2114 ++tokptr; 2115 *host_chars += c_parse_escape (&tokptr, &tempbuf); 2116 } 2117 else if (c == quote) 2118 break; 2119 else 2120 { 2121 obstack_1grow (&tempbuf, c); 2122 ++tokptr; 2123 /* FIXME: this does the wrong thing with multi-byte host 2124 characters. We could use mbrlen here, but that would 2125 make "set host-charset" a bit less useful. */ 2126 ++*host_chars; 2127 } 2128 } 2129 2130 if (*tokptr != quote) 2131 { 2132 if (quote == '"') 2133 error (_("Unterminated string in expression.")); 2134 else 2135 error (_("Unmatched single quote.")); 2136 } 2137 ++tokptr; 2138 2139 value->type = type; 2140 value->ptr = obstack_base (&tempbuf); 2141 value->length = obstack_object_size (&tempbuf); 2142 2143 *outptr = tokptr; 2144 2145 return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR; 2146 } 2147 2148 /* This is used to associate some attributes with a token. */ 2149 2150 enum token_flags 2151 { 2152 /* If this bit is set, the token is C++-only. */ 2153 2154 FLAG_CXX = 1, 2155 2156 /* If this bit is set, the token is conditional: if there is a 2157 symbol of the same name, then the token is a symbol; otherwise, 2158 the token is a keyword. */ 2159 2160 FLAG_SHADOW = 2 2161 }; 2162 2163 struct token 2164 { 2165 char *operator; 2166 int token; 2167 enum exp_opcode opcode; 2168 enum token_flags flags; 2169 }; 2170 2171 static const struct token tokentab3[] = 2172 { 2173 {">>=", ASSIGN_MODIFY, BINOP_RSH, 0}, 2174 {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0}, 2175 {"->*", ARROW_STAR, BINOP_END, FLAG_CXX}, 2176 {"...", DOTDOTDOT, BINOP_END, 0} 2177 }; 2178 2179 static const struct token tokentab2[] = 2180 { 2181 {"+=", ASSIGN_MODIFY, BINOP_ADD, 0}, 2182 {"-=", ASSIGN_MODIFY, BINOP_SUB, 0}, 2183 {"*=", ASSIGN_MODIFY, BINOP_MUL, 0}, 2184 {"/=", ASSIGN_MODIFY, BINOP_DIV, 0}, 2185 {"%=", ASSIGN_MODIFY, BINOP_REM, 0}, 2186 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0}, 2187 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0}, 2188 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0}, 2189 {"++", INCREMENT, BINOP_END, 0}, 2190 {"--", DECREMENT, BINOP_END, 0}, 2191 {"->", ARROW, BINOP_END, 0}, 2192 {"&&", ANDAND, BINOP_END, 0}, 2193 {"||", OROR, BINOP_END, 0}, 2194 /* "::" is *not* only C++: gdb overrides its meaning in several 2195 different ways, e.g., 'filename'::func, function::variable. */ 2196 {"::", COLONCOLON, BINOP_END, 0}, 2197 {"<<", LSH, BINOP_END, 0}, 2198 {">>", RSH, BINOP_END, 0}, 2199 {"==", EQUAL, BINOP_END, 0}, 2200 {"!=", NOTEQUAL, BINOP_END, 0}, 2201 {"<=", LEQ, BINOP_END, 0}, 2202 {">=", GEQ, BINOP_END, 0}, 2203 {".*", DOT_STAR, BINOP_END, FLAG_CXX} 2204 }; 2205 2206 /* Identifier-like tokens. */ 2207 static const struct token ident_tokens[] = 2208 { 2209 {"unsigned", UNSIGNED, OP_NULL, 0}, 2210 {"template", TEMPLATE, OP_NULL, FLAG_CXX}, 2211 {"volatile", VOLATILE_KEYWORD, OP_NULL, 0}, 2212 {"struct", STRUCT, OP_NULL, 0}, 2213 {"signed", SIGNED_KEYWORD, OP_NULL, 0}, 2214 {"sizeof", SIZEOF, OP_NULL, 0}, 2215 {"double", DOUBLE_KEYWORD, OP_NULL, 0}, 2216 {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX}, 2217 {"class", CLASS, OP_NULL, FLAG_CXX}, 2218 {"union", UNION, OP_NULL, 0}, 2219 {"short", SHORT, OP_NULL, 0}, 2220 {"const", CONST_KEYWORD, OP_NULL, 0}, 2221 {"enum", ENUM, OP_NULL, 0}, 2222 {"long", LONG, OP_NULL, 0}, 2223 {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX}, 2224 {"int", INT_KEYWORD, OP_NULL, 0}, 2225 {"new", NEW, OP_NULL, FLAG_CXX}, 2226 {"delete", DELETE, OP_NULL, FLAG_CXX}, 2227 {"operator", OPERATOR, OP_NULL, FLAG_CXX}, 2228 2229 {"and", ANDAND, BINOP_END, FLAG_CXX}, 2230 {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX}, 2231 {"bitand", '&', OP_NULL, FLAG_CXX}, 2232 {"bitor", '|', OP_NULL, FLAG_CXX}, 2233 {"compl", '~', OP_NULL, FLAG_CXX}, 2234 {"not", '!', OP_NULL, FLAG_CXX}, 2235 {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX}, 2236 {"or", OROR, BINOP_END, FLAG_CXX}, 2237 {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX}, 2238 {"xor", '^', OP_NULL, FLAG_CXX}, 2239 {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX}, 2240 2241 {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX }, 2242 {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX }, 2243 {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX }, 2244 {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX }, 2245 2246 {"__typeof__", TYPEOF, OP_TYPEOF, 0 }, 2247 {"__typeof", TYPEOF, OP_TYPEOF, 0 }, 2248 {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW }, 2249 {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX }, 2250 {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW } 2251 }; 2252 2253 /* When we find that lexptr (the global var defined in parse.c) is 2254 pointing at a macro invocation, we expand the invocation, and call 2255 scan_macro_expansion to save the old lexptr here and point lexptr 2256 into the expanded text. When we reach the end of that, we call 2257 end_macro_expansion to pop back to the value we saved here. The 2258 macro expansion code promises to return only fully-expanded text, 2259 so we don't need to "push" more than one level. 2260 2261 This is disgusting, of course. It would be cleaner to do all macro 2262 expansion beforehand, and then hand that to lexptr. But we don't 2263 really know where the expression ends. Remember, in a command like 2264 2265 (gdb) break *ADDRESS if CONDITION 2266 2267 we evaluate ADDRESS in the scope of the current frame, but we 2268 evaluate CONDITION in the scope of the breakpoint's location. So 2269 it's simply wrong to try to macro-expand the whole thing at once. */ 2270 static char *macro_original_text; 2271 2272 /* We save all intermediate macro expansions on this obstack for the 2273 duration of a single parse. The expansion text may sometimes have 2274 to live past the end of the expansion, due to yacc lookahead. 2275 Rather than try to be clever about saving the data for a single 2276 token, we simply keep it all and delete it after parsing has 2277 completed. */ 2278 static struct obstack expansion_obstack; 2279 2280 static void 2281 scan_macro_expansion (char *expansion) 2282 { 2283 char *copy; 2284 2285 /* We'd better not be trying to push the stack twice. */ 2286 gdb_assert (! macro_original_text); 2287 2288 /* Copy to the obstack, and then free the intermediate 2289 expansion. */ 2290 copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion)); 2291 xfree (expansion); 2292 2293 /* Save the old lexptr value, so we can return to it when we're done 2294 parsing the expanded text. */ 2295 macro_original_text = lexptr; 2296 lexptr = copy; 2297 } 2298 2299 2300 static int 2301 scanning_macro_expansion (void) 2302 { 2303 return macro_original_text != 0; 2304 } 2305 2306 2307 static void 2308 finished_macro_expansion (void) 2309 { 2310 /* There'd better be something to pop back to. */ 2311 gdb_assert (macro_original_text); 2312 2313 /* Pop back to the original text. */ 2314 lexptr = macro_original_text; 2315 macro_original_text = 0; 2316 } 2317 2318 2319 static void 2320 scan_macro_cleanup (void *dummy) 2321 { 2322 if (macro_original_text) 2323 finished_macro_expansion (); 2324 2325 obstack_free (&expansion_obstack, NULL); 2326 } 2327 2328 /* Return true iff the token represents a C++ cast operator. */ 2329 2330 static int 2331 is_cast_operator (const char *token, int len) 2332 { 2333 return (! strncmp (token, "dynamic_cast", len) 2334 || ! strncmp (token, "static_cast", len) 2335 || ! strncmp (token, "reinterpret_cast", len) 2336 || ! strncmp (token, "const_cast", len)); 2337 } 2338 2339 /* The scope used for macro expansion. */ 2340 static struct macro_scope *expression_macro_scope; 2341 2342 /* This is set if a NAME token appeared at the very end of the input 2343 string, with no whitespace separating the name from the EOF. This 2344 is used only when parsing to do field name completion. */ 2345 static int saw_name_at_eof; 2346 2347 /* This is set if the previously-returned token was a structure 2348 operator -- either '.' or ARROW. This is used only when parsing to 2349 do field name completion. */ 2350 static int last_was_structop; 2351 2352 /* Read one token, getting characters through lexptr. */ 2353 2354 static int 2355 lex_one_token (void) 2356 { 2357 int c; 2358 int namelen; 2359 unsigned int i; 2360 char *tokstart; 2361 int saw_structop = last_was_structop; 2362 char *copy; 2363 2364 last_was_structop = 0; 2365 2366 retry: 2367 2368 /* Check if this is a macro invocation that we need to expand. */ 2369 if (! scanning_macro_expansion ()) 2370 { 2371 char *expanded = macro_expand_next (&lexptr, 2372 standard_macro_lookup, 2373 expression_macro_scope); 2374 2375 if (expanded) 2376 scan_macro_expansion (expanded); 2377 } 2378 2379 prev_lexptr = lexptr; 2380 2381 tokstart = lexptr; 2382 /* See if it is a special token of length 3. */ 2383 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) 2384 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0) 2385 { 2386 if ((tokentab3[i].flags & FLAG_CXX) != 0 2387 && parse_language->la_language != language_cplus) 2388 break; 2389 2390 lexptr += 3; 2391 yylval.opcode = tokentab3[i].opcode; 2392 return tokentab3[i].token; 2393 } 2394 2395 /* See if it is a special token of length 2. */ 2396 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) 2397 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0) 2398 { 2399 if ((tokentab2[i].flags & FLAG_CXX) != 0 2400 && parse_language->la_language != language_cplus) 2401 break; 2402 2403 lexptr += 2; 2404 yylval.opcode = tokentab2[i].opcode; 2405 if (parse_completion && tokentab2[i].token == ARROW) 2406 last_was_structop = 1; 2407 return tokentab2[i].token; 2408 } 2409 2410 switch (c = *tokstart) 2411 { 2412 case 0: 2413 /* If we were just scanning the result of a macro expansion, 2414 then we need to resume scanning the original text. 2415 If we're parsing for field name completion, and the previous 2416 token allows such completion, return a COMPLETE token. 2417 Otherwise, we were already scanning the original text, and 2418 we're really done. */ 2419 if (scanning_macro_expansion ()) 2420 { 2421 finished_macro_expansion (); 2422 goto retry; 2423 } 2424 else if (saw_name_at_eof) 2425 { 2426 saw_name_at_eof = 0; 2427 return COMPLETE; 2428 } 2429 else if (saw_structop) 2430 return COMPLETE; 2431 else 2432 return 0; 2433 2434 case ' ': 2435 case '\t': 2436 case '\n': 2437 lexptr++; 2438 goto retry; 2439 2440 case '[': 2441 case '(': 2442 paren_depth++; 2443 lexptr++; 2444 if (parse_language->la_language == language_objc && c == '[') 2445 return OBJC_LBRAC; 2446 return c; 2447 2448 case ']': 2449 case ')': 2450 if (paren_depth == 0) 2451 return 0; 2452 paren_depth--; 2453 lexptr++; 2454 return c; 2455 2456 case ',': 2457 if (comma_terminates 2458 && paren_depth == 0 2459 && ! scanning_macro_expansion ()) 2460 return 0; 2461 lexptr++; 2462 return c; 2463 2464 case '.': 2465 /* Might be a floating point number. */ 2466 if (lexptr[1] < '0' || lexptr[1] > '9') 2467 { 2468 if (parse_completion) 2469 last_was_structop = 1; 2470 goto symbol; /* Nope, must be a symbol. */ 2471 } 2472 /* FALL THRU into number case. */ 2473 2474 case '0': 2475 case '1': 2476 case '2': 2477 case '3': 2478 case '4': 2479 case '5': 2480 case '6': 2481 case '7': 2482 case '8': 2483 case '9': 2484 { 2485 /* It's a number. */ 2486 int got_dot = 0, got_e = 0, toktype; 2487 char *p = tokstart; 2488 int hex = input_radix > 10; 2489 2490 if (c == '0' && (p[1] == 'x' || p[1] == 'X')) 2491 { 2492 p += 2; 2493 hex = 1; 2494 } 2495 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) 2496 { 2497 p += 2; 2498 hex = 0; 2499 } 2500 2501 for (;; ++p) 2502 { 2503 /* This test includes !hex because 'e' is a valid hex digit 2504 and thus does not indicate a floating point number when 2505 the radix is hex. */ 2506 if (!hex && !got_e && (*p == 'e' || *p == 'E')) 2507 got_dot = got_e = 1; 2508 /* This test does not include !hex, because a '.' always indicates 2509 a decimal floating point number regardless of the radix. */ 2510 else if (!got_dot && *p == '.') 2511 got_dot = 1; 2512 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 2513 && (*p == '-' || *p == '+')) 2514 /* This is the sign of the exponent, not the end of the 2515 number. */ 2516 continue; 2517 /* We will take any letters or digits. parse_number will 2518 complain if past the radix, or if L or U are not final. */ 2519 else if ((*p < '0' || *p > '9') 2520 && ((*p < 'a' || *p > 'z') 2521 && (*p < 'A' || *p > 'Z'))) 2522 break; 2523 } 2524 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); 2525 if (toktype == ERROR) 2526 { 2527 char *err_copy = (char *) alloca (p - tokstart + 1); 2528 2529 memcpy (err_copy, tokstart, p - tokstart); 2530 err_copy[p - tokstart] = 0; 2531 error (_("Invalid number \"%s\"."), err_copy); 2532 } 2533 lexptr = p; 2534 return toktype; 2535 } 2536 2537 case '@': 2538 { 2539 char *p = &tokstart[1]; 2540 size_t len = strlen ("entry"); 2541 2542 if (parse_language->la_language == language_objc) 2543 { 2544 size_t len = strlen ("selector"); 2545 2546 if (strncmp (p, "selector", len) == 0 2547 && (p[len] == '\0' || isspace (p[len]))) 2548 { 2549 lexptr = p + len; 2550 return SELECTOR; 2551 } 2552 else if (*p == '"') 2553 goto parse_string; 2554 } 2555 2556 while (isspace (*p)) 2557 p++; 2558 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len]) 2559 && p[len] != '_') 2560 { 2561 lexptr = &p[len]; 2562 return ENTRY; 2563 } 2564 } 2565 /* FALLTHRU */ 2566 case '+': 2567 case '-': 2568 case '*': 2569 case '/': 2570 case '%': 2571 case '|': 2572 case '&': 2573 case '^': 2574 case '~': 2575 case '!': 2576 case '<': 2577 case '>': 2578 case '?': 2579 case ':': 2580 case '=': 2581 case '{': 2582 case '}': 2583 symbol: 2584 lexptr++; 2585 return c; 2586 2587 case 'L': 2588 case 'u': 2589 case 'U': 2590 if (tokstart[1] != '"' && tokstart[1] != '\'') 2591 break; 2592 /* Fall through. */ 2593 case '\'': 2594 case '"': 2595 2596 parse_string: 2597 { 2598 int host_len; 2599 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval, 2600 &host_len); 2601 if (result == CHAR) 2602 { 2603 if (host_len == 0) 2604 error (_("Empty character constant.")); 2605 else if (host_len > 2 && c == '\'') 2606 { 2607 ++tokstart; 2608 namelen = lexptr - tokstart - 1; 2609 goto tryname; 2610 } 2611 else if (host_len > 1) 2612 error (_("Invalid character constant.")); 2613 } 2614 return result; 2615 } 2616 } 2617 2618 if (!(c == '_' || c == '$' 2619 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 2620 /* We must have come across a bad character (e.g. ';'). */ 2621 error (_("Invalid character '%c' in expression."), c); 2622 2623 /* It's a name. See how long it is. */ 2624 namelen = 0; 2625 for (c = tokstart[namelen]; 2626 (c == '_' || c == '$' || (c >= '0' && c <= '9') 2627 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');) 2628 { 2629 /* Template parameter lists are part of the name. 2630 FIXME: This mishandles `print $a<4&&$a>3'. */ 2631 2632 if (c == '<') 2633 { 2634 if (! is_cast_operator (tokstart, namelen)) 2635 { 2636 /* Scan ahead to get rest of the template specification. Note 2637 that we look ahead only when the '<' adjoins non-whitespace 2638 characters; for comparison expressions, e.g. "a < b > c", 2639 there must be spaces before the '<', etc. */ 2640 2641 char * p = find_template_name_end (tokstart + namelen); 2642 if (p) 2643 namelen = p - tokstart; 2644 } 2645 break; 2646 } 2647 c = tokstart[++namelen]; 2648 } 2649 2650 /* The token "if" terminates the expression and is NOT removed from 2651 the input stream. It doesn't count if it appears in the 2652 expansion of a macro. */ 2653 if (namelen == 2 2654 && tokstart[0] == 'i' 2655 && tokstart[1] == 'f' 2656 && ! scanning_macro_expansion ()) 2657 { 2658 return 0; 2659 } 2660 2661 /* For the same reason (breakpoint conditions), "thread N" 2662 terminates the expression. "thread" could be an identifier, but 2663 an identifier is never followed by a number without intervening 2664 punctuation. "task" is similar. Handle abbreviations of these, 2665 similarly to breakpoint.c:find_condition_and_thread. */ 2666 if (namelen >= 1 2667 && (strncmp (tokstart, "thread", namelen) == 0 2668 || strncmp (tokstart, "task", namelen) == 0) 2669 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t') 2670 && ! scanning_macro_expansion ()) 2671 { 2672 char *p = tokstart + namelen + 1; 2673 while (*p == ' ' || *p == '\t') 2674 p++; 2675 if (*p >= '0' && *p <= '9') 2676 return 0; 2677 } 2678 2679 lexptr += namelen; 2680 2681 tryname: 2682 2683 yylval.sval.ptr = tokstart; 2684 yylval.sval.length = namelen; 2685 2686 /* Catch specific keywords. */ 2687 copy = copy_name (yylval.sval); 2688 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++) 2689 if (strcmp (copy, ident_tokens[i].operator) == 0) 2690 { 2691 if ((ident_tokens[i].flags & FLAG_CXX) != 0 2692 && parse_language->la_language != language_cplus) 2693 break; 2694 2695 if ((ident_tokens[i].flags & FLAG_SHADOW) != 0) 2696 { 2697 struct field_of_this_result is_a_field_of_this; 2698 2699 if (lookup_symbol (copy, expression_context_block, 2700 VAR_DOMAIN, 2701 (parse_language->la_language == language_cplus 2702 ? &is_a_field_of_this 2703 : NULL)) 2704 != NULL) 2705 { 2706 /* The keyword is shadowed. */ 2707 break; 2708 } 2709 } 2710 2711 /* It is ok to always set this, even though we don't always 2712 strictly need to. */ 2713 yylval.opcode = ident_tokens[i].opcode; 2714 return ident_tokens[i].token; 2715 } 2716 2717 if (*tokstart == '$') 2718 return VARIABLE; 2719 2720 if (parse_completion && *lexptr == '\0') 2721 saw_name_at_eof = 1; 2722 2723 yylval.ssym.stoken = yylval.sval; 2724 yylval.ssym.sym = NULL; 2725 yylval.ssym.is_a_field_of_this = 0; 2726 return NAME; 2727 } 2728 2729 /* An object of this type is pushed on a FIFO by the "outer" lexer. */ 2730 typedef struct 2731 { 2732 int token; 2733 YYSTYPE value; 2734 } token_and_value; 2735 2736 DEF_VEC_O (token_and_value); 2737 2738 /* A FIFO of tokens that have been read but not yet returned to the 2739 parser. */ 2740 static VEC (token_and_value) *token_fifo; 2741 2742 /* Non-zero if the lexer should return tokens from the FIFO. */ 2743 static int popping; 2744 2745 /* Temporary storage for c_lex; this holds symbol names as they are 2746 built up. */ 2747 static struct obstack name_obstack; 2748 2749 /* Classify a NAME token. The contents of the token are in `yylval'. 2750 Updates yylval and returns the new token type. BLOCK is the block 2751 in which lookups start; this can be NULL to mean the global 2752 scope. */ 2753 static int 2754 classify_name (const struct block *block) 2755 { 2756 struct symbol *sym; 2757 char *copy; 2758 struct field_of_this_result is_a_field_of_this; 2759 2760 copy = copy_name (yylval.sval); 2761 2762 /* Initialize this in case we *don't* use it in this call; that way 2763 we can refer to it unconditionally below. */ 2764 memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this)); 2765 2766 sym = lookup_symbol (copy, block, VAR_DOMAIN, 2767 parse_language->la_name_of_this 2768 ? &is_a_field_of_this : NULL); 2769 2770 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK) 2771 { 2772 yylval.ssym.sym = sym; 2773 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 2774 return BLOCKNAME; 2775 } 2776 else if (!sym) 2777 { 2778 /* See if it's a file name. */ 2779 struct symtab *symtab; 2780 2781 symtab = lookup_symtab (copy); 2782 if (symtab) 2783 { 2784 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK); 2785 return FILENAME; 2786 } 2787 2788 /* If we found a field of 'this', we might have erroneously 2789 found a constructor where we wanted a type name. Handle this 2790 case by noticing that we found a constructor and then look up 2791 the type tag instead. */ 2792 if (is_a_field_of_this.type != NULL 2793 && is_a_field_of_this.fn_field != NULL 2794 && TYPE_FN_FIELD_CONSTRUCTOR (is_a_field_of_this.fn_field->fn_fields, 2795 0)) 2796 { 2797 struct field_of_this_result inner_is_a_field_of_this; 2798 2799 sym = lookup_symbol (copy, block, STRUCT_DOMAIN, 2800 &inner_is_a_field_of_this); 2801 if (sym != NULL) 2802 { 2803 yylval.tsym.type = SYMBOL_TYPE (sym); 2804 return TYPENAME; 2805 } 2806 } 2807 } 2808 2809 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF) 2810 { 2811 yylval.tsym.type = SYMBOL_TYPE (sym); 2812 return TYPENAME; 2813 } 2814 2815 yylval.tsym.type 2816 = language_lookup_primitive_type_by_name (parse_language, 2817 parse_gdbarch, copy); 2818 if (yylval.tsym.type != NULL) 2819 return TYPENAME; 2820 2821 /* See if it's an ObjC classname. */ 2822 if (parse_language->la_language == language_objc && !sym) 2823 { 2824 CORE_ADDR Class = lookup_objc_class (parse_gdbarch, copy); 2825 if (Class) 2826 { 2827 yylval.class.class = Class; 2828 sym = lookup_struct_typedef (copy, expression_context_block, 1); 2829 if (sym) 2830 yylval.class.type = SYMBOL_TYPE (sym); 2831 return CLASSNAME; 2832 } 2833 } 2834 2835 /* Input names that aren't symbols but ARE valid hex numbers, when 2836 the input radix permits them, can be names or numbers depending 2837 on the parse. Note we support radixes > 16 here. */ 2838 if (!sym 2839 && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10) 2840 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10))) 2841 { 2842 YYSTYPE newlval; /* Its value is ignored. */ 2843 int hextype = parse_number (copy, yylval.sval.length, 0, &newlval); 2844 if (hextype == INT) 2845 { 2846 yylval.ssym.sym = sym; 2847 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 2848 return NAME_OR_INT; 2849 } 2850 } 2851 2852 /* Any other kind of symbol */ 2853 yylval.ssym.sym = sym; 2854 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 2855 2856 if (sym == NULL 2857 && parse_language->la_language == language_cplus 2858 && is_a_field_of_this.type == NULL 2859 && !lookup_minimal_symbol (copy, NULL, NULL)) 2860 return UNKNOWN_CPP_NAME; 2861 2862 return NAME; 2863 } 2864 2865 /* Like classify_name, but used by the inner loop of the lexer, when a 2866 name might have already been seen. CONTEXT is the context type, or 2867 NULL if this is the first component of a name. */ 2868 2869 static int 2870 classify_inner_name (const struct block *block, struct type *context) 2871 { 2872 struct type *type; 2873 char *copy; 2874 2875 if (context == NULL) 2876 return classify_name (block); 2877 2878 type = check_typedef (context); 2879 if (TYPE_CODE (type) != TYPE_CODE_STRUCT 2880 && TYPE_CODE (type) != TYPE_CODE_UNION 2881 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE) 2882 return ERROR; 2883 2884 copy = copy_name (yylval.ssym.stoken); 2885 yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block); 2886 if (yylval.ssym.sym == NULL) 2887 return ERROR; 2888 2889 switch (SYMBOL_CLASS (yylval.ssym.sym)) 2890 { 2891 case LOC_BLOCK: 2892 case LOC_LABEL: 2893 return ERROR; 2894 2895 case LOC_TYPEDEF: 2896 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);; 2897 return TYPENAME; 2898 2899 default: 2900 return NAME; 2901 } 2902 internal_error (__FILE__, __LINE__, _("not reached")); 2903 } 2904 2905 /* The outer level of a two-level lexer. This calls the inner lexer 2906 to return tokens. It then either returns these tokens, or 2907 aggregates them into a larger token. This lets us work around a 2908 problem in our parsing approach, where the parser could not 2909 distinguish between qualified names and qualified types at the 2910 right point. 2911 2912 This approach is still not ideal, because it mishandles template 2913 types. See the comment in lex_one_token for an example. However, 2914 this is still an improvement over the earlier approach, and will 2915 suffice until we move to better parsing technology. */ 2916 static int 2917 yylex (void) 2918 { 2919 token_and_value current; 2920 int first_was_coloncolon, last_was_coloncolon, first_iter; 2921 struct type *context_type = NULL; 2922 2923 if (popping && !VEC_empty (token_and_value, token_fifo)) 2924 { 2925 token_and_value tv = *VEC_index (token_and_value, token_fifo, 0); 2926 VEC_ordered_remove (token_and_value, token_fifo, 0); 2927 yylval = tv.value; 2928 return tv.token; 2929 } 2930 popping = 0; 2931 2932 current.token = lex_one_token (); 2933 if (current.token == NAME) 2934 current.token = classify_name (expression_context_block); 2935 if (parse_language->la_language != language_cplus 2936 || (current.token != TYPENAME && current.token != COLONCOLON)) 2937 return current.token; 2938 2939 first_was_coloncolon = current.token == COLONCOLON; 2940 last_was_coloncolon = first_was_coloncolon; 2941 obstack_free (&name_obstack, obstack_base (&name_obstack)); 2942 if (!last_was_coloncolon) 2943 { 2944 obstack_grow (&name_obstack, yylval.sval.ptr, yylval.sval.length); 2945 context_type = yylval.tsym.type; 2946 } 2947 current.value = yylval; 2948 first_iter = 1; 2949 while (1) 2950 { 2951 token_and_value next; 2952 2953 next.token = lex_one_token (); 2954 next.value = yylval; 2955 2956 if (next.token == NAME && last_was_coloncolon) 2957 { 2958 int classification; 2959 2960 classification = classify_inner_name (first_was_coloncolon 2961 ? NULL 2962 : expression_context_block, 2963 context_type); 2964 /* We keep going until we either run out of names, or until 2965 we have a qualified name which is not a type. */ 2966 if (classification != TYPENAME && classification != NAME) 2967 { 2968 /* Push the final component and leave the loop. */ 2969 VEC_safe_push (token_and_value, token_fifo, &next); 2970 break; 2971 } 2972 2973 /* Update the partial name we are constructing. */ 2974 if (context_type != NULL) 2975 { 2976 /* We don't want to put a leading "::" into the name. */ 2977 obstack_grow_str (&name_obstack, "::"); 2978 } 2979 obstack_grow (&name_obstack, next.value.sval.ptr, 2980 next.value.sval.length); 2981 2982 yylval.sval.ptr = obstack_base (&name_obstack); 2983 yylval.sval.length = obstack_object_size (&name_obstack); 2984 current.value = yylval; 2985 current.token = classification; 2986 2987 last_was_coloncolon = 0; 2988 2989 if (classification == NAME) 2990 break; 2991 2992 context_type = yylval.tsym.type; 2993 } 2994 else if (next.token == COLONCOLON && !last_was_coloncolon) 2995 last_was_coloncolon = 1; 2996 else 2997 { 2998 /* We've reached the end of the name. */ 2999 VEC_safe_push (token_and_value, token_fifo, &next); 3000 break; 3001 } 3002 3003 first_iter = 0; 3004 } 3005 3006 popping = 1; 3007 3008 /* If we ended with a "::", insert it too. */ 3009 if (last_was_coloncolon) 3010 { 3011 token_and_value cc; 3012 memset (&cc, 0, sizeof (token_and_value)); 3013 if (first_was_coloncolon && first_iter) 3014 { 3015 yylval = cc.value; 3016 return COLONCOLON; 3017 } 3018 cc.token = COLONCOLON; 3019 VEC_safe_insert (token_and_value, token_fifo, 0, &cc); 3020 } 3021 3022 yylval = current.value; 3023 yylval.sval.ptr = obstack_copy0 (&expansion_obstack, 3024 yylval.sval.ptr, 3025 yylval.sval.length); 3026 return current.token; 3027 } 3028 3029 int 3030 c_parse (void) 3031 { 3032 int result; 3033 struct cleanup *back_to = make_cleanup (free_current_contents, 3034 &expression_macro_scope); 3035 3036 /* Set up the scope for macro expansion. */ 3037 expression_macro_scope = NULL; 3038 3039 if (expression_context_block) 3040 expression_macro_scope 3041 = sal_macro_scope (find_pc_line (expression_context_pc, 0)); 3042 else 3043 expression_macro_scope = default_macro_scope (); 3044 if (! expression_macro_scope) 3045 expression_macro_scope = user_macro_scope (); 3046 3047 /* Initialize macro expansion code. */ 3048 obstack_init (&expansion_obstack); 3049 gdb_assert (! macro_original_text); 3050 make_cleanup (scan_macro_cleanup, 0); 3051 3052 make_cleanup_restore_integer (&yydebug); 3053 yydebug = parser_debug; 3054 3055 /* Initialize some state used by the lexer. */ 3056 last_was_structop = 0; 3057 saw_name_at_eof = 0; 3058 3059 VEC_free (token_and_value, token_fifo); 3060 popping = 0; 3061 obstack_init (&name_obstack); 3062 make_cleanup_obstack_free (&name_obstack); 3063 3064 result = yyparse (); 3065 do_cleanups (back_to); 3066 return result; 3067 } 3068 3069 3070 void 3071 yyerror (char *msg) 3072 { 3073 if (prev_lexptr) 3074 lexptr = prev_lexptr; 3075 3076 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr); 3077 } 3078