1 /* YACC parser for D expressions, for GDB. 2 3 Copyright (C) 2014-2019 Free Software 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 /* This file is derived from c-exp.y, jv-exp.y. */ 21 22 /* Parse a D expression from text in a string, 23 and return the result as a struct expression pointer. 24 That structure contains arithmetic operations in reverse polish, 25 with constants represented by operations that are followed by special data. 26 See expression.h for the details of the format. 27 What is important here is that it can be built up sequentially 28 during the process of parsing; the lower levels of the tree always 29 come first in the result. 30 31 Note that malloc's and realloc's in this file are transformed to 32 xmalloc and xrealloc respectively by the same sed command in the 33 makefile that remaps any other malloc/realloc inserted by the parser 34 generator. Doing this with #defines and trying to control the interaction 35 with include files (<malloc.h> and <stdlib.h> for example) just became 36 too messy, particularly when such includes can be inserted at random 37 times by the parser generator. */ 38 39 %{ 40 41 #include "defs.h" 42 #include <ctype.h> 43 #include "expression.h" 44 #include "value.h" 45 #include "parser-defs.h" 46 #include "language.h" 47 #include "c-lang.h" 48 #include "d-lang.h" 49 #include "bfd.h" /* Required by objfiles.h. */ 50 #include "symfile.h" /* Required by objfiles.h. */ 51 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 52 #include "charset.h" 53 #include "block.h" 54 55 #define parse_type(ps) builtin_type (parse_gdbarch (ps)) 56 #define parse_d_type(ps) builtin_d_type (parse_gdbarch (ps)) 57 58 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, 59 etc). */ 60 #define GDB_YY_REMAP_PREFIX d_ 61 #include "yy-remap.h" 62 63 /* The state of the parser, used internally when we are parsing the 64 expression. */ 65 66 static struct parser_state *pstate = NULL; 67 68 int yyparse (void); 69 70 static int yylex (void); 71 72 static void yyerror (const char *); 73 74 static int type_aggregate_p (struct type *); 75 76 %} 77 78 /* Although the yacc "value" of an expression is not used, 79 since the result is stored in the structure being created, 80 other node types do have values. */ 81 82 %union 83 { 84 struct { 85 LONGEST val; 86 struct type *type; 87 } typed_val_int; 88 struct { 89 gdb_byte val[16]; 90 struct type *type; 91 } typed_val_float; 92 struct symbol *sym; 93 struct type *tval; 94 struct typed_stoken tsval; 95 struct stoken sval; 96 struct ttype tsym; 97 struct symtoken ssym; 98 int ival; 99 int voidval; 100 struct block *bval; 101 enum exp_opcode opcode; 102 struct stoken_vector svec; 103 } 104 105 %{ 106 /* YYSTYPE gets defined by %union */ 107 static int parse_number (struct parser_state *, const char *, 108 int, int, YYSTYPE *); 109 %} 110 111 %token <sval> IDENTIFIER UNKNOWN_NAME 112 %token <tsym> TYPENAME 113 %token <voidval> COMPLETE 114 115 /* A NAME_OR_INT is a symbol which is not known in the symbol table, 116 but which would parse as a valid number in the current input radix. 117 E.g. "c" when input_radix==16. Depending on the parse, it will be 118 turned into a name or into a number. */ 119 120 %token <sval> NAME_OR_INT 121 122 %token <typed_val_int> INTEGER_LITERAL 123 %token <typed_val_float> FLOAT_LITERAL 124 %token <tsval> CHARACTER_LITERAL 125 %token <tsval> STRING_LITERAL 126 127 %type <svec> StringExp 128 %type <tval> BasicType TypeExp 129 %type <sval> IdentifierExp 130 %type <ival> ArrayLiteral 131 132 %token ENTRY 133 %token ERROR 134 135 /* Keywords that have a constant value. */ 136 %token TRUE_KEYWORD FALSE_KEYWORD NULL_KEYWORD 137 /* Class 'super' accessor. */ 138 %token SUPER_KEYWORD 139 /* Properties. */ 140 %token CAST_KEYWORD SIZEOF_KEYWORD 141 %token TYPEOF_KEYWORD TYPEID_KEYWORD 142 %token INIT_KEYWORD 143 /* Comparison keywords. */ 144 /* Type storage classes. */ 145 %token IMMUTABLE_KEYWORD CONST_KEYWORD SHARED_KEYWORD 146 /* Non-scalar type keywords. */ 147 %token STRUCT_KEYWORD UNION_KEYWORD 148 %token CLASS_KEYWORD INTERFACE_KEYWORD 149 %token ENUM_KEYWORD TEMPLATE_KEYWORD 150 %token DELEGATE_KEYWORD FUNCTION_KEYWORD 151 152 %token <sval> DOLLAR_VARIABLE 153 154 %token <opcode> ASSIGN_MODIFY 155 156 %left ',' 157 %right '=' ASSIGN_MODIFY 158 %right '?' 159 %left OROR 160 %left ANDAND 161 %left '|' 162 %left '^' 163 %left '&' 164 %left EQUAL NOTEQUAL '<' '>' LEQ GEQ 165 %right LSH RSH 166 %left '+' '-' 167 %left '*' '/' '%' 168 %right HATHAT 169 %left IDENTITY NOTIDENTITY 170 %right INCREMENT DECREMENT 171 %right '.' '[' '(' 172 %token DOTDOT 173 174 175 %% 176 177 start : 178 Expression 179 | TypeExp 180 ; 181 182 /* Expressions, including the comma operator. */ 183 184 Expression: 185 CommaExpression 186 ; 187 188 CommaExpression: 189 AssignExpression 190 | AssignExpression ',' CommaExpression 191 { write_exp_elt_opcode (pstate, BINOP_COMMA); } 192 ; 193 194 AssignExpression: 195 ConditionalExpression 196 | ConditionalExpression '=' AssignExpression 197 { write_exp_elt_opcode (pstate, BINOP_ASSIGN); } 198 | ConditionalExpression ASSIGN_MODIFY AssignExpression 199 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); 200 write_exp_elt_opcode (pstate, $2); 201 write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); } 202 ; 203 204 ConditionalExpression: 205 OrOrExpression 206 | OrOrExpression '?' Expression ':' ConditionalExpression 207 { write_exp_elt_opcode (pstate, TERNOP_COND); } 208 ; 209 210 OrOrExpression: 211 AndAndExpression 212 | OrOrExpression OROR AndAndExpression 213 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); } 214 ; 215 216 AndAndExpression: 217 OrExpression 218 | AndAndExpression ANDAND OrExpression 219 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); } 220 ; 221 222 OrExpression: 223 XorExpression 224 | OrExpression '|' XorExpression 225 { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); } 226 ; 227 228 XorExpression: 229 AndExpression 230 | XorExpression '^' AndExpression 231 { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); } 232 ; 233 234 AndExpression: 235 CmpExpression 236 | AndExpression '&' CmpExpression 237 { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); } 238 ; 239 240 CmpExpression: 241 ShiftExpression 242 | EqualExpression 243 | IdentityExpression 244 | RelExpression 245 ; 246 247 EqualExpression: 248 ShiftExpression EQUAL ShiftExpression 249 { write_exp_elt_opcode (pstate, BINOP_EQUAL); } 250 | ShiftExpression NOTEQUAL ShiftExpression 251 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); } 252 ; 253 254 IdentityExpression: 255 ShiftExpression IDENTITY ShiftExpression 256 { write_exp_elt_opcode (pstate, BINOP_EQUAL); } 257 | ShiftExpression NOTIDENTITY ShiftExpression 258 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); } 259 ; 260 261 RelExpression: 262 ShiftExpression '<' ShiftExpression 263 { write_exp_elt_opcode (pstate, BINOP_LESS); } 264 | ShiftExpression LEQ ShiftExpression 265 { write_exp_elt_opcode (pstate, BINOP_LEQ); } 266 | ShiftExpression '>' ShiftExpression 267 { write_exp_elt_opcode (pstate, BINOP_GTR); } 268 | ShiftExpression GEQ ShiftExpression 269 { write_exp_elt_opcode (pstate, BINOP_GEQ); } 270 ; 271 272 ShiftExpression: 273 AddExpression 274 | ShiftExpression LSH AddExpression 275 { write_exp_elt_opcode (pstate, BINOP_LSH); } 276 | ShiftExpression RSH AddExpression 277 { write_exp_elt_opcode (pstate, BINOP_RSH); } 278 ; 279 280 AddExpression: 281 MulExpression 282 | AddExpression '+' MulExpression 283 { write_exp_elt_opcode (pstate, BINOP_ADD); } 284 | AddExpression '-' MulExpression 285 { write_exp_elt_opcode (pstate, BINOP_SUB); } 286 | AddExpression '~' MulExpression 287 { write_exp_elt_opcode (pstate, BINOP_CONCAT); } 288 ; 289 290 MulExpression: 291 UnaryExpression 292 | MulExpression '*' UnaryExpression 293 { write_exp_elt_opcode (pstate, BINOP_MUL); } 294 | MulExpression '/' UnaryExpression 295 { write_exp_elt_opcode (pstate, BINOP_DIV); } 296 | MulExpression '%' UnaryExpression 297 { write_exp_elt_opcode (pstate, BINOP_REM); } 298 299 UnaryExpression: 300 '&' UnaryExpression 301 { write_exp_elt_opcode (pstate, UNOP_ADDR); } 302 | INCREMENT UnaryExpression 303 { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); } 304 | DECREMENT UnaryExpression 305 { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); } 306 | '*' UnaryExpression 307 { write_exp_elt_opcode (pstate, UNOP_IND); } 308 | '-' UnaryExpression 309 { write_exp_elt_opcode (pstate, UNOP_NEG); } 310 | '+' UnaryExpression 311 { write_exp_elt_opcode (pstate, UNOP_PLUS); } 312 | '!' UnaryExpression 313 { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); } 314 | '~' UnaryExpression 315 { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); } 316 | TypeExp '.' SIZEOF_KEYWORD 317 { write_exp_elt_opcode (pstate, UNOP_SIZEOF); } 318 | CastExpression 319 | PowExpression 320 ; 321 322 CastExpression: 323 CAST_KEYWORD '(' TypeExp ')' UnaryExpression 324 { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); } 325 /* C style cast is illegal D, but is still recognised in 326 the grammar, so we keep this around for convenience. */ 327 | '(' TypeExp ')' UnaryExpression 328 { write_exp_elt_opcode (pstate, UNOP_CAST_TYPE); } 329 330 ; 331 332 PowExpression: 333 PostfixExpression 334 | PostfixExpression HATHAT UnaryExpression 335 { write_exp_elt_opcode (pstate, BINOP_EXP); } 336 ; 337 338 PostfixExpression: 339 PrimaryExpression 340 | PostfixExpression '.' COMPLETE 341 { struct stoken s; 342 mark_struct_expression (pstate); 343 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); 344 s.ptr = ""; 345 s.length = 0; 346 write_exp_string (pstate, s); 347 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); } 348 | PostfixExpression '.' IDENTIFIER 349 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); 350 write_exp_string (pstate, $3); 351 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); } 352 | PostfixExpression '.' IDENTIFIER COMPLETE 353 { mark_struct_expression (pstate); 354 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); 355 write_exp_string (pstate, $3); 356 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); } 357 | PostfixExpression '.' SIZEOF_KEYWORD 358 { write_exp_elt_opcode (pstate, UNOP_SIZEOF); } 359 | PostfixExpression INCREMENT 360 { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); } 361 | PostfixExpression DECREMENT 362 { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); } 363 | CallExpression 364 | IndexExpression 365 | SliceExpression 366 ; 367 368 ArgumentList: 369 AssignExpression 370 { arglist_len = 1; } 371 | ArgumentList ',' AssignExpression 372 { arglist_len++; } 373 ; 374 375 ArgumentList_opt: 376 /* EMPTY */ 377 { arglist_len = 0; } 378 | ArgumentList 379 ; 380 381 CallExpression: 382 PostfixExpression '(' 383 { start_arglist (); } 384 ArgumentList_opt ')' 385 { write_exp_elt_opcode (pstate, OP_FUNCALL); 386 write_exp_elt_longcst (pstate, (LONGEST) end_arglist ()); 387 write_exp_elt_opcode (pstate, OP_FUNCALL); } 388 ; 389 390 IndexExpression: 391 PostfixExpression '[' ArgumentList ']' 392 { if (arglist_len > 0) 393 { 394 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT); 395 write_exp_elt_longcst (pstate, (LONGEST) arglist_len); 396 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT); 397 } 398 else 399 write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); 400 } 401 ; 402 403 SliceExpression: 404 PostfixExpression '[' ']' 405 { /* Do nothing. */ } 406 | PostfixExpression '[' AssignExpression DOTDOT AssignExpression ']' 407 { write_exp_elt_opcode (pstate, TERNOP_SLICE); } 408 ; 409 410 PrimaryExpression: 411 '(' Expression ')' 412 { /* Do nothing. */ } 413 | IdentifierExp 414 { struct bound_minimal_symbol msymbol; 415 char *copy = copy_name ($1); 416 struct field_of_this_result is_a_field_of_this; 417 struct block_symbol sym; 418 419 /* Handle VAR, which could be local or global. */ 420 sym = lookup_symbol (copy, expression_context_block, VAR_DOMAIN, 421 &is_a_field_of_this); 422 if (sym.symbol && SYMBOL_CLASS (sym.symbol) != LOC_TYPEDEF) 423 { 424 if (symbol_read_needs_frame (sym.symbol)) 425 innermost_block.update (sym); 426 write_exp_elt_opcode (pstate, OP_VAR_VALUE); 427 write_exp_elt_block (pstate, sym.block); 428 write_exp_elt_sym (pstate, sym.symbol); 429 write_exp_elt_opcode (pstate, OP_VAR_VALUE); 430 } 431 else if (is_a_field_of_this.type != NULL) 432 { 433 /* It hangs off of `this'. Must not inadvertently convert from a 434 method call to data ref. */ 435 innermost_block.update (sym); 436 write_exp_elt_opcode (pstate, OP_THIS); 437 write_exp_elt_opcode (pstate, OP_THIS); 438 write_exp_elt_opcode (pstate, STRUCTOP_PTR); 439 write_exp_string (pstate, $1); 440 write_exp_elt_opcode (pstate, STRUCTOP_PTR); 441 } 442 else 443 { 444 /* Lookup foreign name in global static symbols. */ 445 msymbol = lookup_bound_minimal_symbol (copy); 446 if (msymbol.minsym != NULL) 447 write_exp_msymbol (pstate, msymbol); 448 else if (!have_full_symbols () && !have_partial_symbols ()) 449 error (_("No symbol table is loaded. Use the \"file\" command")); 450 else 451 error (_("No symbol \"%s\" in current context."), copy); 452 } 453 } 454 | TypeExp '.' IdentifierExp 455 { struct type *type = check_typedef ($1); 456 457 /* Check if the qualified name is in the global 458 context. However if the symbol has not already 459 been resolved, it's not likely to be found. */ 460 if (TYPE_CODE (type) == TYPE_CODE_MODULE) 461 { 462 struct bound_minimal_symbol msymbol; 463 struct block_symbol sym; 464 const char *type_name = TYPE_SAFE_NAME (type); 465 int type_name_len = strlen (type_name); 466 std::string name 467 = string_printf ("%.*s.%.*s", 468 type_name_len, type_name, 469 $3.length, $3.ptr); 470 471 sym = 472 lookup_symbol (name.c_str (), 473 (const struct block *) NULL, 474 VAR_DOMAIN, NULL); 475 if (sym.symbol) 476 { 477 write_exp_elt_opcode (pstate, OP_VAR_VALUE); 478 write_exp_elt_block (pstate, sym.block); 479 write_exp_elt_sym (pstate, sym.symbol); 480 write_exp_elt_opcode (pstate, OP_VAR_VALUE); 481 break; 482 } 483 484 msymbol = lookup_bound_minimal_symbol (name.c_str ()); 485 if (msymbol.minsym != NULL) 486 write_exp_msymbol (pstate, msymbol); 487 else if (!have_full_symbols () && !have_partial_symbols ()) 488 error (_("No symbol table is loaded. Use the \"file\" command.")); 489 else 490 error (_("No symbol \"%s\" in current context."), 491 name.c_str ()); 492 } 493 494 /* Check if the qualified name resolves as a member 495 of an aggregate or an enum type. */ 496 if (!type_aggregate_p (type)) 497 error (_("`%s' is not defined as an aggregate type."), 498 TYPE_SAFE_NAME (type)); 499 500 write_exp_elt_opcode (pstate, OP_SCOPE); 501 write_exp_elt_type (pstate, type); 502 write_exp_string (pstate, $3); 503 write_exp_elt_opcode (pstate, OP_SCOPE); 504 } 505 | DOLLAR_VARIABLE 506 { write_dollar_variable (pstate, $1); } 507 | NAME_OR_INT 508 { YYSTYPE val; 509 parse_number (pstate, $1.ptr, $1.length, 0, &val); 510 write_exp_elt_opcode (pstate, OP_LONG); 511 write_exp_elt_type (pstate, val.typed_val_int.type); 512 write_exp_elt_longcst (pstate, 513 (LONGEST) val.typed_val_int.val); 514 write_exp_elt_opcode (pstate, OP_LONG); } 515 | NULL_KEYWORD 516 { struct type *type = parse_d_type (pstate)->builtin_void; 517 type = lookup_pointer_type (type); 518 write_exp_elt_opcode (pstate, OP_LONG); 519 write_exp_elt_type (pstate, type); 520 write_exp_elt_longcst (pstate, (LONGEST) 0); 521 write_exp_elt_opcode (pstate, OP_LONG); } 522 | TRUE_KEYWORD 523 { write_exp_elt_opcode (pstate, OP_BOOL); 524 write_exp_elt_longcst (pstate, (LONGEST) 1); 525 write_exp_elt_opcode (pstate, OP_BOOL); } 526 | FALSE_KEYWORD 527 { write_exp_elt_opcode (pstate, OP_BOOL); 528 write_exp_elt_longcst (pstate, (LONGEST) 0); 529 write_exp_elt_opcode (pstate, OP_BOOL); } 530 | INTEGER_LITERAL 531 { write_exp_elt_opcode (pstate, OP_LONG); 532 write_exp_elt_type (pstate, $1.type); 533 write_exp_elt_longcst (pstate, (LONGEST)($1.val)); 534 write_exp_elt_opcode (pstate, OP_LONG); } 535 | FLOAT_LITERAL 536 { write_exp_elt_opcode (pstate, OP_FLOAT); 537 write_exp_elt_type (pstate, $1.type); 538 write_exp_elt_floatcst (pstate, $1.val); 539 write_exp_elt_opcode (pstate, OP_FLOAT); } 540 | CHARACTER_LITERAL 541 { struct stoken_vector vec; 542 vec.len = 1; 543 vec.tokens = &$1; 544 write_exp_string_vector (pstate, $1.type, &vec); } 545 | StringExp 546 { int i; 547 write_exp_string_vector (pstate, 0, &$1); 548 for (i = 0; i < $1.len; ++i) 549 free ($1.tokens[i].ptr); 550 free ($1.tokens); } 551 | ArrayLiteral 552 { write_exp_elt_opcode (pstate, OP_ARRAY); 553 write_exp_elt_longcst (pstate, (LONGEST) 0); 554 write_exp_elt_longcst (pstate, (LONGEST) $1 - 1); 555 write_exp_elt_opcode (pstate, OP_ARRAY); } 556 | TYPEOF_KEYWORD '(' Expression ')' 557 { write_exp_elt_opcode (pstate, OP_TYPEOF); } 558 ; 559 560 ArrayLiteral: 561 '[' ArgumentList_opt ']' 562 { $$ = arglist_len; } 563 ; 564 565 IdentifierExp: 566 IDENTIFIER 567 ; 568 569 StringExp: 570 STRING_LITERAL 571 { /* We copy the string here, and not in the 572 lexer, to guarantee that we do not leak a 573 string. Note that we follow the 574 NUL-termination convention of the 575 lexer. */ 576 struct typed_stoken *vec = XNEW (struct typed_stoken); 577 $$.len = 1; 578 $$.tokens = vec; 579 580 vec->type = $1.type; 581 vec->length = $1.length; 582 vec->ptr = (char *) malloc ($1.length + 1); 583 memcpy (vec->ptr, $1.ptr, $1.length + 1); 584 } 585 | StringExp STRING_LITERAL 586 { /* Note that we NUL-terminate here, but just 587 for convenience. */ 588 char *p; 589 ++$$.len; 590 $$.tokens 591 = XRESIZEVEC (struct typed_stoken, $$.tokens, $$.len); 592 593 p = (char *) malloc ($2.length + 1); 594 memcpy (p, $2.ptr, $2.length + 1); 595 596 $$.tokens[$$.len - 1].type = $2.type; 597 $$.tokens[$$.len - 1].length = $2.length; 598 $$.tokens[$$.len - 1].ptr = p; 599 } 600 ; 601 602 TypeExp: 603 '(' TypeExp ')' 604 { /* Do nothing. */ } 605 | BasicType 606 { write_exp_elt_opcode (pstate, OP_TYPE); 607 write_exp_elt_type (pstate, $1); 608 write_exp_elt_opcode (pstate, OP_TYPE); } 609 | BasicType BasicType2 610 { $$ = follow_types ($1); 611 write_exp_elt_opcode (pstate, OP_TYPE); 612 write_exp_elt_type (pstate, $$); 613 write_exp_elt_opcode (pstate, OP_TYPE); 614 } 615 ; 616 617 BasicType2: 618 '*' 619 { push_type (tp_pointer); } 620 | '*' BasicType2 621 { push_type (tp_pointer); } 622 | '[' INTEGER_LITERAL ']' 623 { push_type_int ($2.val); 624 push_type (tp_array); } 625 | '[' INTEGER_LITERAL ']' BasicType2 626 { push_type_int ($2.val); 627 push_type (tp_array); } 628 ; 629 630 BasicType: 631 TYPENAME 632 { $$ = $1.type; } 633 ; 634 635 %% 636 637 /* Return true if the type is aggregate-like. */ 638 639 static int 640 type_aggregate_p (struct type *type) 641 { 642 return (TYPE_CODE (type) == TYPE_CODE_STRUCT 643 || TYPE_CODE (type) == TYPE_CODE_UNION 644 || TYPE_CODE (type) == TYPE_CODE_MODULE 645 || (TYPE_CODE (type) == TYPE_CODE_ENUM 646 && TYPE_DECLARED_CLASS (type))); 647 } 648 649 /* Take care of parsing a number (anything that starts with a digit). 650 Set yylval and return the token type; update lexptr. 651 LEN is the number of characters in it. */ 652 653 /*** Needs some error checking for the float case ***/ 654 655 static int 656 parse_number (struct parser_state *ps, const char *p, 657 int len, int parsed_float, YYSTYPE *putithere) 658 { 659 ULONGEST n = 0; 660 ULONGEST prevn = 0; 661 ULONGEST un; 662 663 int i = 0; 664 int c; 665 int base = input_radix; 666 int unsigned_p = 0; 667 int long_p = 0; 668 669 /* We have found a "L" or "U" suffix. */ 670 int found_suffix = 0; 671 672 ULONGEST high_bit; 673 struct type *signed_type; 674 struct type *unsigned_type; 675 676 if (parsed_float) 677 { 678 char *s, *sp; 679 680 /* Strip out all embedded '_' before passing to parse_float. */ 681 s = (char *) alloca (len + 1); 682 sp = s; 683 while (len-- > 0) 684 { 685 if (*p != '_') 686 *sp++ = *p; 687 p++; 688 } 689 *sp = '\0'; 690 len = strlen (s); 691 692 /* Check suffix for `i' , `fi' or `li' (idouble, ifloat or ireal). */ 693 if (len >= 1 && tolower (s[len - 1]) == 'i') 694 { 695 if (len >= 2 && tolower (s[len - 2]) == 'f') 696 { 697 putithere->typed_val_float.type 698 = parse_d_type (ps)->builtin_ifloat; 699 len -= 2; 700 } 701 else if (len >= 2 && tolower (s[len - 2]) == 'l') 702 { 703 putithere->typed_val_float.type 704 = parse_d_type (ps)->builtin_ireal; 705 len -= 2; 706 } 707 else 708 { 709 putithere->typed_val_float.type 710 = parse_d_type (ps)->builtin_idouble; 711 len -= 1; 712 } 713 } 714 /* Check suffix for `f' or `l'' (float or real). */ 715 else if (len >= 1 && tolower (s[len - 1]) == 'f') 716 { 717 putithere->typed_val_float.type 718 = parse_d_type (ps)->builtin_float; 719 len -= 1; 720 } 721 else if (len >= 1 && tolower (s[len - 1]) == 'l') 722 { 723 putithere->typed_val_float.type 724 = parse_d_type (ps)->builtin_real; 725 len -= 1; 726 } 727 /* Default type if no suffix. */ 728 else 729 { 730 putithere->typed_val_float.type 731 = parse_d_type (ps)->builtin_double; 732 } 733 734 if (!parse_float (s, len, 735 putithere->typed_val_float.type, 736 putithere->typed_val_float.val)) 737 return ERROR; 738 739 return FLOAT_LITERAL; 740 } 741 742 /* Handle base-switching prefixes 0x, 0b, 0 */ 743 if (p[0] == '0') 744 switch (p[1]) 745 { 746 case 'x': 747 case 'X': 748 if (len >= 3) 749 { 750 p += 2; 751 base = 16; 752 len -= 2; 753 } 754 break; 755 756 case 'b': 757 case 'B': 758 if (len >= 3) 759 { 760 p += 2; 761 base = 2; 762 len -= 2; 763 } 764 break; 765 766 default: 767 base = 8; 768 break; 769 } 770 771 while (len-- > 0) 772 { 773 c = *p++; 774 if (c == '_') 775 continue; /* Ignore embedded '_'. */ 776 if (c >= 'A' && c <= 'Z') 777 c += 'a' - 'A'; 778 if (c != 'l' && c != 'u') 779 n *= base; 780 if (c >= '0' && c <= '9') 781 { 782 if (found_suffix) 783 return ERROR; 784 n += i = c - '0'; 785 } 786 else 787 { 788 if (base > 10 && c >= 'a' && c <= 'f') 789 { 790 if (found_suffix) 791 return ERROR; 792 n += i = c - 'a' + 10; 793 } 794 else if (c == 'l' && long_p == 0) 795 { 796 long_p = 1; 797 found_suffix = 1; 798 } 799 else if (c == 'u' && unsigned_p == 0) 800 { 801 unsigned_p = 1; 802 found_suffix = 1; 803 } 804 else 805 return ERROR; /* Char not a digit */ 806 } 807 if (i >= base) 808 return ERROR; /* Invalid digit in this base. */ 809 /* Portably test for integer overflow. */ 810 if (c != 'l' && c != 'u') 811 { 812 ULONGEST n2 = prevn * base; 813 if ((n2 / base != prevn) || (n2 + i < prevn)) 814 error (_("Numeric constant too large.")); 815 } 816 prevn = n; 817 } 818 819 /* An integer constant is an int or a long. An L suffix forces it to 820 be long, and a U suffix forces it to be unsigned. To figure out 821 whether it fits, we shift it right and see whether anything remains. 822 Note that we can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or 823 more in one operation, because many compilers will warn about such a 824 shift (which always produces a zero result). To deal with the case 825 where it is we just always shift the value more than once, with fewer 826 bits each time. */ 827 un = (ULONGEST) n >> 2; 828 if (long_p == 0 && (un >> 30) == 0) 829 { 830 high_bit = ((ULONGEST) 1) << 31; 831 signed_type = parse_d_type (ps)->builtin_int; 832 /* For decimal notation, keep the sign of the worked out type. */ 833 if (base == 10 && !unsigned_p) 834 unsigned_type = parse_d_type (ps)->builtin_long; 835 else 836 unsigned_type = parse_d_type (ps)->builtin_uint; 837 } 838 else 839 { 840 int shift; 841 if (sizeof (ULONGEST) * HOST_CHAR_BIT < 64) 842 /* A long long does not fit in a LONGEST. */ 843 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1); 844 else 845 shift = 63; 846 high_bit = (ULONGEST) 1 << shift; 847 signed_type = parse_d_type (ps)->builtin_long; 848 unsigned_type = parse_d_type (ps)->builtin_ulong; 849 } 850 851 putithere->typed_val_int.val = n; 852 853 /* If the high bit of the worked out type is set then this number 854 has to be unsigned_type. */ 855 if (unsigned_p || (n & high_bit)) 856 putithere->typed_val_int.type = unsigned_type; 857 else 858 putithere->typed_val_int.type = signed_type; 859 860 return INTEGER_LITERAL; 861 } 862 863 /* Temporary obstack used for holding strings. */ 864 static struct obstack tempbuf; 865 static int tempbuf_init; 866 867 /* Parse a string or character literal from TOKPTR. The string or 868 character may be wide or unicode. *OUTPTR is set to just after the 869 end of the literal in the input string. The resulting token is 870 stored in VALUE. This returns a token value, either STRING or 871 CHAR, depending on what was parsed. *HOST_CHARS is set to the 872 number of host characters in the literal. */ 873 874 static int 875 parse_string_or_char (const char *tokptr, const char **outptr, 876 struct typed_stoken *value, int *host_chars) 877 { 878 int quote; 879 880 /* Build the gdb internal form of the input string in tempbuf. Note 881 that the buffer is null byte terminated *only* for the 882 convenience of debugging gdb itself and printing the buffer 883 contents when the buffer contains no embedded nulls. Gdb does 884 not depend upon the buffer being null byte terminated, it uses 885 the length string instead. This allows gdb to handle C strings 886 (as well as strings in other languages) with embedded null 887 bytes */ 888 889 if (!tempbuf_init) 890 tempbuf_init = 1; 891 else 892 obstack_free (&tempbuf, NULL); 893 obstack_init (&tempbuf); 894 895 /* Skip the quote. */ 896 quote = *tokptr; 897 ++tokptr; 898 899 *host_chars = 0; 900 901 while (*tokptr) 902 { 903 char c = *tokptr; 904 if (c == '\\') 905 { 906 ++tokptr; 907 *host_chars += c_parse_escape (&tokptr, &tempbuf); 908 } 909 else if (c == quote) 910 break; 911 else 912 { 913 obstack_1grow (&tempbuf, c); 914 ++tokptr; 915 /* FIXME: this does the wrong thing with multi-byte host 916 characters. We could use mbrlen here, but that would 917 make "set host-charset" a bit less useful. */ 918 ++*host_chars; 919 } 920 } 921 922 if (*tokptr != quote) 923 { 924 if (quote == '"' || quote == '`') 925 error (_("Unterminated string in expression.")); 926 else 927 error (_("Unmatched single quote.")); 928 } 929 ++tokptr; 930 931 /* FIXME: should instead use own language string_type enum 932 and handle D-specific string suffixes here. */ 933 if (quote == '\'') 934 value->type = C_CHAR; 935 else 936 value->type = C_STRING; 937 938 value->ptr = (char *) obstack_base (&tempbuf); 939 value->length = obstack_object_size (&tempbuf); 940 941 *outptr = tokptr; 942 943 return quote == '\'' ? CHARACTER_LITERAL : STRING_LITERAL; 944 } 945 946 struct token 947 { 948 const char *oper; 949 int token; 950 enum exp_opcode opcode; 951 }; 952 953 static const struct token tokentab3[] = 954 { 955 {"^^=", ASSIGN_MODIFY, BINOP_EXP}, 956 {"<<=", ASSIGN_MODIFY, BINOP_LSH}, 957 {">>=", ASSIGN_MODIFY, BINOP_RSH}, 958 }; 959 960 static const struct token tokentab2[] = 961 { 962 {"+=", ASSIGN_MODIFY, BINOP_ADD}, 963 {"-=", ASSIGN_MODIFY, BINOP_SUB}, 964 {"*=", ASSIGN_MODIFY, BINOP_MUL}, 965 {"/=", ASSIGN_MODIFY, BINOP_DIV}, 966 {"%=", ASSIGN_MODIFY, BINOP_REM}, 967 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR}, 968 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, 969 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, 970 {"++", INCREMENT, BINOP_END}, 971 {"--", DECREMENT, BINOP_END}, 972 {"&&", ANDAND, BINOP_END}, 973 {"||", OROR, BINOP_END}, 974 {"^^", HATHAT, BINOP_END}, 975 {"<<", LSH, BINOP_END}, 976 {">>", RSH, BINOP_END}, 977 {"==", EQUAL, BINOP_END}, 978 {"!=", NOTEQUAL, BINOP_END}, 979 {"<=", LEQ, BINOP_END}, 980 {">=", GEQ, BINOP_END}, 981 {"..", DOTDOT, BINOP_END}, 982 }; 983 984 /* Identifier-like tokens. */ 985 static const struct token ident_tokens[] = 986 { 987 {"is", IDENTITY, BINOP_END}, 988 {"!is", NOTIDENTITY, BINOP_END}, 989 990 {"cast", CAST_KEYWORD, OP_NULL}, 991 {"const", CONST_KEYWORD, OP_NULL}, 992 {"immutable", IMMUTABLE_KEYWORD, OP_NULL}, 993 {"shared", SHARED_KEYWORD, OP_NULL}, 994 {"super", SUPER_KEYWORD, OP_NULL}, 995 996 {"null", NULL_KEYWORD, OP_NULL}, 997 {"true", TRUE_KEYWORD, OP_NULL}, 998 {"false", FALSE_KEYWORD, OP_NULL}, 999 1000 {"init", INIT_KEYWORD, OP_NULL}, 1001 {"sizeof", SIZEOF_KEYWORD, OP_NULL}, 1002 {"typeof", TYPEOF_KEYWORD, OP_NULL}, 1003 {"typeid", TYPEID_KEYWORD, OP_NULL}, 1004 1005 {"delegate", DELEGATE_KEYWORD, OP_NULL}, 1006 {"function", FUNCTION_KEYWORD, OP_NULL}, 1007 {"struct", STRUCT_KEYWORD, OP_NULL}, 1008 {"union", UNION_KEYWORD, OP_NULL}, 1009 {"class", CLASS_KEYWORD, OP_NULL}, 1010 {"interface", INTERFACE_KEYWORD, OP_NULL}, 1011 {"enum", ENUM_KEYWORD, OP_NULL}, 1012 {"template", TEMPLATE_KEYWORD, OP_NULL}, 1013 }; 1014 1015 /* This is set if a NAME token appeared at the very end of the input 1016 string, with no whitespace separating the name from the EOF. This 1017 is used only when parsing to do field name completion. */ 1018 static int saw_name_at_eof; 1019 1020 /* This is set if the previously-returned token was a structure operator. 1021 This is used only when parsing to do field name completion. */ 1022 static int last_was_structop; 1023 1024 /* Read one token, getting characters through lexptr. */ 1025 1026 static int 1027 lex_one_token (struct parser_state *par_state) 1028 { 1029 int c; 1030 int namelen; 1031 unsigned int i; 1032 const char *tokstart; 1033 int saw_structop = last_was_structop; 1034 char *copy; 1035 1036 last_was_structop = 0; 1037 1038 retry: 1039 1040 prev_lexptr = lexptr; 1041 1042 tokstart = lexptr; 1043 /* See if it is a special token of length 3. */ 1044 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) 1045 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0) 1046 { 1047 lexptr += 3; 1048 yylval.opcode = tokentab3[i].opcode; 1049 return tokentab3[i].token; 1050 } 1051 1052 /* See if it is a special token of length 2. */ 1053 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) 1054 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0) 1055 { 1056 lexptr += 2; 1057 yylval.opcode = tokentab2[i].opcode; 1058 return tokentab2[i].token; 1059 } 1060 1061 switch (c = *tokstart) 1062 { 1063 case 0: 1064 /* If we're parsing for field name completion, and the previous 1065 token allows such completion, return a COMPLETE token. 1066 Otherwise, we were already scanning the original text, and 1067 we're really done. */ 1068 if (saw_name_at_eof) 1069 { 1070 saw_name_at_eof = 0; 1071 return COMPLETE; 1072 } 1073 else if (saw_structop) 1074 return COMPLETE; 1075 else 1076 return 0; 1077 1078 case ' ': 1079 case '\t': 1080 case '\n': 1081 lexptr++; 1082 goto retry; 1083 1084 case '[': 1085 case '(': 1086 paren_depth++; 1087 lexptr++; 1088 return c; 1089 1090 case ']': 1091 case ')': 1092 if (paren_depth == 0) 1093 return 0; 1094 paren_depth--; 1095 lexptr++; 1096 return c; 1097 1098 case ',': 1099 if (comma_terminates && paren_depth == 0) 1100 return 0; 1101 lexptr++; 1102 return c; 1103 1104 case '.': 1105 /* Might be a floating point number. */ 1106 if (lexptr[1] < '0' || lexptr[1] > '9') 1107 { 1108 if (parse_completion) 1109 last_was_structop = 1; 1110 goto symbol; /* Nope, must be a symbol. */ 1111 } 1112 /* FALL THRU. */ 1113 1114 case '0': 1115 case '1': 1116 case '2': 1117 case '3': 1118 case '4': 1119 case '5': 1120 case '6': 1121 case '7': 1122 case '8': 1123 case '9': 1124 { 1125 /* It's a number. */ 1126 int got_dot = 0, got_e = 0, toktype; 1127 const char *p = tokstart; 1128 int hex = input_radix > 10; 1129 1130 if (c == '0' && (p[1] == 'x' || p[1] == 'X')) 1131 { 1132 p += 2; 1133 hex = 1; 1134 } 1135 1136 for (;; ++p) 1137 { 1138 /* Hex exponents start with 'p', because 'e' is a valid hex 1139 digit and thus does not indicate a floating point number 1140 when the radix is hex. */ 1141 if ((!hex && !got_e && tolower (p[0]) == 'e') 1142 || (hex && !got_e && tolower (p[0] == 'p'))) 1143 got_dot = got_e = 1; 1144 /* A '.' always indicates a decimal floating point number 1145 regardless of the radix. If we have a '..' then its the 1146 end of the number and the beginning of a slice. */ 1147 else if (!got_dot && (p[0] == '.' && p[1] != '.')) 1148 got_dot = 1; 1149 /* This is the sign of the exponent, not the end of the number. */ 1150 else if (got_e && (tolower (p[-1]) == 'e' || tolower (p[-1]) == 'p') 1151 && (*p == '-' || *p == '+')) 1152 continue; 1153 /* We will take any letters or digits, ignoring any embedded '_'. 1154 parse_number will complain if past the radix, or if L or U are 1155 not final. */ 1156 else if ((*p < '0' || *p > '9') && (*p != '_') 1157 && ((*p < 'a' || *p > 'z') && (*p < 'A' || *p > 'Z'))) 1158 break; 1159 } 1160 1161 toktype = parse_number (par_state, tokstart, p - tokstart, 1162 got_dot|got_e, &yylval); 1163 if (toktype == ERROR) 1164 { 1165 char *err_copy = (char *) alloca (p - tokstart + 1); 1166 1167 memcpy (err_copy, tokstart, p - tokstart); 1168 err_copy[p - tokstart] = 0; 1169 error (_("Invalid number \"%s\"."), err_copy); 1170 } 1171 lexptr = p; 1172 return toktype; 1173 } 1174 1175 case '@': 1176 { 1177 const char *p = &tokstart[1]; 1178 size_t len = strlen ("entry"); 1179 1180 while (isspace (*p)) 1181 p++; 1182 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len]) 1183 && p[len] != '_') 1184 { 1185 lexptr = &p[len]; 1186 return ENTRY; 1187 } 1188 } 1189 /* FALLTHRU */ 1190 case '+': 1191 case '-': 1192 case '*': 1193 case '/': 1194 case '%': 1195 case '|': 1196 case '&': 1197 case '^': 1198 case '~': 1199 case '!': 1200 case '<': 1201 case '>': 1202 case '?': 1203 case ':': 1204 case '=': 1205 case '{': 1206 case '}': 1207 symbol: 1208 lexptr++; 1209 return c; 1210 1211 case '\'': 1212 case '"': 1213 case '`': 1214 { 1215 int host_len; 1216 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval, 1217 &host_len); 1218 if (result == CHARACTER_LITERAL) 1219 { 1220 if (host_len == 0) 1221 error (_("Empty character constant.")); 1222 else if (host_len > 2 && c == '\'') 1223 { 1224 ++tokstart; 1225 namelen = lexptr - tokstart - 1; 1226 goto tryname; 1227 } 1228 else if (host_len > 1) 1229 error (_("Invalid character constant.")); 1230 } 1231 return result; 1232 } 1233 } 1234 1235 if (!(c == '_' || c == '$' 1236 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 1237 /* We must have come across a bad character (e.g. ';'). */ 1238 error (_("Invalid character '%c' in expression"), c); 1239 1240 /* It's a name. See how long it is. */ 1241 namelen = 0; 1242 for (c = tokstart[namelen]; 1243 (c == '_' || c == '$' || (c >= '0' && c <= '9') 1244 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));) 1245 c = tokstart[++namelen]; 1246 1247 /* The token "if" terminates the expression and is NOT 1248 removed from the input stream. */ 1249 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') 1250 return 0; 1251 1252 /* For the same reason (breakpoint conditions), "thread N" 1253 terminates the expression. "thread" could be an identifier, but 1254 an identifier is never followed by a number without intervening 1255 punctuation. "task" is similar. Handle abbreviations of these, 1256 similarly to breakpoint.c:find_condition_and_thread. */ 1257 if (namelen >= 1 1258 && (strncmp (tokstart, "thread", namelen) == 0 1259 || strncmp (tokstart, "task", namelen) == 0) 1260 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')) 1261 { 1262 const char *p = tokstart + namelen + 1; 1263 1264 while (*p == ' ' || *p == '\t') 1265 p++; 1266 if (*p >= '0' && *p <= '9') 1267 return 0; 1268 } 1269 1270 lexptr += namelen; 1271 1272 tryname: 1273 1274 yylval.sval.ptr = tokstart; 1275 yylval.sval.length = namelen; 1276 1277 /* Catch specific keywords. */ 1278 copy = copy_name (yylval.sval); 1279 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++) 1280 if (strcmp (copy, ident_tokens[i].oper) == 0) 1281 { 1282 /* It is ok to always set this, even though we don't always 1283 strictly need to. */ 1284 yylval.opcode = ident_tokens[i].opcode; 1285 return ident_tokens[i].token; 1286 } 1287 1288 if (*tokstart == '$') 1289 return DOLLAR_VARIABLE; 1290 1291 yylval.tsym.type 1292 = language_lookup_primitive_type (parse_language (par_state), 1293 parse_gdbarch (par_state), copy); 1294 if (yylval.tsym.type != NULL) 1295 return TYPENAME; 1296 1297 /* Input names that aren't symbols but ARE valid hex numbers, 1298 when the input radix permits them, can be names or numbers 1299 depending on the parse. Note we support radixes > 16 here. */ 1300 if ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) 1301 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)) 1302 { 1303 YYSTYPE newlval; /* Its value is ignored. */ 1304 int hextype = parse_number (par_state, tokstart, namelen, 0, &newlval); 1305 if (hextype == INTEGER_LITERAL) 1306 return NAME_OR_INT; 1307 } 1308 1309 if (parse_completion && *lexptr == '\0') 1310 saw_name_at_eof = 1; 1311 1312 return IDENTIFIER; 1313 } 1314 1315 /* An object of this type is pushed on a FIFO by the "outer" lexer. */ 1316 struct token_and_value 1317 { 1318 int token; 1319 YYSTYPE value; 1320 }; 1321 1322 1323 /* A FIFO of tokens that have been read but not yet returned to the 1324 parser. */ 1325 static std::vector<token_and_value> token_fifo; 1326 1327 /* Non-zero if the lexer should return tokens from the FIFO. */ 1328 static int popping; 1329 1330 /* Temporary storage for yylex; this holds symbol names as they are 1331 built up. */ 1332 static auto_obstack name_obstack; 1333 1334 /* Classify an IDENTIFIER token. The contents of the token are in `yylval'. 1335 Updates yylval and returns the new token type. BLOCK is the block 1336 in which lookups start; this can be NULL to mean the global scope. */ 1337 1338 static int 1339 classify_name (struct parser_state *par_state, const struct block *block) 1340 { 1341 struct block_symbol sym; 1342 char *copy; 1343 struct field_of_this_result is_a_field_of_this; 1344 1345 copy = copy_name (yylval.sval); 1346 1347 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this); 1348 if (sym.symbol && SYMBOL_CLASS (sym.symbol) == LOC_TYPEDEF) 1349 { 1350 yylval.tsym.type = SYMBOL_TYPE (sym.symbol); 1351 return TYPENAME; 1352 } 1353 else if (sym.symbol == NULL) 1354 { 1355 /* Look-up first for a module name, then a type. */ 1356 sym = lookup_symbol (copy, block, MODULE_DOMAIN, NULL); 1357 if (sym.symbol == NULL) 1358 sym = lookup_symbol (copy, block, STRUCT_DOMAIN, NULL); 1359 1360 if (sym.symbol != NULL) 1361 { 1362 yylval.tsym.type = SYMBOL_TYPE (sym.symbol); 1363 return TYPENAME; 1364 } 1365 1366 return UNKNOWN_NAME; 1367 } 1368 1369 return IDENTIFIER; 1370 } 1371 1372 /* Like classify_name, but used by the inner loop of the lexer, when a 1373 name might have already been seen. CONTEXT is the context type, or 1374 NULL if this is the first component of a name. */ 1375 1376 static int 1377 classify_inner_name (struct parser_state *par_state, 1378 const struct block *block, struct type *context) 1379 { 1380 struct type *type; 1381 char *copy; 1382 1383 if (context == NULL) 1384 return classify_name (par_state, block); 1385 1386 type = check_typedef (context); 1387 if (!type_aggregate_p (type)) 1388 return ERROR; 1389 1390 copy = copy_name (yylval.ssym.stoken); 1391 yylval.ssym.sym = d_lookup_nested_symbol (type, copy, block); 1392 1393 if (yylval.ssym.sym.symbol == NULL) 1394 return ERROR; 1395 1396 if (SYMBOL_CLASS (yylval.ssym.sym.symbol) == LOC_TYPEDEF) 1397 { 1398 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol); 1399 return TYPENAME; 1400 } 1401 1402 return IDENTIFIER; 1403 } 1404 1405 /* The outer level of a two-level lexer. This calls the inner lexer 1406 to return tokens. It then either returns these tokens, or 1407 aggregates them into a larger token. This lets us work around a 1408 problem in our parsing approach, where the parser could not 1409 distinguish between qualified names and qualified types at the 1410 right point. */ 1411 1412 static int 1413 yylex (void) 1414 { 1415 token_and_value current; 1416 int last_was_dot; 1417 struct type *context_type = NULL; 1418 int last_to_examine, next_to_examine, checkpoint; 1419 const struct block *search_block; 1420 1421 if (popping && !token_fifo.empty ()) 1422 goto do_pop; 1423 popping = 0; 1424 1425 /* Read the first token and decide what to do. */ 1426 current.token = lex_one_token (pstate); 1427 if (current.token != IDENTIFIER && current.token != '.') 1428 return current.token; 1429 1430 /* Read any sequence of alternating "." and identifier tokens into 1431 the token FIFO. */ 1432 current.value = yylval; 1433 token_fifo.push_back (current); 1434 last_was_dot = current.token == '.'; 1435 1436 while (1) 1437 { 1438 current.token = lex_one_token (pstate); 1439 current.value = yylval; 1440 token_fifo.push_back (current); 1441 1442 if ((last_was_dot && current.token != IDENTIFIER) 1443 || (!last_was_dot && current.token != '.')) 1444 break; 1445 1446 last_was_dot = !last_was_dot; 1447 } 1448 popping = 1; 1449 1450 /* We always read one extra token, so compute the number of tokens 1451 to examine accordingly. */ 1452 last_to_examine = token_fifo.size () - 2; 1453 next_to_examine = 0; 1454 1455 current = token_fifo[next_to_examine]; 1456 ++next_to_examine; 1457 1458 /* If we are not dealing with a typename, now is the time to find out. */ 1459 if (current.token == IDENTIFIER) 1460 { 1461 yylval = current.value; 1462 current.token = classify_name (pstate, expression_context_block); 1463 current.value = yylval; 1464 } 1465 1466 /* If the IDENTIFIER is not known, it could be a package symbol, 1467 first try building up a name until we find the qualified module. */ 1468 if (current.token == UNKNOWN_NAME) 1469 { 1470 name_obstack.clear (); 1471 obstack_grow (&name_obstack, current.value.sval.ptr, 1472 current.value.sval.length); 1473 1474 last_was_dot = 0; 1475 1476 while (next_to_examine <= last_to_examine) 1477 { 1478 token_and_value next; 1479 1480 next = token_fifo[next_to_examine]; 1481 ++next_to_examine; 1482 1483 if (next.token == IDENTIFIER && last_was_dot) 1484 { 1485 /* Update the partial name we are constructing. */ 1486 obstack_grow_str (&name_obstack, "."); 1487 obstack_grow (&name_obstack, next.value.sval.ptr, 1488 next.value.sval.length); 1489 1490 yylval.sval.ptr = (char *) obstack_base (&name_obstack); 1491 yylval.sval.length = obstack_object_size (&name_obstack); 1492 1493 current.token = classify_name (pstate, expression_context_block); 1494 current.value = yylval; 1495 1496 /* We keep going until we find a TYPENAME. */ 1497 if (current.token == TYPENAME) 1498 { 1499 /* Install it as the first token in the FIFO. */ 1500 token_fifo[0] = current; 1501 token_fifo.erase (token_fifo.begin () + 1, 1502 token_fifo.begin () + next_to_examine); 1503 break; 1504 } 1505 } 1506 else if (next.token == '.' && !last_was_dot) 1507 last_was_dot = 1; 1508 else 1509 { 1510 /* We've reached the end of the name. */ 1511 break; 1512 } 1513 } 1514 1515 /* Reset our current token back to the start, if we found nothing 1516 this means that we will just jump to do pop. */ 1517 current = token_fifo[0]; 1518 next_to_examine = 1; 1519 } 1520 if (current.token != TYPENAME && current.token != '.') 1521 goto do_pop; 1522 1523 name_obstack.clear (); 1524 checkpoint = 0; 1525 if (current.token == '.') 1526 search_block = NULL; 1527 else 1528 { 1529 gdb_assert (current.token == TYPENAME); 1530 search_block = expression_context_block; 1531 obstack_grow (&name_obstack, current.value.sval.ptr, 1532 current.value.sval.length); 1533 context_type = current.value.tsym.type; 1534 checkpoint = 1; 1535 } 1536 1537 last_was_dot = current.token == '.'; 1538 1539 while (next_to_examine <= last_to_examine) 1540 { 1541 token_and_value next; 1542 1543 next = token_fifo[next_to_examine]; 1544 ++next_to_examine; 1545 1546 if (next.token == IDENTIFIER && last_was_dot) 1547 { 1548 int classification; 1549 1550 yylval = next.value; 1551 classification = classify_inner_name (pstate, search_block, 1552 context_type); 1553 /* We keep going until we either run out of names, or until 1554 we have a qualified name which is not a type. */ 1555 if (classification != TYPENAME && classification != IDENTIFIER) 1556 break; 1557 1558 /* Accept up to this token. */ 1559 checkpoint = next_to_examine; 1560 1561 /* Update the partial name we are constructing. */ 1562 if (context_type != NULL) 1563 { 1564 /* We don't want to put a leading "." into the name. */ 1565 obstack_grow_str (&name_obstack, "."); 1566 } 1567 obstack_grow (&name_obstack, next.value.sval.ptr, 1568 next.value.sval.length); 1569 1570 yylval.sval.ptr = (char *) obstack_base (&name_obstack); 1571 yylval.sval.length = obstack_object_size (&name_obstack); 1572 current.value = yylval; 1573 current.token = classification; 1574 1575 last_was_dot = 0; 1576 1577 if (classification == IDENTIFIER) 1578 break; 1579 1580 context_type = yylval.tsym.type; 1581 } 1582 else if (next.token == '.' && !last_was_dot) 1583 last_was_dot = 1; 1584 else 1585 { 1586 /* We've reached the end of the name. */ 1587 break; 1588 } 1589 } 1590 1591 /* If we have a replacement token, install it as the first token in 1592 the FIFO, and delete the other constituent tokens. */ 1593 if (checkpoint > 0) 1594 { 1595 token_fifo[0] = current; 1596 if (checkpoint > 1) 1597 token_fifo.erase (token_fifo.begin () + 1, 1598 token_fifo.begin () + checkpoint); 1599 } 1600 1601 do_pop: 1602 current = token_fifo[0]; 1603 token_fifo.erase (token_fifo.begin ()); 1604 yylval = current.value; 1605 return current.token; 1606 } 1607 1608 int 1609 d_parse (struct parser_state *par_state) 1610 { 1611 /* Setting up the parser state. */ 1612 scoped_restore pstate_restore = make_scoped_restore (&pstate); 1613 gdb_assert (par_state != NULL); 1614 pstate = par_state; 1615 1616 scoped_restore restore_yydebug = make_scoped_restore (&yydebug, 1617 parser_debug); 1618 1619 /* Initialize some state used by the lexer. */ 1620 last_was_structop = 0; 1621 saw_name_at_eof = 0; 1622 1623 token_fifo.clear (); 1624 popping = 0; 1625 name_obstack.clear (); 1626 1627 return yyparse (); 1628 } 1629 1630 static void 1631 yyerror (const char *msg) 1632 { 1633 if (prev_lexptr) 1634 lexptr = prev_lexptr; 1635 1636 error (_("A %s in expression, near `%s'."), msg, lexptr); 1637 } 1638 1639