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