1 /* YACC parser for Go expressions, for GDB. 2 3 Copyright (C) 2012-2013 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, p-exp.y. */ 21 22 /* Parse a Go 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 /* Known bugs or limitations: 40 41 - Unicode 42 - &^ 43 - '_' (blank identifier) 44 - automatic deref of pointers 45 - method expressions 46 - interfaces, channels, etc. 47 48 And lots of other things. 49 I'm sure there's some cleanup to do. 50 */ 51 52 %{ 53 54 #include "defs.h" 55 #include "gdb_string.h" 56 #include <ctype.h> 57 #include "expression.h" 58 #include "value.h" 59 #include "parser-defs.h" 60 #include "language.h" 61 #include "c-lang.h" 62 #include "go-lang.h" 63 #include "bfd.h" /* Required by objfiles.h. */ 64 #include "symfile.h" /* Required by objfiles.h. */ 65 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 66 #include "charset.h" 67 #include "block.h" 68 69 #define parse_type builtin_type (parse_gdbarch) 70 71 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 72 as well as gratuitiously global symbol names, so we can have multiple 73 yacc generated parsers in gdb. Note that these are only the variables 74 produced by yacc. If other parser generators (bison, byacc, etc) produce 75 additional global names that conflict at link time, then those parser 76 generators need to be fixed instead of adding those names to this list. */ 77 78 #define yymaxdepth go_maxdepth 79 #define yyparse go_parse_internal 80 #define yylex go_lex 81 #define yyerror go_error 82 #define yylval go_lval 83 #define yychar go_char 84 #define yydebug go_debug 85 #define yypact go_pact 86 #define yyr1 go_r1 87 #define yyr2 go_r2 88 #define yydef go_def 89 #define yychk go_chk 90 #define yypgo go_pgo 91 #define yyact go_act 92 #define yyexca go_exca 93 #define yyerrflag go_errflag 94 #define yynerrs go_nerrs 95 #define yyps go_ps 96 #define yypv go_pv 97 #define yys go_s 98 #define yy_yys go_yys 99 #define yystate go_state 100 #define yytmp go_tmp 101 #define yyv go_v 102 #define yy_yyv go_yyv 103 #define yyval go_val 104 #define yylloc go_lloc 105 #define yyreds go_reds /* With YYDEBUG defined */ 106 #define yytoks go_toks /* With YYDEBUG defined */ 107 #define yyname go_name /* With YYDEBUG defined */ 108 #define yyrule go_rule /* With YYDEBUG defined */ 109 #define yylhs go_yylhs 110 #define yylen go_yylen 111 #define yydefred go_yydefred 112 #define yydgoto go_yydgoto 113 #define yysindex go_yysindex 114 #define yyrindex go_yyrindex 115 #define yygindex go_yygindex 116 #define yytable go_yytable 117 #define yycheck go_yycheck 118 119 #ifndef YYDEBUG 120 #define YYDEBUG 1 /* Default to yydebug support */ 121 #endif 122 123 #define YYFPRINTF parser_fprintf 124 125 int yyparse (void); 126 127 static int yylex (void); 128 129 void yyerror (char *); 130 131 %} 132 133 /* Although the yacc "value" of an expression is not used, 134 since the result is stored in the structure being created, 135 other node types do have values. */ 136 137 %union 138 { 139 LONGEST lval; 140 struct { 141 LONGEST val; 142 struct type *type; 143 } typed_val_int; 144 struct { 145 DOUBLEST dval; 146 struct type *type; 147 } typed_val_float; 148 struct stoken sval; 149 struct symtoken ssym; 150 struct type *tval; 151 struct typed_stoken tsval; 152 struct ttype tsym; 153 int voidval; 154 enum exp_opcode opcode; 155 struct internalvar *ivar; 156 struct stoken_vector svec; 157 } 158 159 %{ 160 /* YYSTYPE gets defined by %union. */ 161 static int parse_number (char *, int, int, YYSTYPE *); 162 static int parse_go_float (struct gdbarch *gdbarch, const char *p, int len, 163 DOUBLEST *d, struct type **t); 164 %} 165 166 %type <voidval> exp exp1 type_exp start variable lcurly 167 %type <lval> rcurly 168 %type <tval> type 169 170 %token <typed_val_int> INT 171 %token <typed_val_float> FLOAT 172 173 /* Both NAME and TYPENAME tokens represent symbols in the input, 174 and both convey their data as strings. 175 But a TYPENAME is a string that happens to be defined as a type 176 or builtin type name (such as int or char) 177 and a NAME is any other symbol. 178 Contexts where this distinction is not important can use the 179 nonterminal "name", which matches either NAME or TYPENAME. */ 180 181 %token <tsval> RAW_STRING 182 %token <tsval> STRING 183 %token <tsval> CHAR 184 %token <ssym> NAME 185 %token <tsym> TYPENAME /* Not TYPE_NAME cus already taken. */ 186 %token <voidval> COMPLETE 187 /*%type <sval> name*/ 188 %type <svec> string_exp 189 %type <ssym> name_not_typename 190 191 /* A NAME_OR_INT is a symbol which is not known in the symbol table, 192 but which would parse as a valid number in the current input radix. 193 E.g. "c" when input_radix==16. Depending on the parse, it will be 194 turned into a name or into a number. */ 195 %token <ssym> NAME_OR_INT 196 197 %token <lval> TRUE_KEYWORD FALSE_KEYWORD 198 %token STRUCT_KEYWORD INTERFACE_KEYWORD TYPE_KEYWORD CHAN_KEYWORD 199 %token SIZEOF_KEYWORD 200 %token LEN_KEYWORD CAP_KEYWORD 201 %token NEW_KEYWORD 202 %token IOTA_KEYWORD NIL_KEYWORD 203 %token CONST_KEYWORD 204 %token DOTDOTDOT 205 %token ENTRY 206 %token ERROR 207 208 /* Special type cases. */ 209 %token BYTE_KEYWORD /* An alias of uint8. */ 210 211 %token <sval> DOLLAR_VARIABLE 212 213 %token <opcode> ASSIGN_MODIFY 214 215 %left ',' 216 %left ABOVE_COMMA 217 %right '=' ASSIGN_MODIFY 218 %right '?' 219 %left OROR 220 %left ANDAND 221 %left '|' 222 %left '^' 223 %left '&' 224 %left ANDNOT 225 %left EQUAL NOTEQUAL 226 %left '<' '>' LEQ GEQ 227 %left LSH RSH 228 %left '@' 229 %left '+' '-' 230 %left '*' '/' '%' 231 %right UNARY INCREMENT DECREMENT 232 %right LEFT_ARROW '.' '[' '(' 233 234 235 %% 236 237 start : exp1 238 | type_exp 239 ; 240 241 type_exp: type 242 { write_exp_elt_opcode(OP_TYPE); 243 write_exp_elt_type($1); 244 write_exp_elt_opcode(OP_TYPE); } 245 ; 246 247 /* Expressions, including the comma operator. */ 248 exp1 : exp 249 | exp1 ',' exp 250 { write_exp_elt_opcode (BINOP_COMMA); } 251 ; 252 253 /* Expressions, not including the comma operator. */ 254 exp : '*' exp %prec UNARY 255 { write_exp_elt_opcode (UNOP_IND); } 256 ; 257 258 exp : '&' exp %prec UNARY 259 { write_exp_elt_opcode (UNOP_ADDR); } 260 ; 261 262 exp : '-' exp %prec UNARY 263 { write_exp_elt_opcode (UNOP_NEG); } 264 ; 265 266 exp : '+' exp %prec UNARY 267 { write_exp_elt_opcode (UNOP_PLUS); } 268 ; 269 270 exp : '!' exp %prec UNARY 271 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } 272 ; 273 274 exp : '^' exp %prec UNARY 275 { write_exp_elt_opcode (UNOP_COMPLEMENT); } 276 ; 277 278 exp : exp INCREMENT %prec UNARY 279 { write_exp_elt_opcode (UNOP_POSTINCREMENT); } 280 ; 281 282 exp : exp DECREMENT %prec UNARY 283 { write_exp_elt_opcode (UNOP_POSTDECREMENT); } 284 ; 285 286 /* foo->bar is not in Go. May want as a gdb extension. Later. */ 287 288 exp : exp '.' name_not_typename 289 { write_exp_elt_opcode (STRUCTOP_STRUCT); 290 write_exp_string ($3.stoken); 291 write_exp_elt_opcode (STRUCTOP_STRUCT); } 292 ; 293 294 exp : exp '.' name_not_typename COMPLETE 295 { mark_struct_expression (); 296 write_exp_elt_opcode (STRUCTOP_STRUCT); 297 write_exp_string ($3.stoken); 298 write_exp_elt_opcode (STRUCTOP_STRUCT); } 299 ; 300 301 exp : exp '.' COMPLETE 302 { struct stoken s; 303 mark_struct_expression (); 304 write_exp_elt_opcode (STRUCTOP_STRUCT); 305 s.ptr = ""; 306 s.length = 0; 307 write_exp_string (s); 308 write_exp_elt_opcode (STRUCTOP_STRUCT); } 309 ; 310 311 exp : exp '[' exp1 ']' 312 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 313 ; 314 315 exp : exp '(' 316 /* This is to save the value of arglist_len 317 being accumulated by an outer function call. */ 318 { start_arglist (); } 319 arglist ')' %prec LEFT_ARROW 320 { write_exp_elt_opcode (OP_FUNCALL); 321 write_exp_elt_longcst ((LONGEST) end_arglist ()); 322 write_exp_elt_opcode (OP_FUNCALL); } 323 ; 324 325 lcurly : '{' 326 { start_arglist (); } 327 ; 328 329 arglist : 330 ; 331 332 arglist : exp 333 { arglist_len = 1; } 334 ; 335 336 arglist : arglist ',' exp %prec ABOVE_COMMA 337 { arglist_len++; } 338 ; 339 340 rcurly : '}' 341 { $$ = end_arglist () - 1; } 342 ; 343 344 exp : lcurly type rcurly exp %prec UNARY 345 { write_exp_elt_opcode (UNOP_MEMVAL); 346 write_exp_elt_type ($2); 347 write_exp_elt_opcode (UNOP_MEMVAL); } 348 ; 349 350 exp : type '(' exp ')' %prec UNARY 351 { write_exp_elt_opcode (UNOP_CAST); 352 write_exp_elt_type ($1); 353 write_exp_elt_opcode (UNOP_CAST); } 354 ; 355 356 exp : '(' exp1 ')' 357 { } 358 ; 359 360 /* Binary operators in order of decreasing precedence. */ 361 362 exp : exp '@' exp 363 { write_exp_elt_opcode (BINOP_REPEAT); } 364 ; 365 366 exp : exp '*' exp 367 { write_exp_elt_opcode (BINOP_MUL); } 368 ; 369 370 exp : exp '/' exp 371 { write_exp_elt_opcode (BINOP_DIV); } 372 ; 373 374 exp : exp '%' exp 375 { write_exp_elt_opcode (BINOP_REM); } 376 ; 377 378 exp : exp '+' exp 379 { write_exp_elt_opcode (BINOP_ADD); } 380 ; 381 382 exp : exp '-' exp 383 { write_exp_elt_opcode (BINOP_SUB); } 384 ; 385 386 exp : exp LSH exp 387 { write_exp_elt_opcode (BINOP_LSH); } 388 ; 389 390 exp : exp RSH exp 391 { write_exp_elt_opcode (BINOP_RSH); } 392 ; 393 394 exp : exp EQUAL exp 395 { write_exp_elt_opcode (BINOP_EQUAL); } 396 ; 397 398 exp : exp NOTEQUAL exp 399 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 400 ; 401 402 exp : exp LEQ exp 403 { write_exp_elt_opcode (BINOP_LEQ); } 404 ; 405 406 exp : exp GEQ exp 407 { write_exp_elt_opcode (BINOP_GEQ); } 408 ; 409 410 exp : exp '<' exp 411 { write_exp_elt_opcode (BINOP_LESS); } 412 ; 413 414 exp : exp '>' exp 415 { write_exp_elt_opcode (BINOP_GTR); } 416 ; 417 418 exp : exp '&' exp 419 { write_exp_elt_opcode (BINOP_BITWISE_AND); } 420 ; 421 422 exp : exp '^' exp 423 { write_exp_elt_opcode (BINOP_BITWISE_XOR); } 424 ; 425 426 exp : exp '|' exp 427 { write_exp_elt_opcode (BINOP_BITWISE_IOR); } 428 ; 429 430 exp : exp ANDAND exp 431 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 432 ; 433 434 exp : exp OROR exp 435 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 436 ; 437 438 exp : exp '?' exp ':' exp %prec '?' 439 { write_exp_elt_opcode (TERNOP_COND); } 440 ; 441 442 exp : exp '=' exp 443 { write_exp_elt_opcode (BINOP_ASSIGN); } 444 ; 445 446 exp : exp ASSIGN_MODIFY exp 447 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); 448 write_exp_elt_opcode ($2); 449 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } 450 ; 451 452 exp : INT 453 { write_exp_elt_opcode (OP_LONG); 454 write_exp_elt_type ($1.type); 455 write_exp_elt_longcst ((LONGEST)($1.val)); 456 write_exp_elt_opcode (OP_LONG); } 457 ; 458 459 exp : CHAR 460 { 461 struct stoken_vector vec; 462 vec.len = 1; 463 vec.tokens = &$1; 464 write_exp_string_vector ($1.type, &vec); 465 } 466 ; 467 468 exp : NAME_OR_INT 469 { YYSTYPE val; 470 parse_number ($1.stoken.ptr, $1.stoken.length, 471 0, &val); 472 write_exp_elt_opcode (OP_LONG); 473 write_exp_elt_type (val.typed_val_int.type); 474 write_exp_elt_longcst ((LONGEST) 475 val.typed_val_int.val); 476 write_exp_elt_opcode (OP_LONG); 477 } 478 ; 479 480 481 exp : FLOAT 482 { write_exp_elt_opcode (OP_DOUBLE); 483 write_exp_elt_type ($1.type); 484 write_exp_elt_dblcst ($1.dval); 485 write_exp_elt_opcode (OP_DOUBLE); } 486 ; 487 488 exp : variable 489 ; 490 491 exp : DOLLAR_VARIABLE 492 { 493 write_dollar_variable ($1); 494 } 495 ; 496 497 exp : SIZEOF_KEYWORD '(' type ')' %prec UNARY 498 { 499 /* TODO(dje): Go objects in structs. */ 500 write_exp_elt_opcode (OP_LONG); 501 /* TODO(dje): What's the right type here? */ 502 write_exp_elt_type (parse_type->builtin_unsigned_int); 503 CHECK_TYPEDEF ($3); 504 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3)); 505 write_exp_elt_opcode (OP_LONG); 506 } 507 ; 508 509 exp : SIZEOF_KEYWORD '(' exp ')' %prec UNARY 510 { 511 /* TODO(dje): Go objects in structs. */ 512 write_exp_elt_opcode (UNOP_SIZEOF); 513 } 514 515 string_exp: 516 STRING 517 { 518 /* We copy the string here, and not in the 519 lexer, to guarantee that we do not leak a 520 string. */ 521 /* Note that we NUL-terminate here, but just 522 for convenience. */ 523 struct typed_stoken *vec = XNEW (struct typed_stoken); 524 $$.len = 1; 525 $$.tokens = vec; 526 527 vec->type = $1.type; 528 vec->length = $1.length; 529 vec->ptr = malloc ($1.length + 1); 530 memcpy (vec->ptr, $1.ptr, $1.length + 1); 531 } 532 533 | string_exp '+' STRING 534 { 535 /* Note that we NUL-terminate here, but just 536 for convenience. */ 537 char *p; 538 ++$$.len; 539 $$.tokens = realloc ($$.tokens, 540 $$.len * sizeof (struct typed_stoken)); 541 542 p = malloc ($3.length + 1); 543 memcpy (p, $3.ptr, $3.length + 1); 544 545 $$.tokens[$$.len - 1].type = $3.type; 546 $$.tokens[$$.len - 1].length = $3.length; 547 $$.tokens[$$.len - 1].ptr = p; 548 } 549 ; 550 551 exp : string_exp %prec ABOVE_COMMA 552 { 553 int i; 554 555 write_exp_string_vector (0 /*always utf8*/, &$1); 556 for (i = 0; i < $1.len; ++i) 557 free ($1.tokens[i].ptr); 558 free ($1.tokens); 559 } 560 ; 561 562 exp : TRUE_KEYWORD 563 { write_exp_elt_opcode (OP_BOOL); 564 write_exp_elt_longcst ((LONGEST) $1); 565 write_exp_elt_opcode (OP_BOOL); } 566 ; 567 568 exp : FALSE_KEYWORD 569 { write_exp_elt_opcode (OP_BOOL); 570 write_exp_elt_longcst ((LONGEST) $1); 571 write_exp_elt_opcode (OP_BOOL); } 572 ; 573 574 variable: name_not_typename ENTRY 575 { struct symbol *sym = $1.sym; 576 577 if (sym == NULL 578 || !SYMBOL_IS_ARGUMENT (sym) 579 || !symbol_read_needs_frame (sym)) 580 error (_("@entry can be used only for function " 581 "parameters, not for \"%s\""), 582 copy_name ($1.stoken)); 583 584 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); 585 write_exp_elt_sym (sym); 586 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); 587 } 588 ; 589 590 variable: name_not_typename 591 { struct symbol *sym = $1.sym; 592 593 if (sym) 594 { 595 if (symbol_read_needs_frame (sym)) 596 { 597 if (innermost_block == 0 598 || contained_in (block_found, 599 innermost_block)) 600 innermost_block = block_found; 601 } 602 603 write_exp_elt_opcode (OP_VAR_VALUE); 604 /* We want to use the selected frame, not 605 another more inner frame which happens to 606 be in the same block. */ 607 write_exp_elt_block (NULL); 608 write_exp_elt_sym (sym); 609 write_exp_elt_opcode (OP_VAR_VALUE); 610 } 611 else if ($1.is_a_field_of_this) 612 { 613 /* TODO(dje): Can we get here? 614 E.g., via a mix of c++ and go? */ 615 gdb_assert_not_reached ("go with `this' field"); 616 } 617 else 618 { 619 struct minimal_symbol *msymbol; 620 char *arg = copy_name ($1.stoken); 621 622 msymbol = 623 lookup_minimal_symbol (arg, NULL, NULL); 624 if (msymbol != NULL) 625 write_exp_msymbol (msymbol); 626 else if (!have_full_symbols () 627 && !have_partial_symbols ()) 628 error (_("No symbol table is loaded. " 629 "Use the \"file\" command.")); 630 else 631 error (_("No symbol \"%s\" in current context."), 632 copy_name ($1.stoken)); 633 } 634 } 635 ; 636 637 /* TODO 638 method_exp: PACKAGENAME '.' name '.' name 639 { 640 } 641 ; 642 */ 643 644 type /* Implements (approximately): [*] type-specifier */ 645 : '*' type 646 { $$ = lookup_pointer_type ($2); } 647 | TYPENAME 648 { $$ = $1.type; } 649 /* 650 | STRUCT_KEYWORD name 651 { $$ = lookup_struct (copy_name ($2), 652 expression_context_block); } 653 */ 654 | BYTE_KEYWORD 655 { $$ = builtin_go_type (parse_gdbarch) 656 ->builtin_uint8; } 657 ; 658 659 /* TODO 660 name : NAME { $$ = $1.stoken; } 661 | TYPENAME { $$ = $1.stoken; } 662 | NAME_OR_INT { $$ = $1.stoken; } 663 ; 664 */ 665 666 name_not_typename 667 : NAME 668 /* These would be useful if name_not_typename was useful, but it is just 669 a fake for "variable", so these cause reduce/reduce conflicts because 670 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable, 671 =exp) or just an exp. If name_not_typename was ever used in an lvalue 672 context where only a name could occur, this might be useful. 673 | NAME_OR_INT 674 */ 675 ; 676 677 %% 678 679 /* Wrapper on parse_c_float to get the type right for Go. */ 680 681 static int 682 parse_go_float (struct gdbarch *gdbarch, const char *p, int len, 683 DOUBLEST *d, struct type **t) 684 { 685 int result = parse_c_float (gdbarch, p, len, d, t); 686 const struct builtin_type *builtin_types = builtin_type (gdbarch); 687 const struct builtin_go_type *builtin_go_types = builtin_go_type (gdbarch); 688 689 if (*t == builtin_types->builtin_float) 690 *t = builtin_go_types->builtin_float32; 691 else if (*t == builtin_types->builtin_double) 692 *t = builtin_go_types->builtin_float64; 693 694 return result; 695 } 696 697 /* Take care of parsing a number (anything that starts with a digit). 698 Set yylval and return the token type; update lexptr. 699 LEN is the number of characters in it. */ 700 701 /* FIXME: Needs some error checking for the float case. */ 702 /* FIXME(dje): IWBN to use c-exp.y's parse_number if we could. 703 That will require moving the guts into a function that we both call 704 as our YYSTYPE is different than c-exp.y's */ 705 706 static int 707 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) 708 { 709 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values 710 here, and we do kind of silly things like cast to unsigned. */ 711 LONGEST n = 0; 712 LONGEST prevn = 0; 713 ULONGEST un; 714 715 int i = 0; 716 int c; 717 int base = input_radix; 718 int unsigned_p = 0; 719 720 /* Number of "L" suffixes encountered. */ 721 int long_p = 0; 722 723 /* We have found a "L" or "U" suffix. */ 724 int found_suffix = 0; 725 726 ULONGEST high_bit; 727 struct type *signed_type; 728 struct type *unsigned_type; 729 730 if (parsed_float) 731 { 732 if (! parse_go_float (parse_gdbarch, p, len, 733 &putithere->typed_val_float.dval, 734 &putithere->typed_val_float.type)) 735 return ERROR; 736 return FLOAT; 737 } 738 739 /* Handle base-switching prefixes 0x, 0t, 0d, 0. */ 740 if (p[0] == '0') 741 switch (p[1]) 742 { 743 case 'x': 744 case 'X': 745 if (len >= 3) 746 { 747 p += 2; 748 base = 16; 749 len -= 2; 750 } 751 break; 752 753 case 'b': 754 case 'B': 755 if (len >= 3) 756 { 757 p += 2; 758 base = 2; 759 len -= 2; 760 } 761 break; 762 763 case 't': 764 case 'T': 765 case 'd': 766 case 'D': 767 if (len >= 3) 768 { 769 p += 2; 770 base = 10; 771 len -= 2; 772 } 773 break; 774 775 default: 776 base = 8; 777 break; 778 } 779 780 while (len-- > 0) 781 { 782 c = *p++; 783 if (c >= 'A' && c <= 'Z') 784 c += 'a' - 'A'; 785 if (c != 'l' && c != 'u') 786 n *= base; 787 if (c >= '0' && c <= '9') 788 { 789 if (found_suffix) 790 return ERROR; 791 n += i = c - '0'; 792 } 793 else 794 { 795 if (base > 10 && c >= 'a' && c <= 'f') 796 { 797 if (found_suffix) 798 return ERROR; 799 n += i = c - 'a' + 10; 800 } 801 else if (c == 'l') 802 { 803 ++long_p; 804 found_suffix = 1; 805 } 806 else if (c == 'u') 807 { 808 unsigned_p = 1; 809 found_suffix = 1; 810 } 811 else 812 return ERROR; /* Char not a digit */ 813 } 814 if (i >= base) 815 return ERROR; /* Invalid digit in this base. */ 816 817 /* Portably test for overflow (only works for nonzero values, so make 818 a second check for zero). FIXME: Can't we just make n and prevn 819 unsigned and avoid this? */ 820 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0) 821 unsigned_p = 1; /* Try something unsigned. */ 822 823 /* Portably test for unsigned overflow. 824 FIXME: This check is wrong; for example it doesn't find overflow 825 on 0x123456789 when LONGEST is 32 bits. */ 826 if (c != 'l' && c != 'u' && n != 0) 827 { 828 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n)) 829 error (_("Numeric constant too large.")); 830 } 831 prevn = n; 832 } 833 834 /* An integer constant is an int, a long, or a long long. An L 835 suffix forces it to be long; an LL suffix forces it to be long 836 long. If not forced to a larger size, it gets the first type of 837 the above that it fits in. To figure out whether it fits, we 838 shift it right and see whether anything remains. Note that we 839 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one 840 operation, because many compilers will warn about such a shift 841 (which always produces a zero result). Sometimes gdbarch_int_bit 842 or gdbarch_long_bit will be that big, sometimes not. To deal with 843 the case where it is we just always shift the value more than 844 once, with fewer bits each time. */ 845 846 un = (ULONGEST)n >> 2; 847 if (long_p == 0 848 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0) 849 { 850 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1); 851 852 /* A large decimal (not hex or octal) constant (between INT_MAX 853 and UINT_MAX) is a long or unsigned long, according to ANSI, 854 never an unsigned int, but this code treats it as unsigned 855 int. This probably should be fixed. GCC gives a warning on 856 such constants. */ 857 858 unsigned_type = parse_type->builtin_unsigned_int; 859 signed_type = parse_type->builtin_int; 860 } 861 else if (long_p <= 1 862 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0) 863 { 864 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1); 865 unsigned_type = parse_type->builtin_unsigned_long; 866 signed_type = parse_type->builtin_long; 867 } 868 else 869 { 870 int shift; 871 if (sizeof (ULONGEST) * HOST_CHAR_BIT 872 < gdbarch_long_long_bit (parse_gdbarch)) 873 /* A long long does not fit in a LONGEST. */ 874 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1); 875 else 876 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1); 877 high_bit = (ULONGEST) 1 << shift; 878 unsigned_type = parse_type->builtin_unsigned_long_long; 879 signed_type = parse_type->builtin_long_long; 880 } 881 882 putithere->typed_val_int.val = n; 883 884 /* If the high bit of the worked out type is set then this number 885 has to be unsigned. */ 886 887 if (unsigned_p || (n & high_bit)) 888 { 889 putithere->typed_val_int.type = unsigned_type; 890 } 891 else 892 { 893 putithere->typed_val_int.type = signed_type; 894 } 895 896 return INT; 897 } 898 899 /* Temporary obstack used for holding strings. */ 900 static struct obstack tempbuf; 901 static int tempbuf_init; 902 903 /* Parse a string or character literal from TOKPTR. The string or 904 character may be wide or unicode. *OUTPTR is set to just after the 905 end of the literal in the input string. The resulting token is 906 stored in VALUE. This returns a token value, either STRING or 907 CHAR, depending on what was parsed. *HOST_CHARS is set to the 908 number of host characters in the literal. */ 909 910 static int 911 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value, 912 int *host_chars) 913 { 914 int quote; 915 916 /* Build the gdb internal form of the input string in tempbuf. Note 917 that the buffer is null byte terminated *only* for the 918 convenience of debugging gdb itself and printing the buffer 919 contents when the buffer contains no embedded nulls. Gdb does 920 not depend upon the buffer being null byte terminated, it uses 921 the length string instead. This allows gdb to handle C strings 922 (as well as strings in other languages) with embedded null 923 bytes */ 924 925 if (!tempbuf_init) 926 tempbuf_init = 1; 927 else 928 obstack_free (&tempbuf, NULL); 929 obstack_init (&tempbuf); 930 931 /* Skip the quote. */ 932 quote = *tokptr; 933 ++tokptr; 934 935 *host_chars = 0; 936 937 while (*tokptr) 938 { 939 char c = *tokptr; 940 if (c == '\\') 941 { 942 ++tokptr; 943 *host_chars += c_parse_escape (&tokptr, &tempbuf); 944 } 945 else if (c == quote) 946 break; 947 else 948 { 949 obstack_1grow (&tempbuf, c); 950 ++tokptr; 951 /* FIXME: this does the wrong thing with multi-byte host 952 characters. We could use mbrlen here, but that would 953 make "set host-charset" a bit less useful. */ 954 ++*host_chars; 955 } 956 } 957 958 if (*tokptr != quote) 959 { 960 if (quote == '"') 961 error (_("Unterminated string in expression.")); 962 else 963 error (_("Unmatched single quote.")); 964 } 965 ++tokptr; 966 967 value->type = C_STRING | (quote == '\'' ? C_CHAR : 0); /*FIXME*/ 968 value->ptr = obstack_base (&tempbuf); 969 value->length = obstack_object_size (&tempbuf); 970 971 *outptr = tokptr; 972 973 return quote == '\'' ? CHAR : STRING; 974 } 975 976 struct token 977 { 978 char *operator; 979 int token; 980 enum exp_opcode opcode; 981 }; 982 983 static const struct token tokentab3[] = 984 { 985 {">>=", ASSIGN_MODIFY, BINOP_RSH}, 986 {"<<=", ASSIGN_MODIFY, BINOP_LSH}, 987 /*{"&^=", ASSIGN_MODIFY, BINOP_BITWISE_ANDNOT}, TODO */ 988 {"...", DOTDOTDOT, OP_NULL}, 989 }; 990 991 static const struct token tokentab2[] = 992 { 993 {"+=", ASSIGN_MODIFY, BINOP_ADD}, 994 {"-=", ASSIGN_MODIFY, BINOP_SUB}, 995 {"*=", ASSIGN_MODIFY, BINOP_MUL}, 996 {"/=", ASSIGN_MODIFY, BINOP_DIV}, 997 {"%=", ASSIGN_MODIFY, BINOP_REM}, 998 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR}, 999 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, 1000 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, 1001 {"++", INCREMENT, BINOP_END}, 1002 {"--", DECREMENT, BINOP_END}, 1003 /*{"->", RIGHT_ARROW, BINOP_END}, Doesn't exist in Go. */ 1004 {"<-", LEFT_ARROW, BINOP_END}, 1005 {"&&", ANDAND, BINOP_END}, 1006 {"||", OROR, BINOP_END}, 1007 {"<<", LSH, BINOP_END}, 1008 {">>", RSH, BINOP_END}, 1009 {"==", EQUAL, BINOP_END}, 1010 {"!=", NOTEQUAL, BINOP_END}, 1011 {"<=", LEQ, BINOP_END}, 1012 {">=", GEQ, BINOP_END}, 1013 /*{"&^", ANDNOT, BINOP_END}, TODO */ 1014 }; 1015 1016 /* Identifier-like tokens. */ 1017 static const struct token ident_tokens[] = 1018 { 1019 {"true", TRUE_KEYWORD, OP_NULL}, 1020 {"false", FALSE_KEYWORD, OP_NULL}, 1021 {"nil", NIL_KEYWORD, OP_NULL}, 1022 {"const", CONST_KEYWORD, OP_NULL}, 1023 {"struct", STRUCT_KEYWORD, OP_NULL}, 1024 {"type", TYPE_KEYWORD, OP_NULL}, 1025 {"interface", INTERFACE_KEYWORD, OP_NULL}, 1026 {"chan", CHAN_KEYWORD, OP_NULL}, 1027 {"byte", BYTE_KEYWORD, OP_NULL}, /* An alias of uint8. */ 1028 {"len", LEN_KEYWORD, OP_NULL}, 1029 {"cap", CAP_KEYWORD, OP_NULL}, 1030 {"new", NEW_KEYWORD, OP_NULL}, 1031 {"iota", IOTA_KEYWORD, OP_NULL}, 1032 }; 1033 1034 /* This is set if a NAME token appeared at the very end of the input 1035 string, with no whitespace separating the name from the EOF. This 1036 is used only when parsing to do field name completion. */ 1037 static int saw_name_at_eof; 1038 1039 /* This is set if the previously-returned token was a structure 1040 operator -- either '.' or ARROW. This is used only when parsing to 1041 do field name completion. */ 1042 static int last_was_structop; 1043 1044 /* Read one token, getting characters through lexptr. */ 1045 1046 static int 1047 lex_one_token (void) 1048 { 1049 int c; 1050 int namelen; 1051 unsigned int i; 1052 char *tokstart; 1053 int saw_structop = last_was_structop; 1054 char *copy; 1055 1056 last_was_structop = 0; 1057 1058 retry: 1059 1060 prev_lexptr = lexptr; 1061 1062 tokstart = lexptr; 1063 /* See if it is a special token of length 3. */ 1064 for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++) 1065 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0) 1066 { 1067 lexptr += 3; 1068 yylval.opcode = tokentab3[i].opcode; 1069 return tokentab3[i].token; 1070 } 1071 1072 /* See if it is a special token of length 2. */ 1073 for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++) 1074 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0) 1075 { 1076 lexptr += 2; 1077 yylval.opcode = tokentab2[i].opcode; 1078 /* NOTE: -> doesn't exist in Go, so we don't need to watch for 1079 setting last_was_structop here. */ 1080 return tokentab2[i].token; 1081 } 1082 1083 switch (c = *tokstart) 1084 { 1085 case 0: 1086 if (saw_name_at_eof) 1087 { 1088 saw_name_at_eof = 0; 1089 return COMPLETE; 1090 } 1091 else if (saw_structop) 1092 return COMPLETE; 1093 else 1094 return 0; 1095 1096 case ' ': 1097 case '\t': 1098 case '\n': 1099 lexptr++; 1100 goto retry; 1101 1102 case '[': 1103 case '(': 1104 paren_depth++; 1105 lexptr++; 1106 return c; 1107 1108 case ']': 1109 case ')': 1110 if (paren_depth == 0) 1111 return 0; 1112 paren_depth--; 1113 lexptr++; 1114 return c; 1115 1116 case ',': 1117 if (comma_terminates 1118 && paren_depth == 0) 1119 return 0; 1120 lexptr++; 1121 return c; 1122 1123 case '.': 1124 /* Might be a floating point number. */ 1125 if (lexptr[1] < '0' || lexptr[1] > '9') 1126 { 1127 if (parse_completion) 1128 last_was_structop = 1; 1129 goto symbol; /* Nope, must be a symbol. */ 1130 } 1131 /* FALL THRU into number case. */ 1132 1133 case '0': 1134 case '1': 1135 case '2': 1136 case '3': 1137 case '4': 1138 case '5': 1139 case '6': 1140 case '7': 1141 case '8': 1142 case '9': 1143 { 1144 /* It's a number. */ 1145 int got_dot = 0, got_e = 0, toktype; 1146 char *p = tokstart; 1147 int hex = input_radix > 10; 1148 1149 if (c == '0' && (p[1] == 'x' || p[1] == 'X')) 1150 { 1151 p += 2; 1152 hex = 1; 1153 } 1154 1155 for (;; ++p) 1156 { 1157 /* This test includes !hex because 'e' is a valid hex digit 1158 and thus does not indicate a floating point number when 1159 the radix is hex. */ 1160 if (!hex && !got_e && (*p == 'e' || *p == 'E')) 1161 got_dot = got_e = 1; 1162 /* This test does not include !hex, because a '.' always indicates 1163 a decimal floating point number regardless of the radix. */ 1164 else if (!got_dot && *p == '.') 1165 got_dot = 1; 1166 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 1167 && (*p == '-' || *p == '+')) 1168 /* This is the sign of the exponent, not the end of the 1169 number. */ 1170 continue; 1171 /* We will take any letters or digits. parse_number will 1172 complain if past the radix, or if L or U are not final. */ 1173 else if ((*p < '0' || *p > '9') 1174 && ((*p < 'a' || *p > 'z') 1175 && (*p < 'A' || *p > 'Z'))) 1176 break; 1177 } 1178 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); 1179 if (toktype == ERROR) 1180 { 1181 char *err_copy = (char *) alloca (p - tokstart + 1); 1182 1183 memcpy (err_copy, tokstart, p - tokstart); 1184 err_copy[p - tokstart] = 0; 1185 error (_("Invalid number \"%s\"."), err_copy); 1186 } 1187 lexptr = p; 1188 return toktype; 1189 } 1190 1191 case '@': 1192 { 1193 char *p = &tokstart[1]; 1194 size_t len = strlen ("entry"); 1195 1196 while (isspace (*p)) 1197 p++; 1198 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len]) 1199 && p[len] != '_') 1200 { 1201 lexptr = &p[len]; 1202 return ENTRY; 1203 } 1204 } 1205 /* FALLTHRU */ 1206 case '+': 1207 case '-': 1208 case '*': 1209 case '/': 1210 case '%': 1211 case '|': 1212 case '&': 1213 case '^': 1214 case '~': 1215 case '!': 1216 case '<': 1217 case '>': 1218 case '?': 1219 case ':': 1220 case '=': 1221 case '{': 1222 case '}': 1223 symbol: 1224 lexptr++; 1225 return c; 1226 1227 case '\'': 1228 case '"': 1229 case '`': 1230 { 1231 int host_len; 1232 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval, 1233 &host_len); 1234 if (result == CHAR) 1235 { 1236 if (host_len == 0) 1237 error (_("Empty character constant.")); 1238 else if (host_len > 2 && c == '\'') 1239 { 1240 ++tokstart; 1241 namelen = lexptr - tokstart - 1; 1242 goto tryname; 1243 } 1244 else if (host_len > 1) 1245 error (_("Invalid character constant.")); 1246 } 1247 return result; 1248 } 1249 } 1250 1251 if (!(c == '_' || c == '$' 1252 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 1253 /* We must have come across a bad character (e.g. ';'). */ 1254 error (_("Invalid character '%c' in expression."), c); 1255 1256 /* It's a name. See how long it is. */ 1257 namelen = 0; 1258 for (c = tokstart[namelen]; 1259 (c == '_' || c == '$' || (c >= '0' && c <= '9') 1260 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));) 1261 { 1262 c = tokstart[++namelen]; 1263 } 1264 1265 /* The token "if" terminates the expression and is NOT removed from 1266 the input stream. It doesn't count if it appears in the 1267 expansion of a macro. */ 1268 if (namelen == 2 1269 && tokstart[0] == 'i' 1270 && tokstart[1] == 'f') 1271 { 1272 return 0; 1273 } 1274 1275 /* For the same reason (breakpoint conditions), "thread N" 1276 terminates the expression. "thread" could be an identifier, but 1277 an identifier is never followed by a number without intervening 1278 punctuation. 1279 Handle abbreviations of these, similarly to 1280 breakpoint.c:find_condition_and_thread. 1281 TODO: Watch for "goroutine" here? */ 1282 if (namelen >= 1 1283 && strncmp (tokstart, "thread", namelen) == 0 1284 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')) 1285 { 1286 char *p = tokstart + namelen + 1; 1287 while (*p == ' ' || *p == '\t') 1288 p++; 1289 if (*p >= '0' && *p <= '9') 1290 return 0; 1291 } 1292 1293 lexptr += namelen; 1294 1295 tryname: 1296 1297 yylval.sval.ptr = tokstart; 1298 yylval.sval.length = namelen; 1299 1300 /* Catch specific keywords. */ 1301 copy = copy_name (yylval.sval); 1302 for (i = 0; i < sizeof (ident_tokens) / sizeof (ident_tokens[0]); i++) 1303 if (strcmp (copy, ident_tokens[i].operator) == 0) 1304 { 1305 /* It is ok to always set this, even though we don't always 1306 strictly need to. */ 1307 yylval.opcode = ident_tokens[i].opcode; 1308 return ident_tokens[i].token; 1309 } 1310 1311 if (*tokstart == '$') 1312 return DOLLAR_VARIABLE; 1313 1314 if (parse_completion && *lexptr == '\0') 1315 saw_name_at_eof = 1; 1316 return NAME; 1317 } 1318 1319 /* An object of this type is pushed on a FIFO by the "outer" lexer. */ 1320 typedef struct 1321 { 1322 int token; 1323 YYSTYPE value; 1324 } token_and_value; 1325 1326 DEF_VEC_O (token_and_value); 1327 1328 /* A FIFO of tokens that have been read but not yet returned to the 1329 parser. */ 1330 static VEC (token_and_value) *token_fifo; 1331 1332 /* Non-zero if the lexer should return tokens from the FIFO. */ 1333 static int popping; 1334 1335 /* Temporary storage for yylex; this holds symbol names as they are 1336 built up. */ 1337 static struct obstack name_obstack; 1338 1339 /* Build "package.name" in name_obstack. 1340 For convenience of the caller, the name is NUL-terminated, 1341 but the NUL is not included in the recorded length. */ 1342 1343 static struct stoken 1344 build_packaged_name (const char *package, int package_len, 1345 const char *name, int name_len) 1346 { 1347 struct stoken result; 1348 1349 obstack_free (&name_obstack, obstack_base (&name_obstack)); 1350 obstack_grow (&name_obstack, package, package_len); 1351 obstack_grow_str (&name_obstack, "."); 1352 obstack_grow (&name_obstack, name, name_len); 1353 obstack_grow (&name_obstack, "", 1); 1354 result.ptr = obstack_base (&name_obstack); 1355 result.length = obstack_object_size (&name_obstack) - 1; 1356 1357 return result; 1358 } 1359 1360 /* Return non-zero if NAME is a package name. 1361 BLOCK is the scope in which to interpret NAME; this can be NULL 1362 to mean the global scope. */ 1363 1364 static int 1365 package_name_p (const char *name, const struct block *block) 1366 { 1367 struct symbol *sym; 1368 struct field_of_this_result is_a_field_of_this; 1369 1370 sym = lookup_symbol (name, block, STRUCT_DOMAIN, &is_a_field_of_this); 1371 1372 if (sym 1373 && SYMBOL_CLASS (sym) == LOC_TYPEDEF 1374 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_MODULE) 1375 return 1; 1376 1377 return 0; 1378 } 1379 1380 /* Classify a (potential) function in the "unsafe" package. 1381 We fold these into "keywords" to keep things simple, at least until 1382 something more complex is warranted. */ 1383 1384 static int 1385 classify_unsafe_function (struct stoken function_name) 1386 { 1387 char *copy = copy_name (function_name); 1388 1389 if (strcmp (copy, "Sizeof") == 0) 1390 { 1391 yylval.sval = function_name; 1392 return SIZEOF_KEYWORD; 1393 } 1394 1395 error (_("Unknown function in `unsafe' package: %s"), copy); 1396 } 1397 1398 /* Classify token(s) "name1.name2" where name1 is known to be a package. 1399 The contents of the token are in `yylval'. 1400 Updates yylval and returns the new token type. 1401 1402 The result is one of NAME, NAME_OR_INT, or TYPENAME. */ 1403 1404 static int 1405 classify_packaged_name (const struct block *block) 1406 { 1407 char *copy; 1408 struct symbol *sym; 1409 struct field_of_this_result is_a_field_of_this; 1410 1411 copy = copy_name (yylval.sval); 1412 1413 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this); 1414 1415 if (sym) 1416 { 1417 yylval.ssym.sym = sym; 1418 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 1419 } 1420 1421 return NAME; 1422 } 1423 1424 /* Classify a NAME token. 1425 The contents of the token are in `yylval'. 1426 Updates yylval and returns the new token type. 1427 BLOCK is the block in which lookups start; this can be NULL 1428 to mean the global scope. 1429 1430 The result is one of NAME, NAME_OR_INT, or TYPENAME. */ 1431 1432 static int 1433 classify_name (const struct block *block) 1434 { 1435 struct type *type; 1436 struct symbol *sym; 1437 char *copy; 1438 struct field_of_this_result is_a_field_of_this; 1439 1440 copy = copy_name (yylval.sval); 1441 1442 /* Try primitive types first so they win over bad/weird debug info. */ 1443 type = language_lookup_primitive_type_by_name (parse_language, 1444 parse_gdbarch, copy); 1445 if (type != NULL) 1446 { 1447 /* NOTE: We take advantage of the fact that yylval coming in was a 1448 NAME, and that struct ttype is a compatible extension of struct 1449 stoken, so yylval.tsym.stoken is already filled in. */ 1450 yylval.tsym.type = type; 1451 return TYPENAME; 1452 } 1453 1454 /* TODO: What about other types? */ 1455 1456 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this); 1457 1458 if (sym) 1459 { 1460 yylval.ssym.sym = sym; 1461 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 1462 return NAME; 1463 } 1464 1465 /* If we didn't find a symbol, look again in the current package. 1466 This is to, e.g., make "p global_var" work without having to specify 1467 the package name. We intentionally only looks for objects in the 1468 current package. */ 1469 1470 { 1471 char *current_package_name = go_block_package_name (block); 1472 1473 if (current_package_name != NULL) 1474 { 1475 struct stoken sval = 1476 build_packaged_name (current_package_name, 1477 strlen (current_package_name), 1478 copy, strlen (copy)); 1479 1480 xfree (current_package_name); 1481 sym = lookup_symbol (sval.ptr, block, VAR_DOMAIN, 1482 &is_a_field_of_this); 1483 if (sym) 1484 { 1485 yylval.ssym.stoken = sval; 1486 yylval.ssym.sym = sym; 1487 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 1488 return NAME; 1489 } 1490 } 1491 } 1492 1493 /* Input names that aren't symbols but ARE valid hex numbers, when 1494 the input radix permits them, can be names or numbers depending 1495 on the parse. Note we support radixes > 16 here. */ 1496 if ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10) 1497 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)) 1498 { 1499 YYSTYPE newlval; /* Its value is ignored. */ 1500 int hextype = parse_number (copy, yylval.sval.length, 0, &newlval); 1501 if (hextype == INT) 1502 { 1503 yylval.ssym.sym = NULL; 1504 yylval.ssym.is_a_field_of_this = 0; 1505 return NAME_OR_INT; 1506 } 1507 } 1508 1509 yylval.ssym.sym = NULL; 1510 yylval.ssym.is_a_field_of_this = 0; 1511 return NAME; 1512 } 1513 1514 /* This is taken from c-exp.y mostly to get something working. 1515 The basic structure has been kept because we may yet need some of it. */ 1516 1517 static int 1518 yylex (void) 1519 { 1520 token_and_value current, next; 1521 1522 if (popping && !VEC_empty (token_and_value, token_fifo)) 1523 { 1524 token_and_value tv = *VEC_index (token_and_value, token_fifo, 0); 1525 VEC_ordered_remove (token_and_value, token_fifo, 0); 1526 yylval = tv.value; 1527 /* There's no need to fall through to handle package.name 1528 as that can never happen here. In theory. */ 1529 return tv.token; 1530 } 1531 popping = 0; 1532 1533 current.token = lex_one_token (); 1534 1535 /* TODO: Need a way to force specifying name1 as a package. 1536 .name1.name2 ? */ 1537 1538 if (current.token != NAME) 1539 return current.token; 1540 1541 /* See if we have "name1 . name2". */ 1542 1543 current.value = yylval; 1544 next.token = lex_one_token (); 1545 next.value = yylval; 1546 1547 if (next.token == '.') 1548 { 1549 token_and_value name2; 1550 1551 name2.token = lex_one_token (); 1552 name2.value = yylval; 1553 1554 if (name2.token == NAME) 1555 { 1556 /* Ok, we have "name1 . name2". */ 1557 char *copy; 1558 1559 copy = copy_name (current.value.sval); 1560 1561 if (strcmp (copy, "unsafe") == 0) 1562 { 1563 popping = 1; 1564 return classify_unsafe_function (name2.value.sval); 1565 } 1566 1567 if (package_name_p (copy, expression_context_block)) 1568 { 1569 popping = 1; 1570 yylval.sval = build_packaged_name (current.value.sval.ptr, 1571 current.value.sval.length, 1572 name2.value.sval.ptr, 1573 name2.value.sval.length); 1574 return classify_packaged_name (expression_context_block); 1575 } 1576 } 1577 1578 VEC_safe_push (token_and_value, token_fifo, &next); 1579 VEC_safe_push (token_and_value, token_fifo, &name2); 1580 } 1581 else 1582 { 1583 VEC_safe_push (token_and_value, token_fifo, &next); 1584 } 1585 1586 /* If we arrive here we don't have a package-qualified name. */ 1587 1588 popping = 1; 1589 yylval = current.value; 1590 return classify_name (expression_context_block); 1591 } 1592 1593 int 1594 go_parse (void) 1595 { 1596 int result; 1597 struct cleanup *back_to = make_cleanup (null_cleanup, NULL); 1598 1599 make_cleanup_restore_integer (&yydebug); 1600 yydebug = parser_debug; 1601 1602 /* Initialize some state used by the lexer. */ 1603 last_was_structop = 0; 1604 saw_name_at_eof = 0; 1605 1606 VEC_free (token_and_value, token_fifo); 1607 popping = 0; 1608 obstack_init (&name_obstack); 1609 make_cleanup_obstack_free (&name_obstack); 1610 1611 result = yyparse (); 1612 do_cleanups (back_to); 1613 return result; 1614 } 1615 1616 void 1617 yyerror (char *msg) 1618 { 1619 if (prev_lexptr) 1620 lexptr = prev_lexptr; 1621 1622 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr); 1623 } 1624