1 2 /* A Bison parser, made by GNU Bison 2.4.1. */ 3 4 /* Skeleton implementation for Bison's Yacc-like parsers in C 5 6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 7 Free Software Foundation, Inc. 8 9 This program is free software: you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation, either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 /* As a special exception, you may create a larger work that contains 23 part or all of the Bison parser skeleton and distribute that work 24 under terms of your choice, so long as that work isn't itself a 25 parser generator using the skeleton or a modified version thereof 26 as a parser skeleton. Alternatively, if you modify or redistribute 27 the parser skeleton itself, you may (at your option) remove this 28 special exception, which will cause the skeleton and the resulting 29 Bison output files to be licensed under the GNU General Public 30 License without this special exception. 31 32 This special exception was added by the Free Software Foundation in 33 version 2.2 of Bison. */ 34 35 /* C LALR(1) parser skeleton written by Richard Stallman, by 36 simplifying the original so-called "semantic" parser. */ 37 38 /* All symbols defined below should begin with yy or YY, to avoid 39 infringing on user name space. This should be done even for local 40 variables, as they might otherwise be expanded by user macros. 41 There are some unavoidable exceptions within include files to 42 define necessary library symbols; they are noted "INFRINGES ON 43 USER NAME SPACE" below. */ 44 45 /* Identify Bison output. */ 46 #define YYBISON 1 47 48 /* Bison version. */ 49 #define YYBISON_VERSION "2.4.1" 50 51 /* Skeleton name. */ 52 #define YYSKELETON_NAME "yacc.c" 53 54 /* Pure parsers. */ 55 #define YYPURE 0 56 57 /* Push parsers. */ 58 #define YYPUSH 0 59 60 /* Pull parsers. */ 61 #define YYPULL 1 62 63 /* Using locations. */ 64 #define YYLSP_NEEDED 0 65 66 67 68 /* Copy the first part of user declarations. */ 69 70 /* Line 189 of yacc.c */ 71 #line 52 "go-exp.y" 72 73 74 #include "defs.h" 75 #include "gdb_string.h" 76 #include <ctype.h> 77 #include "expression.h" 78 #include "value.h" 79 #include "parser-defs.h" 80 #include "language.h" 81 #include "c-lang.h" 82 #include "go-lang.h" 83 #include "bfd.h" /* Required by objfiles.h. */ 84 #include "symfile.h" /* Required by objfiles.h. */ 85 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ 86 #include "charset.h" 87 #include "block.h" 88 89 #define parse_type builtin_type (parse_gdbarch) 90 91 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 92 as well as gratuitiously global symbol names, so we can have multiple 93 yacc generated parsers in gdb. Note that these are only the variables 94 produced by yacc. If other parser generators (bison, byacc, etc) produce 95 additional global names that conflict at link time, then those parser 96 generators need to be fixed instead of adding those names to this list. */ 97 98 #define yymaxdepth go_maxdepth 99 #define yyparse go_parse_internal 100 #define yylex go_lex 101 #define yyerror go_error 102 #define yylval go_lval 103 #define yychar go_char 104 #define yydebug go_debug 105 #define yypact go_pact 106 #define yyr1 go_r1 107 #define yyr2 go_r2 108 #define yydef go_def 109 #define yychk go_chk 110 #define yypgo go_pgo 111 #define yyact go_act 112 #define yyexca go_exca 113 #define yyerrflag go_errflag 114 #define yynerrs go_nerrs 115 #define yyps go_ps 116 #define yypv go_pv 117 #define yys go_s 118 #define yy_yys go_yys 119 #define yystate go_state 120 #define yytmp go_tmp 121 #define yyv go_v 122 #define yy_yyv go_yyv 123 #define yyval go_val 124 #define yylloc go_lloc 125 #define yyreds go_reds /* With YYDEBUG defined */ 126 #define yytoks go_toks /* With YYDEBUG defined */ 127 #define yyname go_name /* With YYDEBUG defined */ 128 #define yyrule go_rule /* With YYDEBUG defined */ 129 #define yylhs go_yylhs 130 #define yylen go_yylen 131 #define yydefred go_yydefred 132 #define yydgoto go_yydgoto 133 #define yysindex go_yysindex 134 #define yyrindex go_yyrindex 135 #define yygindex go_yygindex 136 #define yytable go_yytable 137 #define yycheck go_yycheck 138 139 #ifndef YYDEBUG 140 #define YYDEBUG 1 /* Default to yydebug support */ 141 #endif 142 143 #define YYFPRINTF parser_fprintf 144 145 int yyparse (void); 146 147 static int yylex (void); 148 149 void yyerror (char *); 150 151 152 153 /* Line 189 of yacc.c */ 154 #line 155 "go-exp.c" 155 156 /* Enabling traces. */ 157 #ifndef YYDEBUG 158 # define YYDEBUG 0 159 #endif 160 161 /* Enabling verbose error messages. */ 162 #ifdef YYERROR_VERBOSE 163 # undef YYERROR_VERBOSE 164 # define YYERROR_VERBOSE 1 165 #else 166 # define YYERROR_VERBOSE 0 167 #endif 168 169 /* Enabling the token table. */ 170 #ifndef YYTOKEN_TABLE 171 # define YYTOKEN_TABLE 0 172 #endif 173 174 175 /* Tokens. */ 176 #ifndef YYTOKENTYPE 177 # define YYTOKENTYPE 178 /* Put the tokens into the symbol table, so that GDB and other debuggers 179 know about them. */ 180 enum yytokentype { 181 INT = 258, 182 FLOAT = 259, 183 RAW_STRING = 260, 184 STRING = 261, 185 CHAR = 262, 186 NAME = 263, 187 TYPENAME = 264, 188 COMPLETE = 265, 189 NAME_OR_INT = 266, 190 TRUE_KEYWORD = 267, 191 FALSE_KEYWORD = 268, 192 STRUCT_KEYWORD = 269, 193 INTERFACE_KEYWORD = 270, 194 TYPE_KEYWORD = 271, 195 CHAN_KEYWORD = 272, 196 SIZEOF_KEYWORD = 273, 197 LEN_KEYWORD = 274, 198 CAP_KEYWORD = 275, 199 NEW_KEYWORD = 276, 200 IOTA_KEYWORD = 277, 201 NIL_KEYWORD = 278, 202 CONST_KEYWORD = 279, 203 DOTDOTDOT = 280, 204 ENTRY = 281, 205 ERROR = 282, 206 BYTE_KEYWORD = 283, 207 DOLLAR_VARIABLE = 284, 208 ASSIGN_MODIFY = 285, 209 ABOVE_COMMA = 286, 210 OROR = 287, 211 ANDAND = 288, 212 ANDNOT = 289, 213 NOTEQUAL = 290, 214 EQUAL = 291, 215 GEQ = 292, 216 LEQ = 293, 217 RSH = 294, 218 LSH = 295, 219 DECREMENT = 296, 220 INCREMENT = 297, 221 UNARY = 298, 222 LEFT_ARROW = 299 223 }; 224 #endif 225 /* Tokens. */ 226 #define INT 258 227 #define FLOAT 259 228 #define RAW_STRING 260 229 #define STRING 261 230 #define CHAR 262 231 #define NAME 263 232 #define TYPENAME 264 233 #define COMPLETE 265 234 #define NAME_OR_INT 266 235 #define TRUE_KEYWORD 267 236 #define FALSE_KEYWORD 268 237 #define STRUCT_KEYWORD 269 238 #define INTERFACE_KEYWORD 270 239 #define TYPE_KEYWORD 271 240 #define CHAN_KEYWORD 272 241 #define SIZEOF_KEYWORD 273 242 #define LEN_KEYWORD 274 243 #define CAP_KEYWORD 275 244 #define NEW_KEYWORD 276 245 #define IOTA_KEYWORD 277 246 #define NIL_KEYWORD 278 247 #define CONST_KEYWORD 279 248 #define DOTDOTDOT 280 249 #define ENTRY 281 250 #define ERROR 282 251 #define BYTE_KEYWORD 283 252 #define DOLLAR_VARIABLE 284 253 #define ASSIGN_MODIFY 285 254 #define ABOVE_COMMA 286 255 #define OROR 287 256 #define ANDAND 288 257 #define ANDNOT 289 258 #define NOTEQUAL 290 259 #define EQUAL 291 260 #define GEQ 292 261 #define LEQ 293 262 #define RSH 294 263 #define LSH 295 264 #define DECREMENT 296 265 #define INCREMENT 297 266 #define UNARY 298 267 #define LEFT_ARROW 299 268 269 270 271 272 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 273 typedef union YYSTYPE 274 { 275 276 /* Line 214 of yacc.c */ 277 #line 138 "go-exp.y" 278 279 LONGEST lval; 280 struct { 281 LONGEST val; 282 struct type *type; 283 } typed_val_int; 284 struct { 285 DOUBLEST dval; 286 struct type *type; 287 } typed_val_float; 288 struct stoken sval; 289 struct symtoken ssym; 290 struct type *tval; 291 struct typed_stoken tsval; 292 struct ttype tsym; 293 int voidval; 294 enum exp_opcode opcode; 295 struct internalvar *ivar; 296 struct stoken_vector svec; 297 298 299 300 /* Line 214 of yacc.c */ 301 #line 302 "go-exp.c" 302 } YYSTYPE; 303 # define YYSTYPE_IS_TRIVIAL 1 304 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 305 # define YYSTYPE_IS_DECLARED 1 306 #endif 307 308 309 /* Copy the second part of user declarations. */ 310 311 /* Line 264 of yacc.c */ 312 #line 159 "go-exp.y" 313 314 /* YYSTYPE gets defined by %union. */ 315 static int parse_number (char *, int, int, YYSTYPE *); 316 static int parse_go_float (struct gdbarch *gdbarch, const char *p, int len, 317 DOUBLEST *d, struct type **t); 318 319 320 /* Line 264 of yacc.c */ 321 #line 322 "go-exp.c" 322 323 #ifdef short 324 # undef short 325 #endif 326 327 #ifdef YYTYPE_UINT8 328 typedef YYTYPE_UINT8 yytype_uint8; 329 #else 330 typedef unsigned char yytype_uint8; 331 #endif 332 333 #ifdef YYTYPE_INT8 334 typedef YYTYPE_INT8 yytype_int8; 335 #elif (defined __STDC__ || defined __C99__FUNC__ \ 336 || defined __cplusplus || defined _MSC_VER) 337 typedef signed char yytype_int8; 338 #else 339 typedef short int yytype_int8; 340 #endif 341 342 #ifdef YYTYPE_UINT16 343 typedef YYTYPE_UINT16 yytype_uint16; 344 #else 345 typedef unsigned short int yytype_uint16; 346 #endif 347 348 #ifdef YYTYPE_INT16 349 typedef YYTYPE_INT16 yytype_int16; 350 #else 351 typedef short int yytype_int16; 352 #endif 353 354 #ifndef YYSIZE_T 355 # ifdef __SIZE_TYPE__ 356 # define YYSIZE_T __SIZE_TYPE__ 357 # elif defined size_t 358 # define YYSIZE_T size_t 359 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 360 || defined __cplusplus || defined _MSC_VER) 361 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 362 # define YYSIZE_T size_t 363 # else 364 # define YYSIZE_T unsigned int 365 # endif 366 #endif 367 368 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 369 370 #ifndef YY_ 371 # if YYENABLE_NLS 372 # if ENABLE_NLS 373 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 374 # define YY_(msgid) dgettext ("bison-runtime", msgid) 375 # endif 376 # endif 377 # ifndef YY_ 378 # define YY_(msgid) msgid 379 # endif 380 #endif 381 382 /* Suppress unused-variable warnings by "using" E. */ 383 #if ! defined lint || defined __GNUC__ 384 # define YYUSE(e) ((void) (e)) 385 #else 386 # define YYUSE(e) /* empty */ 387 #endif 388 389 /* Identity function, used to suppress warnings about constant conditions. */ 390 #ifndef lint 391 # define YYID(n) (n) 392 #else 393 #if (defined __STDC__ || defined __C99__FUNC__ \ 394 || defined __cplusplus || defined _MSC_VER) 395 static int 396 YYID (int yyi) 397 #else 398 static int 399 YYID (yyi) 400 int yyi; 401 #endif 402 { 403 return yyi; 404 } 405 #endif 406 407 #if ! defined yyoverflow || YYERROR_VERBOSE 408 409 /* The parser invokes alloca or xmalloc; define the necessary symbols. */ 410 411 # ifdef YYSTACK_USE_ALLOCA 412 # if YYSTACK_USE_ALLOCA 413 # ifdef __GNUC__ 414 # define YYSTACK_ALLOC __builtin_alloca 415 # elif defined __BUILTIN_VA_ARG_INCR 416 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 417 # elif defined _AIX 418 # define YYSTACK_ALLOC __alloca 419 # elif defined _MSC_VER 420 # define alloca _alloca 421 # else 422 # define YYSTACK_ALLOC alloca 423 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 424 || defined __cplusplus || defined _MSC_VER) 425 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 426 # ifndef _STDLIB_H 427 # define _STDLIB_H 1 428 # endif 429 # endif 430 # endif 431 # endif 432 # endif 433 434 # ifdef YYSTACK_ALLOC 435 /* Pacify GCC's `empty if-body' warning. */ 436 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 437 # ifndef YYSTACK_ALLOC_MAXIMUM 438 /* The OS might guarantee only one guard page at the bottom of the stack, 439 and a page size can be as small as 4096 bytes. So we cannot safely 440 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 441 to allow for a few compiler-allocated temporary stack slots. */ 442 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 443 # endif 444 # else 445 # define YYSTACK_ALLOC YYMALLOC 446 # define YYSTACK_FREE YYFREE 447 # ifndef YYSTACK_ALLOC_MAXIMUM 448 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 449 # endif 450 # if (defined __cplusplus && ! defined _STDLIB_H \ 451 && ! ((defined YYMALLOC || defined xmalloc) \ 452 && (defined YYFREE || defined xfree))) 453 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 454 # ifndef _STDLIB_H 455 # define _STDLIB_H 1 456 # endif 457 # endif 458 # ifndef YYMALLOC 459 # define YYMALLOC xmalloc 460 # if ! defined xmalloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 461 || defined __cplusplus || defined _MSC_VER) 462 void *xmalloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 463 # endif 464 # endif 465 # ifndef YYFREE 466 # define YYFREE xfree 467 # if ! defined xfree && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 468 || defined __cplusplus || defined _MSC_VER) 469 void xfree (void *); /* INFRINGES ON USER NAME SPACE */ 470 # endif 471 # endif 472 # endif 473 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 474 475 476 #if (! defined yyoverflow \ 477 && (! defined __cplusplus \ 478 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 479 480 /* A type that is properly aligned for any stack member. */ 481 union yyalloc 482 { 483 yytype_int16 yyss_alloc; 484 YYSTYPE yyvs_alloc; 485 }; 486 487 /* The size of the maximum gap between one aligned stack and the next. */ 488 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 489 490 /* The size of an array large to enough to hold all stacks, each with 491 N elements. */ 492 # define YYSTACK_BYTES(N) \ 493 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 494 + YYSTACK_GAP_MAXIMUM) 495 496 /* Copy COUNT objects from FROM to TO. The source and destination do 497 not overlap. */ 498 # ifndef YYCOPY 499 # if defined __GNUC__ && 1 < __GNUC__ 500 # define YYCOPY(To, From, Count) \ 501 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 502 # else 503 # define YYCOPY(To, From, Count) \ 504 do \ 505 { \ 506 YYSIZE_T yyi; \ 507 for (yyi = 0; yyi < (Count); yyi++) \ 508 (To)[yyi] = (From)[yyi]; \ 509 } \ 510 while (YYID (0)) 511 # endif 512 # endif 513 514 /* Relocate STACK from its old location to the new one. The 515 local variables YYSIZE and YYSTACKSIZE give the old and new number of 516 elements in the stack, and YYPTR gives the new location of the 517 stack. Advance YYPTR to a properly aligned location for the next 518 stack. */ 519 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 520 do \ 521 { \ 522 YYSIZE_T yynewbytes; \ 523 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 524 Stack = &yyptr->Stack_alloc; \ 525 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 526 yyptr += yynewbytes / sizeof (*yyptr); \ 527 } \ 528 while (YYID (0)) 529 530 #endif 531 532 /* YYFINAL -- State number of the termination state. */ 533 #define YYFINAL 40 534 /* YYLAST -- Last index in YYTABLE. */ 535 #define YYLAST 443 536 537 /* YYNTOKENS -- Number of terminals. */ 538 #define YYNTOKENS 68 539 /* YYNNTS -- Number of nonterminals. */ 540 #define YYNNTS 13 541 /* YYNRULES -- Number of rules. */ 542 #define YYNRULES 69 543 /* YYNRULES -- Number of states. */ 544 #define YYNSTATES 122 545 546 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 547 #define YYUNDEFTOK 2 548 #define YYMAXUTOK 299 549 550 #define YYTRANSLATE(YYX) \ 551 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 552 553 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 554 static const yytype_uint8 yytranslate[] = 555 { 556 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 557 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 558 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 559 2, 2, 2, 62, 2, 2, 2, 54, 39, 2, 560 60, 64, 52, 50, 31, 51, 58, 53, 2, 2, 561 2, 2, 2, 2, 2, 2, 2, 2, 67, 2, 562 43, 33, 44, 34, 49, 2, 2, 2, 2, 2, 563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 565 2, 59, 2, 63, 38, 2, 2, 2, 2, 2, 566 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 568 2, 2, 2, 65, 37, 66, 2, 2, 2, 2, 569 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 571 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 574 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 575 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 576 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 577 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 578 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 579 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 580 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 581 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 582 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 583 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 584 25, 26, 27, 28, 29, 30, 32, 35, 36, 40, 585 41, 42, 45, 46, 47, 48, 55, 56, 57, 61 586 }; 587 588 #if YYDEBUG 589 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 590 YYRHS. */ 591 static const yytype_uint8 yyprhs[] = 592 { 593 0, 0, 3, 5, 7, 9, 11, 15, 18, 21, 594 24, 27, 30, 33, 36, 39, 43, 48, 52, 57, 595 58, 64, 66, 67, 69, 73, 75, 80, 85, 89, 596 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 597 133, 137, 141, 145, 149, 153, 157, 161, 165, 171, 598 175, 179, 181, 183, 185, 187, 189, 191, 196, 201, 599 203, 207, 209, 211, 213, 216, 218, 221, 223, 225 600 }; 601 602 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 603 static const yytype_int8 yyrhs[] = 604 { 605 69, 0, -1, 71, -1, 70, -1, 79, -1, 72, 606 -1, 71, 31, 72, -1, 52, 72, -1, 39, 72, 607 -1, 51, 72, -1, 50, 72, -1, 62, 72, -1, 608 38, 72, -1, 72, 56, -1, 72, 55, -1, 72, 609 58, 80, -1, 72, 58, 80, 10, -1, 72, 58, 610 10, -1, 72, 59, 71, 63, -1, -1, 72, 60, 611 73, 75, 64, -1, 65, -1, -1, 72, -1, 75, 612 31, 72, -1, 66, -1, 74, 79, 76, 72, -1, 613 79, 60, 72, 64, -1, 60, 71, 64, -1, 72, 614 49, 72, -1, 72, 52, 72, -1, 72, 53, 72, 615 -1, 72, 54, 72, -1, 72, 50, 72, -1, 72, 616 51, 72, -1, 72, 48, 72, -1, 72, 47, 72, 617 -1, 72, 42, 72, -1, 72, 41, 72, -1, 72, 618 46, 72, -1, 72, 45, 72, -1, 72, 43, 72, 619 -1, 72, 44, 72, -1, 72, 39, 72, -1, 72, 620 38, 72, -1, 72, 37, 72, -1, 72, 36, 72, 621 -1, 72, 35, 72, -1, 72, 34, 72, 67, 72, 622 -1, 72, 33, 72, -1, 72, 30, 72, -1, 3, 623 -1, 7, -1, 11, -1, 4, -1, 78, -1, 29, 624 -1, 18, 60, 79, 64, -1, 18, 60, 72, 64, 625 -1, 6, -1, 77, 50, 6, -1, 77, -1, 12, 626 -1, 13, -1, 80, 26, -1, 80, -1, 52, 79, 627 -1, 9, -1, 28, -1, 8, -1 628 }; 629 630 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 631 static const yytype_uint16 yyrline[] = 632 { 633 0, 237, 237, 238, 241, 248, 249, 254, 258, 262, 634 266, 270, 274, 278, 282, 288, 294, 301, 311, 318, 635 315, 325, 329, 332, 336, 340, 344, 350, 356, 362, 636 366, 370, 374, 378, 382, 386, 390, 394, 398, 402, 637 406, 410, 414, 418, 422, 426, 430, 434, 438, 442, 638 446, 452, 459, 468, 481, 488, 491, 497, 509, 516, 639 533, 551, 562, 568, 574, 590, 645, 647, 654, 667 640 }; 641 #endif 642 643 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 644 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 645 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 646 static const char *const yytname[] = 647 { 648 "$end", "error", "$undefined", "INT", "FLOAT", "RAW_STRING", "STRING", 649 "CHAR", "NAME", "TYPENAME", "COMPLETE", "NAME_OR_INT", "TRUE_KEYWORD", 650 "FALSE_KEYWORD", "STRUCT_KEYWORD", "INTERFACE_KEYWORD", "TYPE_KEYWORD", 651 "CHAN_KEYWORD", "SIZEOF_KEYWORD", "LEN_KEYWORD", "CAP_KEYWORD", 652 "NEW_KEYWORD", "IOTA_KEYWORD", "NIL_KEYWORD", "CONST_KEYWORD", 653 "DOTDOTDOT", "ENTRY", "ERROR", "BYTE_KEYWORD", "DOLLAR_VARIABLE", 654 "ASSIGN_MODIFY", "','", "ABOVE_COMMA", "'='", "'?'", "OROR", "ANDAND", 655 "'|'", "'^'", "'&'", "ANDNOT", "NOTEQUAL", "EQUAL", "'<'", "'>'", "GEQ", 656 "LEQ", "RSH", "LSH", "'@'", "'+'", "'-'", "'*'", "'/'", "'%'", 657 "DECREMENT", "INCREMENT", "UNARY", "'.'", "'['", "'('", "LEFT_ARROW", 658 "'!'", "']'", "')'", "'{'", "'}'", "':'", "$accept", "start", "type_exp", 659 "exp1", "exp", "$@1", "lcurly", "arglist", "rcurly", "string_exp", 660 "variable", "type", "name_not_typename", 0 661 }; 662 #endif 663 664 # ifdef YYPRINT 665 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 666 token YYLEX-NUM. */ 667 static const yytype_uint16 yytoknum[] = 668 { 669 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 670 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 671 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 672 285, 44, 286, 61, 63, 287, 288, 124, 94, 38, 673 289, 290, 291, 60, 62, 292, 293, 294, 295, 64, 674 43, 45, 42, 47, 37, 296, 297, 298, 46, 91, 675 40, 299, 33, 93, 41, 123, 125, 58 676 }; 677 # endif 678 679 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 680 static const yytype_uint8 yyr1[] = 681 { 682 0, 68, 69, 69, 70, 71, 71, 72, 72, 72, 683 72, 72, 72, 72, 72, 72, 72, 72, 72, 73, 684 72, 74, 75, 75, 75, 76, 72, 72, 72, 72, 685 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 686 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 687 72, 72, 72, 72, 72, 72, 72, 72, 72, 77, 688 77, 72, 72, 72, 78, 78, 79, 79, 79, 80 689 }; 690 691 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 692 static const yytype_uint8 yyr2[] = 693 { 694 0, 2, 1, 1, 1, 1, 3, 2, 2, 2, 695 2, 2, 2, 2, 2, 3, 4, 3, 4, 0, 696 5, 1, 0, 1, 3, 1, 4, 4, 3, 3, 697 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 698 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 699 3, 1, 1, 1, 1, 1, 1, 4, 4, 1, 700 3, 1, 1, 1, 2, 1, 2, 1, 1, 1 701 }; 702 703 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 704 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 705 means the default is an error. */ 706 static const yytype_uint8 yydefact[] = 707 { 708 0, 51, 54, 59, 52, 69, 67, 53, 62, 63, 709 0, 68, 56, 0, 0, 0, 0, 0, 0, 0, 710 21, 0, 3, 2, 5, 0, 61, 55, 4, 65, 711 0, 12, 0, 8, 10, 9, 7, 66, 0, 11, 712 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 713 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 714 0, 0, 0, 0, 14, 13, 0, 0, 19, 0, 715 0, 0, 0, 64, 0, 0, 28, 6, 50, 49, 716 0, 47, 46, 45, 44, 43, 38, 37, 41, 42, 717 40, 39, 36, 35, 29, 33, 34, 30, 31, 32, 718 17, 15, 0, 22, 66, 25, 0, 60, 0, 58, 719 57, 0, 16, 18, 23, 0, 26, 27, 48, 0, 720 20, 24 721 }; 722 723 /* YYDEFGOTO[NTERM-NUM]. */ 724 static const yytype_int8 yydefgoto[] = 725 { 726 -1, 21, 22, 23, 24, 103, 25, 115, 106, 26, 727 27, 32, 29 728 }; 729 730 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 731 STATE-NUM. */ 732 #define YYPACT_NINF -56 733 static const yytype_int16 yypact[] = 734 { 735 49, -56, -56, -56, -56, -56, -56, -56, -56, -56, 736 -44, -56, -56, 49, 49, 49, 49, 49, 49, 49, 737 -56, 23, -56, 34, 187, 45, -23, -56, 6, 46, 738 49, -48, 6, -48, -48, -48, -48, 6, 38, -48, 739 -56, 49, 49, 49, 49, 49, 49, 49, 49, 49, 740 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 741 49, 49, 49, 49, -56, -56, 5, 49, -56, 45, 742 8, 65, 49, -56, 123, -55, -56, 187, 187, 187, 743 88, 239, 263, 286, 308, 328, 346, 346, 360, 360, 744 360, 360, 372, 372, 383, -34, -34, -48, -48, -48, 745 -56, 69, 33, 49, -56, -56, 49, -56, 155, -56, 746 -56, 49, -56, -56, 187, 39, -48, -56, 214, 49, 747 -56, 187 748 }; 749 750 /* YYPGOTO[NTERM-NUM]. */ 751 static const yytype_int8 yypgoto[] = 752 { 753 -56, -56, -56, -4, -13, -56, -56, -56, -56, -56, 754 -56, 51, 9 755 }; 756 757 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 758 positive, shift that token. If negative, reduce the rule which 759 number is the opposite. If zero, do what YYDEFACT says. 760 If YYTABLE_NINF, syntax error. */ 761 #define YYTABLE_NINF -1 762 static const yytype_uint8 yytable[] = 763 { 764 31, 33, 34, 35, 36, 72, 39, 64, 65, 110, 765 66, 67, 68, 5, 38, 100, 30, 74, 61, 62, 766 63, 64, 65, 40, 66, 67, 68, 71, 77, 78, 767 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 768 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 769 99, 28, 1, 2, 6, 3, 4, 5, 6, 108, 770 7, 8, 9, 102, 41, 41, 72, 10, 37, 41, 771 119, 107, 73, 11, 105, 101, 70, 11, 12, 112, 772 0, 75, 0, 0, 0, 0, 0, 13, 14, 0, 773 114, 0, 0, 116, 0, 0, 113, 69, 118, 15, 774 16, 17, 76, 120, 0, 0, 121, 0, 0, 18, 775 0, 19, 0, 0, 20, 0, 0, 0, 42, 0, 776 104, 43, 44, 45, 46, 47, 48, 49, 0, 50, 777 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 778 61, 62, 63, 64, 65, 0, 66, 67, 68, 0, 779 0, 0, 0, 42, 0, 111, 43, 44, 45, 46, 780 47, 48, 49, 0, 50, 51, 52, 53, 54, 55, 781 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 782 0, 66, 67, 68, 0, 42, 0, 109, 43, 44, 783 45, 46, 47, 48, 49, 0, 50, 51, 52, 53, 784 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 785 64, 65, 0, 66, 67, 68, 0, 42, 0, 117, 786 43, 44, 45, 46, 47, 48, 49, 0, 50, 51, 787 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 788 62, 63, 64, 65, 0, 66, 67, 68, 44, 45, 789 46, 47, 48, 49, 0, 50, 51, 52, 53, 54, 790 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 791 65, 0, 66, 67, 68, 46, 47, 48, 49, 0, 792 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 793 60, 61, 62, 63, 64, 65, 0, 66, 67, 68, 794 47, 48, 49, 0, 50, 51, 52, 53, 54, 55, 795 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 796 0, 66, 67, 68, 48, 49, 0, 50, 51, 52, 797 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 798 63, 64, 65, 0, 66, 67, 68, 49, 0, 50, 799 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 800 61, 62, 63, 64, 65, 0, 66, 67, 68, 50, 801 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 802 61, 62, 63, 64, 65, 0, 66, 67, 68, 52, 803 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 804 63, 64, 65, 0, 66, 67, 68, 56, 57, 58, 805 59, 60, 61, 62, 63, 64, 65, 0, 66, 67, 806 68, 58, 59, 60, 61, 62, 63, 64, 65, 0, 807 66, 67, 68, 59, 60, 61, 62, 63, 64, 65, 808 0, 66, 67, 68 809 }; 810 811 static const yytype_int8 yycheck[] = 812 { 813 13, 14, 15, 16, 17, 60, 19, 55, 56, 64, 814 58, 59, 60, 8, 18, 10, 60, 30, 52, 53, 815 54, 55, 56, 0, 58, 59, 60, 50, 41, 42, 816 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 817 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 818 63, 0, 3, 4, 9, 6, 7, 8, 9, 72, 819 11, 12, 13, 67, 31, 31, 60, 18, 17, 31, 820 31, 6, 26, 28, 66, 66, 25, 28, 29, 10, 821 -1, 30, -1, -1, -1, -1, -1, 38, 39, -1, 822 103, -1, -1, 106, -1, -1, 63, 52, 111, 50, 823 51, 52, 64, 64, -1, -1, 119, -1, -1, 60, 824 -1, 62, -1, -1, 65, -1, -1, -1, 30, -1, 825 69, 33, 34, 35, 36, 37, 38, 39, -1, 41, 826 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 827 52, 53, 54, 55, 56, -1, 58, 59, 60, -1, 828 -1, -1, -1, 30, -1, 67, 33, 34, 35, 36, 829 37, 38, 39, -1, 41, 42, 43, 44, 45, 46, 830 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 831 -1, 58, 59, 60, -1, 30, -1, 64, 33, 34, 832 35, 36, 37, 38, 39, -1, 41, 42, 43, 44, 833 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 834 55, 56, -1, 58, 59, 60, -1, 30, -1, 64, 835 33, 34, 35, 36, 37, 38, 39, -1, 41, 42, 836 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 837 53, 54, 55, 56, -1, 58, 59, 60, 34, 35, 838 36, 37, 38, 39, -1, 41, 42, 43, 44, 45, 839 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 840 56, -1, 58, 59, 60, 36, 37, 38, 39, -1, 841 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 842 51, 52, 53, 54, 55, 56, -1, 58, 59, 60, 843 37, 38, 39, -1, 41, 42, 43, 44, 45, 46, 844 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 845 -1, 58, 59, 60, 38, 39, -1, 41, 42, 43, 846 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 847 54, 55, 56, -1, 58, 59, 60, 39, -1, 41, 848 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 849 52, 53, 54, 55, 56, -1, 58, 59, 60, 41, 850 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 851 52, 53, 54, 55, 56, -1, 58, 59, 60, 43, 852 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 853 54, 55, 56, -1, 58, 59, 60, 47, 48, 49, 854 50, 51, 52, 53, 54, 55, 56, -1, 58, 59, 855 60, 49, 50, 51, 52, 53, 54, 55, 56, -1, 856 58, 59, 60, 50, 51, 52, 53, 54, 55, 56, 857 -1, 58, 59, 60 858 }; 859 860 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 861 symbol of state STATE-NUM. */ 862 static const yytype_uint8 yystos[] = 863 { 864 0, 3, 4, 6, 7, 8, 9, 11, 12, 13, 865 18, 28, 29, 38, 39, 50, 51, 52, 60, 62, 866 65, 69, 70, 71, 72, 74, 77, 78, 79, 80, 867 60, 72, 79, 72, 72, 72, 72, 79, 71, 72, 868 0, 31, 30, 33, 34, 35, 36, 37, 38, 39, 869 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 870 51, 52, 53, 54, 55, 56, 58, 59, 60, 52, 871 79, 50, 60, 26, 72, 79, 64, 72, 72, 72, 872 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 873 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 874 10, 80, 71, 73, 79, 66, 76, 6, 72, 64, 875 64, 67, 10, 63, 72, 75, 72, 64, 72, 31, 876 64, 72 877 }; 878 879 #define yyerrok (yyerrstatus = 0) 880 #define yyclearin (yychar = YYEMPTY) 881 #define YYEMPTY (-2) 882 #define YYEOF 0 883 884 #define YYACCEPT goto yyacceptlab 885 #define YYABORT goto yyabortlab 886 #define YYERROR goto yyerrorlab 887 888 889 /* Like YYERROR except do call yyerror. This remains here temporarily 890 to ease the transition to the new meaning of YYERROR, for GCC. 891 Once GCC version 2 has supplanted version 1, this can go. */ 892 893 #define YYFAIL goto yyerrlab 894 895 #define YYRECOVERING() (!!yyerrstatus) 896 897 #define YYBACKUP(Token, Value) \ 898 do \ 899 if (yychar == YYEMPTY && yylen == 1) \ 900 { \ 901 yychar = (Token); \ 902 yylval = (Value); \ 903 yytoken = YYTRANSLATE (yychar); \ 904 YYPOPSTACK (1); \ 905 goto yybackup; \ 906 } \ 907 else \ 908 { \ 909 yyerror (YY_("syntax error: cannot back up")); \ 910 YYERROR; \ 911 } \ 912 while (YYID (0)) 913 914 915 #define YYTERROR 1 916 #define YYERRCODE 256 917 918 919 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 920 If N is 0, then set CURRENT to the empty location which ends 921 the previous symbol: RHS[0] (always defined). */ 922 923 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 924 #ifndef YYLLOC_DEFAULT 925 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 926 do \ 927 if (YYID (N)) \ 928 { \ 929 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 930 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 931 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 932 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 933 } \ 934 else \ 935 { \ 936 (Current).first_line = (Current).last_line = \ 937 YYRHSLOC (Rhs, 0).last_line; \ 938 (Current).first_column = (Current).last_column = \ 939 YYRHSLOC (Rhs, 0).last_column; \ 940 } \ 941 while (YYID (0)) 942 #endif 943 944 945 /* YY_LOCATION_PRINT -- Print the location on the stream. 946 This macro was not mandated originally: define only if we know 947 we won't break user code: when these are the locations we know. */ 948 949 #ifndef YY_LOCATION_PRINT 950 # if YYLTYPE_IS_TRIVIAL 951 # define YY_LOCATION_PRINT(File, Loc) \ 952 fprintf (File, "%d.%d-%d.%d", \ 953 (Loc).first_line, (Loc).first_column, \ 954 (Loc).last_line, (Loc).last_column) 955 # else 956 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 957 # endif 958 #endif 959 960 961 /* YYLEX -- calling `yylex' with the right arguments. */ 962 963 #ifdef YYLEX_PARAM 964 # define YYLEX yylex (YYLEX_PARAM) 965 #else 966 # define YYLEX yylex () 967 #endif 968 969 /* Enable debugging if requested. */ 970 #if YYDEBUG 971 972 # ifndef YYFPRINTF 973 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 974 # define YYFPRINTF fprintf 975 # endif 976 977 # define YYDPRINTF(Args) \ 978 do { \ 979 if (yydebug) \ 980 YYFPRINTF Args; \ 981 } while (YYID (0)) 982 983 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 984 do { \ 985 if (yydebug) \ 986 { \ 987 YYFPRINTF (stderr, "%s ", Title); \ 988 yy_symbol_print (stderr, \ 989 Type, Value); \ 990 YYFPRINTF (stderr, "\n"); \ 991 } \ 992 } while (YYID (0)) 993 994 995 /*--------------------------------. 996 | Print this symbol on YYOUTPUT. | 997 `--------------------------------*/ 998 999 /*ARGSUSED*/ 1000 #if (defined __STDC__ || defined __C99__FUNC__ \ 1001 || defined __cplusplus || defined _MSC_VER) 1002 static void 1003 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1004 #else 1005 static void 1006 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1007 FILE *yyoutput; 1008 int yytype; 1009 YYSTYPE const * const yyvaluep; 1010 #endif 1011 { 1012 if (!yyvaluep) 1013 return; 1014 # ifdef YYPRINT 1015 if (yytype < YYNTOKENS) 1016 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1017 # else 1018 YYUSE (yyoutput); 1019 # endif 1020 switch (yytype) 1021 { 1022 default: 1023 break; 1024 } 1025 } 1026 1027 1028 /*--------------------------------. 1029 | Print this symbol on YYOUTPUT. | 1030 `--------------------------------*/ 1031 1032 #if (defined __STDC__ || defined __C99__FUNC__ \ 1033 || defined __cplusplus || defined _MSC_VER) 1034 static void 1035 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1036 #else 1037 static void 1038 yy_symbol_print (yyoutput, yytype, yyvaluep) 1039 FILE *yyoutput; 1040 int yytype; 1041 YYSTYPE const * const yyvaluep; 1042 #endif 1043 { 1044 if (yytype < YYNTOKENS) 1045 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1046 else 1047 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1048 1049 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1050 YYFPRINTF (yyoutput, ")"); 1051 } 1052 1053 /*------------------------------------------------------------------. 1054 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1055 | TOP (included). | 1056 `------------------------------------------------------------------*/ 1057 1058 #if (defined __STDC__ || defined __C99__FUNC__ \ 1059 || defined __cplusplus || defined _MSC_VER) 1060 static void 1061 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 1062 #else 1063 static void 1064 yy_stack_print (yybottom, yytop) 1065 yytype_int16 *yybottom; 1066 yytype_int16 *yytop; 1067 #endif 1068 { 1069 YYFPRINTF (stderr, "Stack now"); 1070 for (; yybottom <= yytop; yybottom++) 1071 { 1072 int yybot = *yybottom; 1073 YYFPRINTF (stderr, " %d", yybot); 1074 } 1075 YYFPRINTF (stderr, "\n"); 1076 } 1077 1078 # define YY_STACK_PRINT(Bottom, Top) \ 1079 do { \ 1080 if (yydebug) \ 1081 yy_stack_print ((Bottom), (Top)); \ 1082 } while (YYID (0)) 1083 1084 1085 /*------------------------------------------------. 1086 | Report that the YYRULE is going to be reduced. | 1087 `------------------------------------------------*/ 1088 1089 #if (defined __STDC__ || defined __C99__FUNC__ \ 1090 || defined __cplusplus || defined _MSC_VER) 1091 static void 1092 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1093 #else 1094 static void 1095 yy_reduce_print (yyvsp, yyrule) 1096 YYSTYPE *yyvsp; 1097 int yyrule; 1098 #endif 1099 { 1100 int yynrhs = yyr2[yyrule]; 1101 int yyi; 1102 unsigned long int yylno = yyrline[yyrule]; 1103 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1104 yyrule - 1, yylno); 1105 /* The symbols being reduced. */ 1106 for (yyi = 0; yyi < yynrhs; yyi++) 1107 { 1108 YYFPRINTF (stderr, " $%d = ", yyi + 1); 1109 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1110 &(yyvsp[(yyi + 1) - (yynrhs)]) 1111 ); 1112 YYFPRINTF (stderr, "\n"); 1113 } 1114 } 1115 1116 # define YY_REDUCE_PRINT(Rule) \ 1117 do { \ 1118 if (yydebug) \ 1119 yy_reduce_print (yyvsp, Rule); \ 1120 } while (YYID (0)) 1121 1122 /* Nonzero means print parse trace. It is left uninitialized so that 1123 multiple parsers can coexist. */ 1124 int yydebug; 1125 #else /* !YYDEBUG */ 1126 # define YYDPRINTF(Args) 1127 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1128 # define YY_STACK_PRINT(Bottom, Top) 1129 # define YY_REDUCE_PRINT(Rule) 1130 #endif /* !YYDEBUG */ 1131 1132 1133 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1134 #ifndef YYINITDEPTH 1135 # define YYINITDEPTH 200 1136 #endif 1137 1138 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1139 if the built-in stack extension method is used). 1140 1141 Do not make this value too large; the results are undefined if 1142 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1143 evaluated with infinite-precision integer arithmetic. */ 1144 1145 #ifndef YYMAXDEPTH 1146 # define YYMAXDEPTH 10000 1147 #endif 1148 1149 1150 1151 #if YYERROR_VERBOSE 1152 1153 # ifndef yystrlen 1154 # if defined __GLIBC__ && defined _STRING_H 1155 # define yystrlen strlen 1156 # else 1157 /* Return the length of YYSTR. */ 1158 #if (defined __STDC__ || defined __C99__FUNC__ \ 1159 || defined __cplusplus || defined _MSC_VER) 1160 static YYSIZE_T 1161 yystrlen (const char *yystr) 1162 #else 1163 static YYSIZE_T 1164 yystrlen (yystr) 1165 const char *yystr; 1166 #endif 1167 { 1168 YYSIZE_T yylen; 1169 for (yylen = 0; yystr[yylen]; yylen++) 1170 continue; 1171 return yylen; 1172 } 1173 # endif 1174 # endif 1175 1176 # ifndef yystpcpy 1177 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1178 # define yystpcpy stpcpy 1179 # else 1180 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1181 YYDEST. */ 1182 #if (defined __STDC__ || defined __C99__FUNC__ \ 1183 || defined __cplusplus || defined _MSC_VER) 1184 static char * 1185 yystpcpy (char *yydest, const char *yysrc) 1186 #else 1187 static char * 1188 yystpcpy (yydest, yysrc) 1189 char *yydest; 1190 const char *yysrc; 1191 #endif 1192 { 1193 char *yyd = yydest; 1194 const char *yys = yysrc; 1195 1196 while ((*yyd++ = *yys++) != '\0') 1197 continue; 1198 1199 return yyd - 1; 1200 } 1201 # endif 1202 # endif 1203 1204 # ifndef yytnamerr 1205 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1206 quotes and backslashes, so that it's suitable for yyerror. The 1207 heuristic is that double-quoting is unnecessary unless the string 1208 contains an apostrophe, a comma, or backslash (other than 1209 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1210 null, do not copy; instead, return the length of what the result 1211 would have been. */ 1212 static YYSIZE_T 1213 yytnamerr (char *yyres, const char *yystr) 1214 { 1215 if (*yystr == '"') 1216 { 1217 YYSIZE_T yyn = 0; 1218 char const *yyp = yystr; 1219 1220 for (;;) 1221 switch (*++yyp) 1222 { 1223 case '\'': 1224 case ',': 1225 goto do_not_strip_quotes; 1226 1227 case '\\': 1228 if (*++yyp != '\\') 1229 goto do_not_strip_quotes; 1230 /* Fall through. */ 1231 default: 1232 if (yyres) 1233 yyres[yyn] = *yyp; 1234 yyn++; 1235 break; 1236 1237 case '"': 1238 if (yyres) 1239 yyres[yyn] = '\0'; 1240 return yyn; 1241 } 1242 do_not_strip_quotes: ; 1243 } 1244 1245 if (! yyres) 1246 return yystrlen (yystr); 1247 1248 return yystpcpy (yyres, yystr) - yyres; 1249 } 1250 # endif 1251 1252 /* Copy into YYRESULT an error message about the unexpected token 1253 YYCHAR while in state YYSTATE. Return the number of bytes copied, 1254 including the terminating null byte. If YYRESULT is null, do not 1255 copy anything; just return the number of bytes that would be 1256 copied. As a special case, return 0 if an ordinary "syntax error" 1257 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1258 size calculation. */ 1259 static YYSIZE_T 1260 yysyntax_error (char *yyresult, int yystate, int yychar) 1261 { 1262 int yyn = yypact[yystate]; 1263 1264 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1265 return 0; 1266 else 1267 { 1268 int yytype = YYTRANSLATE (yychar); 1269 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1270 YYSIZE_T yysize = yysize0; 1271 YYSIZE_T yysize1; 1272 int yysize_overflow = 0; 1273 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1274 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1275 int yyx; 1276 1277 # if 0 1278 /* This is so xgettext sees the translatable formats that are 1279 constructed on the fly. */ 1280 YY_("syntax error, unexpected %s"); 1281 YY_("syntax error, unexpected %s, expecting %s"); 1282 YY_("syntax error, unexpected %s, expecting %s or %s"); 1283 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1284 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1285 # endif 1286 char *yyfmt; 1287 char const *yyf; 1288 static char const yyunexpected[] = "syntax error, unexpected %s"; 1289 static char const yyexpecting[] = ", expecting %s"; 1290 static char const yyor[] = " or %s"; 1291 char yyformat[sizeof yyunexpected 1292 + sizeof yyexpecting - 1 1293 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1294 * (sizeof yyor - 1))]; 1295 char const *yyprefix = yyexpecting; 1296 1297 /* Start YYX at -YYN if negative to avoid negative indexes in 1298 YYCHECK. */ 1299 int yyxbegin = yyn < 0 ? -yyn : 0; 1300 1301 /* Stay within bounds of both yycheck and yytname. */ 1302 int yychecklim = YYLAST - yyn + 1; 1303 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1304 int yycount = 1; 1305 1306 yyarg[0] = yytname[yytype]; 1307 yyfmt = yystpcpy (yyformat, yyunexpected); 1308 1309 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1310 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1311 { 1312 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1313 { 1314 yycount = 1; 1315 yysize = yysize0; 1316 yyformat[sizeof yyunexpected - 1] = '\0'; 1317 break; 1318 } 1319 yyarg[yycount++] = yytname[yyx]; 1320 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1321 yysize_overflow |= (yysize1 < yysize); 1322 yysize = yysize1; 1323 yyfmt = yystpcpy (yyfmt, yyprefix); 1324 yyprefix = yyor; 1325 } 1326 1327 yyf = YY_(yyformat); 1328 yysize1 = yysize + yystrlen (yyf); 1329 yysize_overflow |= (yysize1 < yysize); 1330 yysize = yysize1; 1331 1332 if (yysize_overflow) 1333 return YYSIZE_MAXIMUM; 1334 1335 if (yyresult) 1336 { 1337 /* Avoid sprintf, as that infringes on the user's name space. 1338 Don't have undefined behavior even if the translation 1339 produced a string with the wrong number of "%s"s. */ 1340 char *yyp = yyresult; 1341 int yyi = 0; 1342 while ((*yyp = *yyf) != '\0') 1343 { 1344 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1345 { 1346 yyp += yytnamerr (yyp, yyarg[yyi++]); 1347 yyf += 2; 1348 } 1349 else 1350 { 1351 yyp++; 1352 yyf++; 1353 } 1354 } 1355 } 1356 return yysize; 1357 } 1358 } 1359 #endif /* YYERROR_VERBOSE */ 1360 1361 1362 /*-----------------------------------------------. 1363 | Release the memory associated to this symbol. | 1364 `-----------------------------------------------*/ 1365 1366 /*ARGSUSED*/ 1367 #if (defined __STDC__ || defined __C99__FUNC__ \ 1368 || defined __cplusplus || defined _MSC_VER) 1369 static void 1370 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1371 #else 1372 static void 1373 yydestruct (yymsg, yytype, yyvaluep) 1374 const char *yymsg; 1375 int yytype; 1376 YYSTYPE *yyvaluep; 1377 #endif 1378 { 1379 YYUSE (yyvaluep); 1380 1381 if (!yymsg) 1382 yymsg = "Deleting"; 1383 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1384 1385 switch (yytype) 1386 { 1387 1388 default: 1389 break; 1390 } 1391 } 1392 1393 /* Prevent warnings from -Wmissing-prototypes. */ 1394 #ifdef YYPARSE_PARAM 1395 #if defined __STDC__ || defined __cplusplus 1396 int yyparse (void *YYPARSE_PARAM); 1397 #else 1398 int yyparse (); 1399 #endif 1400 #else /* ! YYPARSE_PARAM */ 1401 #if defined __STDC__ || defined __cplusplus 1402 int yyparse (void); 1403 #else 1404 int yyparse (); 1405 #endif 1406 #endif /* ! YYPARSE_PARAM */ 1407 1408 1409 /* The lookahead symbol. */ 1410 int yychar; 1411 1412 /* The semantic value of the lookahead symbol. */ 1413 YYSTYPE yylval; 1414 1415 /* Number of syntax errors so far. */ 1416 int yynerrs; 1417 1418 1419 1420 /*-------------------------. 1421 | yyparse or yypush_parse. | 1422 `-------------------------*/ 1423 1424 #ifdef YYPARSE_PARAM 1425 #if (defined __STDC__ || defined __C99__FUNC__ \ 1426 || defined __cplusplus || defined _MSC_VER) 1427 int 1428 yyparse (void *YYPARSE_PARAM) 1429 #else 1430 int 1431 yyparse (YYPARSE_PARAM) 1432 void *YYPARSE_PARAM; 1433 #endif 1434 #else /* ! YYPARSE_PARAM */ 1435 #if (defined __STDC__ || defined __C99__FUNC__ \ 1436 || defined __cplusplus || defined _MSC_VER) 1437 int 1438 yyparse (void) 1439 #else 1440 int 1441 yyparse () 1442 1443 #endif 1444 #endif 1445 { 1446 1447 1448 int yystate; 1449 /* Number of tokens to shift before error messages enabled. */ 1450 int yyerrstatus; 1451 1452 /* The stacks and their tools: 1453 `yyss': related to states. 1454 `yyvs': related to semantic values. 1455 1456 Refer to the stacks thru separate pointers, to allow yyoverflow 1457 to xreallocate them elsewhere. */ 1458 1459 /* The state stack. */ 1460 yytype_int16 yyssa[YYINITDEPTH]; 1461 yytype_int16 *yyss; 1462 yytype_int16 *yyssp; 1463 1464 /* The semantic value stack. */ 1465 YYSTYPE yyvsa[YYINITDEPTH]; 1466 YYSTYPE *yyvs; 1467 YYSTYPE *yyvsp; 1468 1469 YYSIZE_T yystacksize; 1470 1471 int yyn; 1472 int yyresult; 1473 /* Lookahead token as an internal (translated) token number. */ 1474 int yytoken; 1475 /* The variables used to return semantic value and location from the 1476 action routines. */ 1477 YYSTYPE yyval; 1478 1479 #if YYERROR_VERBOSE 1480 /* Buffer for error messages, and its allocated size. */ 1481 char yymsgbuf[128]; 1482 char *yymsg = yymsgbuf; 1483 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1484 #endif 1485 1486 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1487 1488 /* The number of symbols on the RHS of the reduced rule. 1489 Keep to zero when no symbol should be popped. */ 1490 int yylen = 0; 1491 1492 yytoken = 0; 1493 yyss = yyssa; 1494 yyvs = yyvsa; 1495 yystacksize = YYINITDEPTH; 1496 1497 YYDPRINTF ((stderr, "Starting parse\n")); 1498 1499 yystate = 0; 1500 yyerrstatus = 0; 1501 yynerrs = 0; 1502 yychar = YYEMPTY; /* Cause a token to be read. */ 1503 1504 /* Initialize stack pointers. 1505 Waste one element of value and location stack 1506 so that they stay on the same level as the state stack. 1507 The wasted elements are never initialized. */ 1508 yyssp = yyss; 1509 yyvsp = yyvs; 1510 1511 goto yysetstate; 1512 1513 /*------------------------------------------------------------. 1514 | yynewstate -- Push a new state, which is found in yystate. | 1515 `------------------------------------------------------------*/ 1516 yynewstate: 1517 /* In all cases, when you get here, the value and location stacks 1518 have just been pushed. So pushing a state here evens the stacks. */ 1519 yyssp++; 1520 1521 yysetstate: 1522 *yyssp = yystate; 1523 1524 if (yyss + yystacksize - 1 <= yyssp) 1525 { 1526 /* Get the current used size of the three stacks, in elements. */ 1527 YYSIZE_T yysize = yyssp - yyss + 1; 1528 1529 #ifdef yyoverflow 1530 { 1531 /* Give user a chance to xreallocate the stack. Use copies of 1532 these so that the &'s don't force the real ones into 1533 memory. */ 1534 YYSTYPE *yyvs1 = yyvs; 1535 yytype_int16 *yyss1 = yyss; 1536 1537 /* Each stack pointer address is followed by the size of the 1538 data in use in that stack, in bytes. This used to be a 1539 conditional around just the two extra args, but that might 1540 be undefined if yyoverflow is a macro. */ 1541 yyoverflow (YY_("memory exhausted"), 1542 &yyss1, yysize * sizeof (*yyssp), 1543 &yyvs1, yysize * sizeof (*yyvsp), 1544 &yystacksize); 1545 1546 yyss = yyss1; 1547 yyvs = yyvs1; 1548 } 1549 #else /* no yyoverflow */ 1550 # ifndef YYSTACK_RELOCATE 1551 goto yyexhaustedlab; 1552 # else 1553 /* Extend the stack our own way. */ 1554 if (YYMAXDEPTH <= yystacksize) 1555 goto yyexhaustedlab; 1556 yystacksize *= 2; 1557 if (YYMAXDEPTH < yystacksize) 1558 yystacksize = YYMAXDEPTH; 1559 1560 { 1561 yytype_int16 *yyss1 = yyss; 1562 union yyalloc *yyptr = 1563 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1564 if (! yyptr) 1565 goto yyexhaustedlab; 1566 YYSTACK_RELOCATE (yyss_alloc, yyss); 1567 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1568 # undef YYSTACK_RELOCATE 1569 if (yyss1 != yyssa) 1570 YYSTACK_FREE (yyss1); 1571 } 1572 # endif 1573 #endif /* no yyoverflow */ 1574 1575 yyssp = yyss + yysize - 1; 1576 yyvsp = yyvs + yysize - 1; 1577 1578 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1579 (unsigned long int) yystacksize)); 1580 1581 if (yyss + yystacksize - 1 <= yyssp) 1582 YYABORT; 1583 } 1584 1585 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1586 1587 if (yystate == YYFINAL) 1588 YYACCEPT; 1589 1590 goto yybackup; 1591 1592 /*-----------. 1593 | yybackup. | 1594 `-----------*/ 1595 yybackup: 1596 1597 /* Do appropriate processing given the current state. Read a 1598 lookahead token if we need one and don't already have one. */ 1599 1600 /* First try to decide what to do without reference to lookahead token. */ 1601 yyn = yypact[yystate]; 1602 if (yyn == YYPACT_NINF) 1603 goto yydefault; 1604 1605 /* Not known => get a lookahead token if don't already have one. */ 1606 1607 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1608 if (yychar == YYEMPTY) 1609 { 1610 YYDPRINTF ((stderr, "Reading a token: ")); 1611 yychar = YYLEX; 1612 } 1613 1614 if (yychar <= YYEOF) 1615 { 1616 yychar = yytoken = YYEOF; 1617 YYDPRINTF ((stderr, "Now at end of input.\n")); 1618 } 1619 else 1620 { 1621 yytoken = YYTRANSLATE (yychar); 1622 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1623 } 1624 1625 /* If the proper action on seeing token YYTOKEN is to reduce or to 1626 detect an error, take that action. */ 1627 yyn += yytoken; 1628 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1629 goto yydefault; 1630 yyn = yytable[yyn]; 1631 if (yyn <= 0) 1632 { 1633 if (yyn == 0 || yyn == YYTABLE_NINF) 1634 goto yyerrlab; 1635 yyn = -yyn; 1636 goto yyreduce; 1637 } 1638 1639 /* Count tokens shifted since error; after three, turn off error 1640 status. */ 1641 if (yyerrstatus) 1642 yyerrstatus--; 1643 1644 /* Shift the lookahead token. */ 1645 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1646 1647 /* Discard the shifted token. */ 1648 yychar = YYEMPTY; 1649 1650 yystate = yyn; 1651 *++yyvsp = yylval; 1652 1653 goto yynewstate; 1654 1655 1656 /*-----------------------------------------------------------. 1657 | yydefault -- do the default action for the current state. | 1658 `-----------------------------------------------------------*/ 1659 yydefault: 1660 yyn = yydefact[yystate]; 1661 if (yyn == 0) 1662 goto yyerrlab; 1663 goto yyreduce; 1664 1665 1666 /*-----------------------------. 1667 | yyreduce -- Do a reduction. | 1668 `-----------------------------*/ 1669 yyreduce: 1670 /* yyn is the number of a rule to reduce with. */ 1671 yylen = yyr2[yyn]; 1672 1673 /* If YYLEN is nonzero, implement the default value of the action: 1674 `$$ = $1'. 1675 1676 Otherwise, the following line sets YYVAL to garbage. 1677 This behavior is undocumented and Bison 1678 users should not rely upon it. Assigning to YYVAL 1679 unconditionally makes the parser a bit smaller, and it avoids a 1680 GCC warning that YYVAL may be used uninitialized. */ 1681 yyval = yyvsp[1-yylen]; 1682 1683 1684 YY_REDUCE_PRINT (yyn); 1685 switch (yyn) 1686 { 1687 case 4: 1688 1689 /* Line 1455 of yacc.c */ 1690 #line 242 "go-exp.y" 1691 { write_exp_elt_opcode(OP_TYPE); 1692 write_exp_elt_type((yyvsp[(1) - (1)].tval)); 1693 write_exp_elt_opcode(OP_TYPE); } 1694 break; 1695 1696 case 6: 1697 1698 /* Line 1455 of yacc.c */ 1699 #line 250 "go-exp.y" 1700 { write_exp_elt_opcode (BINOP_COMMA); } 1701 break; 1702 1703 case 7: 1704 1705 /* Line 1455 of yacc.c */ 1706 #line 255 "go-exp.y" 1707 { write_exp_elt_opcode (UNOP_IND); } 1708 break; 1709 1710 case 8: 1711 1712 /* Line 1455 of yacc.c */ 1713 #line 259 "go-exp.y" 1714 { write_exp_elt_opcode (UNOP_ADDR); } 1715 break; 1716 1717 case 9: 1718 1719 /* Line 1455 of yacc.c */ 1720 #line 263 "go-exp.y" 1721 { write_exp_elt_opcode (UNOP_NEG); } 1722 break; 1723 1724 case 10: 1725 1726 /* Line 1455 of yacc.c */ 1727 #line 267 "go-exp.y" 1728 { write_exp_elt_opcode (UNOP_PLUS); } 1729 break; 1730 1731 case 11: 1732 1733 /* Line 1455 of yacc.c */ 1734 #line 271 "go-exp.y" 1735 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } 1736 break; 1737 1738 case 12: 1739 1740 /* Line 1455 of yacc.c */ 1741 #line 275 "go-exp.y" 1742 { write_exp_elt_opcode (UNOP_COMPLEMENT); } 1743 break; 1744 1745 case 13: 1746 1747 /* Line 1455 of yacc.c */ 1748 #line 279 "go-exp.y" 1749 { write_exp_elt_opcode (UNOP_POSTINCREMENT); } 1750 break; 1751 1752 case 14: 1753 1754 /* Line 1455 of yacc.c */ 1755 #line 283 "go-exp.y" 1756 { write_exp_elt_opcode (UNOP_POSTDECREMENT); } 1757 break; 1758 1759 case 15: 1760 1761 /* Line 1455 of yacc.c */ 1762 #line 289 "go-exp.y" 1763 { write_exp_elt_opcode (STRUCTOP_STRUCT); 1764 write_exp_string ((yyvsp[(3) - (3)].ssym).stoken); 1765 write_exp_elt_opcode (STRUCTOP_STRUCT); } 1766 break; 1767 1768 case 16: 1769 1770 /* Line 1455 of yacc.c */ 1771 #line 295 "go-exp.y" 1772 { mark_struct_expression (); 1773 write_exp_elt_opcode (STRUCTOP_STRUCT); 1774 write_exp_string ((yyvsp[(3) - (4)].ssym).stoken); 1775 write_exp_elt_opcode (STRUCTOP_STRUCT); } 1776 break; 1777 1778 case 17: 1779 1780 /* Line 1455 of yacc.c */ 1781 #line 302 "go-exp.y" 1782 { struct stoken s; 1783 mark_struct_expression (); 1784 write_exp_elt_opcode (STRUCTOP_STRUCT); 1785 s.ptr = ""; 1786 s.length = 0; 1787 write_exp_string (s); 1788 write_exp_elt_opcode (STRUCTOP_STRUCT); } 1789 break; 1790 1791 case 18: 1792 1793 /* Line 1455 of yacc.c */ 1794 #line 312 "go-exp.y" 1795 { write_exp_elt_opcode (BINOP_SUBSCRIPT); } 1796 break; 1797 1798 case 19: 1799 1800 /* Line 1455 of yacc.c */ 1801 #line 318 "go-exp.y" 1802 { start_arglist (); } 1803 break; 1804 1805 case 20: 1806 1807 /* Line 1455 of yacc.c */ 1808 #line 320 "go-exp.y" 1809 { write_exp_elt_opcode (OP_FUNCALL); 1810 write_exp_elt_longcst ((LONGEST) end_arglist ()); 1811 write_exp_elt_opcode (OP_FUNCALL); } 1812 break; 1813 1814 case 21: 1815 1816 /* Line 1455 of yacc.c */ 1817 #line 326 "go-exp.y" 1818 { start_arglist (); } 1819 break; 1820 1821 case 23: 1822 1823 /* Line 1455 of yacc.c */ 1824 #line 333 "go-exp.y" 1825 { arglist_len = 1; } 1826 break; 1827 1828 case 24: 1829 1830 /* Line 1455 of yacc.c */ 1831 #line 337 "go-exp.y" 1832 { arglist_len++; } 1833 break; 1834 1835 case 25: 1836 1837 /* Line 1455 of yacc.c */ 1838 #line 341 "go-exp.y" 1839 { (yyval.lval) = end_arglist () - 1; } 1840 break; 1841 1842 case 26: 1843 1844 /* Line 1455 of yacc.c */ 1845 #line 345 "go-exp.y" 1846 { write_exp_elt_opcode (UNOP_MEMVAL); 1847 write_exp_elt_type ((yyvsp[(2) - (4)].tval)); 1848 write_exp_elt_opcode (UNOP_MEMVAL); } 1849 break; 1850 1851 case 27: 1852 1853 /* Line 1455 of yacc.c */ 1854 #line 351 "go-exp.y" 1855 { write_exp_elt_opcode (UNOP_CAST); 1856 write_exp_elt_type ((yyvsp[(1) - (4)].tval)); 1857 write_exp_elt_opcode (UNOP_CAST); } 1858 break; 1859 1860 case 28: 1861 1862 /* Line 1455 of yacc.c */ 1863 #line 357 "go-exp.y" 1864 { } 1865 break; 1866 1867 case 29: 1868 1869 /* Line 1455 of yacc.c */ 1870 #line 363 "go-exp.y" 1871 { write_exp_elt_opcode (BINOP_REPEAT); } 1872 break; 1873 1874 case 30: 1875 1876 /* Line 1455 of yacc.c */ 1877 #line 367 "go-exp.y" 1878 { write_exp_elt_opcode (BINOP_MUL); } 1879 break; 1880 1881 case 31: 1882 1883 /* Line 1455 of yacc.c */ 1884 #line 371 "go-exp.y" 1885 { write_exp_elt_opcode (BINOP_DIV); } 1886 break; 1887 1888 case 32: 1889 1890 /* Line 1455 of yacc.c */ 1891 #line 375 "go-exp.y" 1892 { write_exp_elt_opcode (BINOP_REM); } 1893 break; 1894 1895 case 33: 1896 1897 /* Line 1455 of yacc.c */ 1898 #line 379 "go-exp.y" 1899 { write_exp_elt_opcode (BINOP_ADD); } 1900 break; 1901 1902 case 34: 1903 1904 /* Line 1455 of yacc.c */ 1905 #line 383 "go-exp.y" 1906 { write_exp_elt_opcode (BINOP_SUB); } 1907 break; 1908 1909 case 35: 1910 1911 /* Line 1455 of yacc.c */ 1912 #line 387 "go-exp.y" 1913 { write_exp_elt_opcode (BINOP_LSH); } 1914 break; 1915 1916 case 36: 1917 1918 /* Line 1455 of yacc.c */ 1919 #line 391 "go-exp.y" 1920 { write_exp_elt_opcode (BINOP_RSH); } 1921 break; 1922 1923 case 37: 1924 1925 /* Line 1455 of yacc.c */ 1926 #line 395 "go-exp.y" 1927 { write_exp_elt_opcode (BINOP_EQUAL); } 1928 break; 1929 1930 case 38: 1931 1932 /* Line 1455 of yacc.c */ 1933 #line 399 "go-exp.y" 1934 { write_exp_elt_opcode (BINOP_NOTEQUAL); } 1935 break; 1936 1937 case 39: 1938 1939 /* Line 1455 of yacc.c */ 1940 #line 403 "go-exp.y" 1941 { write_exp_elt_opcode (BINOP_LEQ); } 1942 break; 1943 1944 case 40: 1945 1946 /* Line 1455 of yacc.c */ 1947 #line 407 "go-exp.y" 1948 { write_exp_elt_opcode (BINOP_GEQ); } 1949 break; 1950 1951 case 41: 1952 1953 /* Line 1455 of yacc.c */ 1954 #line 411 "go-exp.y" 1955 { write_exp_elt_opcode (BINOP_LESS); } 1956 break; 1957 1958 case 42: 1959 1960 /* Line 1455 of yacc.c */ 1961 #line 415 "go-exp.y" 1962 { write_exp_elt_opcode (BINOP_GTR); } 1963 break; 1964 1965 case 43: 1966 1967 /* Line 1455 of yacc.c */ 1968 #line 419 "go-exp.y" 1969 { write_exp_elt_opcode (BINOP_BITWISE_AND); } 1970 break; 1971 1972 case 44: 1973 1974 /* Line 1455 of yacc.c */ 1975 #line 423 "go-exp.y" 1976 { write_exp_elt_opcode (BINOP_BITWISE_XOR); } 1977 break; 1978 1979 case 45: 1980 1981 /* Line 1455 of yacc.c */ 1982 #line 427 "go-exp.y" 1983 { write_exp_elt_opcode (BINOP_BITWISE_IOR); } 1984 break; 1985 1986 case 46: 1987 1988 /* Line 1455 of yacc.c */ 1989 #line 431 "go-exp.y" 1990 { write_exp_elt_opcode (BINOP_LOGICAL_AND); } 1991 break; 1992 1993 case 47: 1994 1995 /* Line 1455 of yacc.c */ 1996 #line 435 "go-exp.y" 1997 { write_exp_elt_opcode (BINOP_LOGICAL_OR); } 1998 break; 1999 2000 case 48: 2001 2002 /* Line 1455 of yacc.c */ 2003 #line 439 "go-exp.y" 2004 { write_exp_elt_opcode (TERNOP_COND); } 2005 break; 2006 2007 case 49: 2008 2009 /* Line 1455 of yacc.c */ 2010 #line 443 "go-exp.y" 2011 { write_exp_elt_opcode (BINOP_ASSIGN); } 2012 break; 2013 2014 case 50: 2015 2016 /* Line 1455 of yacc.c */ 2017 #line 447 "go-exp.y" 2018 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); 2019 write_exp_elt_opcode ((yyvsp[(2) - (3)].opcode)); 2020 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } 2021 break; 2022 2023 case 51: 2024 2025 /* Line 1455 of yacc.c */ 2026 #line 453 "go-exp.y" 2027 { write_exp_elt_opcode (OP_LONG); 2028 write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_int).type); 2029 write_exp_elt_longcst ((LONGEST)((yyvsp[(1) - (1)].typed_val_int).val)); 2030 write_exp_elt_opcode (OP_LONG); } 2031 break; 2032 2033 case 52: 2034 2035 /* Line 1455 of yacc.c */ 2036 #line 460 "go-exp.y" 2037 { 2038 struct stoken_vector vec; 2039 vec.len = 1; 2040 vec.tokens = &(yyvsp[(1) - (1)].tsval); 2041 write_exp_string_vector ((yyvsp[(1) - (1)].tsval).type, &vec); 2042 } 2043 break; 2044 2045 case 53: 2046 2047 /* Line 1455 of yacc.c */ 2048 #line 469 "go-exp.y" 2049 { YYSTYPE val; 2050 parse_number ((yyvsp[(1) - (1)].ssym).stoken.ptr, (yyvsp[(1) - (1)].ssym).stoken.length, 2051 0, &val); 2052 write_exp_elt_opcode (OP_LONG); 2053 write_exp_elt_type (val.typed_val_int.type); 2054 write_exp_elt_longcst ((LONGEST) 2055 val.typed_val_int.val); 2056 write_exp_elt_opcode (OP_LONG); 2057 } 2058 break; 2059 2060 case 54: 2061 2062 /* Line 1455 of yacc.c */ 2063 #line 482 "go-exp.y" 2064 { write_exp_elt_opcode (OP_DOUBLE); 2065 write_exp_elt_type ((yyvsp[(1) - (1)].typed_val_float).type); 2066 write_exp_elt_dblcst ((yyvsp[(1) - (1)].typed_val_float).dval); 2067 write_exp_elt_opcode (OP_DOUBLE); } 2068 break; 2069 2070 case 56: 2071 2072 /* Line 1455 of yacc.c */ 2073 #line 492 "go-exp.y" 2074 { 2075 write_dollar_variable ((yyvsp[(1) - (1)].sval)); 2076 } 2077 break; 2078 2079 case 57: 2080 2081 /* Line 1455 of yacc.c */ 2082 #line 498 "go-exp.y" 2083 { 2084 /* TODO(dje): Go objects in structs. */ 2085 write_exp_elt_opcode (OP_LONG); 2086 /* TODO(dje): What's the right type here? */ 2087 write_exp_elt_type (parse_type->builtin_unsigned_int); 2088 CHECK_TYPEDEF ((yyvsp[(3) - (4)].tval)); 2089 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ((yyvsp[(3) - (4)].tval))); 2090 write_exp_elt_opcode (OP_LONG); 2091 } 2092 break; 2093 2094 case 58: 2095 2096 /* Line 1455 of yacc.c */ 2097 #line 510 "go-exp.y" 2098 { 2099 /* TODO(dje): Go objects in structs. */ 2100 write_exp_elt_opcode (UNOP_SIZEOF); 2101 } 2102 break; 2103 2104 case 59: 2105 2106 /* Line 1455 of yacc.c */ 2107 #line 517 "go-exp.y" 2108 { 2109 /* We copy the string here, and not in the 2110 lexer, to guarantee that we do not leak a 2111 string. */ 2112 /* Note that we NUL-terminate here, but just 2113 for convenience. */ 2114 struct typed_stoken *vec = XNEW (struct typed_stoken); 2115 (yyval.svec).len = 1; 2116 (yyval.svec).tokens = vec; 2117 2118 vec->type = (yyvsp[(1) - (1)].tsval).type; 2119 vec->length = (yyvsp[(1) - (1)].tsval).length; 2120 vec->ptr = xmalloc ((yyvsp[(1) - (1)].tsval).length + 1); 2121 memcpy (vec->ptr, (yyvsp[(1) - (1)].tsval).ptr, (yyvsp[(1) - (1)].tsval).length + 1); 2122 } 2123 break; 2124 2125 case 60: 2126 2127 /* Line 1455 of yacc.c */ 2128 #line 534 "go-exp.y" 2129 { 2130 /* Note that we NUL-terminate here, but just 2131 for convenience. */ 2132 char *p; 2133 ++(yyval.svec).len; 2134 (yyval.svec).tokens = xrealloc ((yyval.svec).tokens, 2135 (yyval.svec).len * sizeof (struct typed_stoken)); 2136 2137 p = xmalloc ((yyvsp[(3) - (3)].tsval).length + 1); 2138 memcpy (p, (yyvsp[(3) - (3)].tsval).ptr, (yyvsp[(3) - (3)].tsval).length + 1); 2139 2140 (yyval.svec).tokens[(yyval.svec).len - 1].type = (yyvsp[(3) - (3)].tsval).type; 2141 (yyval.svec).tokens[(yyval.svec).len - 1].length = (yyvsp[(3) - (3)].tsval).length; 2142 (yyval.svec).tokens[(yyval.svec).len - 1].ptr = p; 2143 } 2144 break; 2145 2146 case 61: 2147 2148 /* Line 1455 of yacc.c */ 2149 #line 552 "go-exp.y" 2150 { 2151 int i; 2152 2153 write_exp_string_vector (0 /*always utf8*/, &(yyvsp[(1) - (1)].svec)); 2154 for (i = 0; i < (yyvsp[(1) - (1)].svec).len; ++i) 2155 xfree ((yyvsp[(1) - (1)].svec).tokens[i].ptr); 2156 xfree ((yyvsp[(1) - (1)].svec).tokens); 2157 } 2158 break; 2159 2160 case 62: 2161 2162 /* Line 1455 of yacc.c */ 2163 #line 563 "go-exp.y" 2164 { write_exp_elt_opcode (OP_BOOL); 2165 write_exp_elt_longcst ((LONGEST) (yyvsp[(1) - (1)].lval)); 2166 write_exp_elt_opcode (OP_BOOL); } 2167 break; 2168 2169 case 63: 2170 2171 /* Line 1455 of yacc.c */ 2172 #line 569 "go-exp.y" 2173 { write_exp_elt_opcode (OP_BOOL); 2174 write_exp_elt_longcst ((LONGEST) (yyvsp[(1) - (1)].lval)); 2175 write_exp_elt_opcode (OP_BOOL); } 2176 break; 2177 2178 case 64: 2179 2180 /* Line 1455 of yacc.c */ 2181 #line 575 "go-exp.y" 2182 { struct symbol *sym = (yyvsp[(1) - (2)].ssym).sym; 2183 2184 if (sym == NULL 2185 || !SYMBOL_IS_ARGUMENT (sym) 2186 || !symbol_read_needs_frame (sym)) 2187 error (_("@entry can be used only for function " 2188 "parameters, not for \"%s\""), 2189 copy_name ((yyvsp[(1) - (2)].ssym).stoken)); 2190 2191 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); 2192 write_exp_elt_sym (sym); 2193 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); 2194 } 2195 break; 2196 2197 case 65: 2198 2199 /* Line 1455 of yacc.c */ 2200 #line 591 "go-exp.y" 2201 { struct symbol *sym = (yyvsp[(1) - (1)].ssym).sym; 2202 2203 if (sym) 2204 { 2205 if (symbol_read_needs_frame (sym)) 2206 { 2207 if (innermost_block == 0 2208 || contained_in (block_found, 2209 innermost_block)) 2210 innermost_block = block_found; 2211 } 2212 2213 write_exp_elt_opcode (OP_VAR_VALUE); 2214 /* We want to use the selected frame, not 2215 another more inner frame which happens to 2216 be in the same block. */ 2217 write_exp_elt_block (NULL); 2218 write_exp_elt_sym (sym); 2219 write_exp_elt_opcode (OP_VAR_VALUE); 2220 } 2221 else if ((yyvsp[(1) - (1)].ssym).is_a_field_of_this) 2222 { 2223 /* TODO(dje): Can we get here? 2224 E.g., via a mix of c++ and go? */ 2225 gdb_assert_not_reached ("go with `this' field"); 2226 } 2227 else 2228 { 2229 struct minimal_symbol *msymbol; 2230 char *arg = copy_name ((yyvsp[(1) - (1)].ssym).stoken); 2231 2232 msymbol = 2233 lookup_minimal_symbol (arg, NULL, NULL); 2234 if (msymbol != NULL) 2235 write_exp_msymbol (msymbol); 2236 else if (!have_full_symbols () 2237 && !have_partial_symbols ()) 2238 error (_("No symbol table is loaded. " 2239 "Use the \"file\" command.")); 2240 else 2241 error (_("No symbol \"%s\" in current context."), 2242 copy_name ((yyvsp[(1) - (1)].ssym).stoken)); 2243 } 2244 } 2245 break; 2246 2247 case 66: 2248 2249 /* Line 1455 of yacc.c */ 2250 #line 646 "go-exp.y" 2251 { (yyval.tval) = lookup_pointer_type ((yyvsp[(2) - (2)].tval)); } 2252 break; 2253 2254 case 67: 2255 2256 /* Line 1455 of yacc.c */ 2257 #line 648 "go-exp.y" 2258 { (yyval.tval) = (yyvsp[(1) - (1)].tsym).type; } 2259 break; 2260 2261 case 68: 2262 2263 /* Line 1455 of yacc.c */ 2264 #line 655 "go-exp.y" 2265 { (yyval.tval) = builtin_go_type (parse_gdbarch) 2266 ->builtin_uint8; } 2267 break; 2268 2269 2270 2271 /* Line 1455 of yacc.c */ 2272 #line 2274 "go-exp.c" 2273 default: break; 2274 } 2275 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2276 2277 YYPOPSTACK (yylen); 2278 yylen = 0; 2279 YY_STACK_PRINT (yyss, yyssp); 2280 2281 *++yyvsp = yyval; 2282 2283 /* Now `shift' the result of the reduction. Determine what state 2284 that goes to, based on the state we popped back to and the rule 2285 number reduced by. */ 2286 2287 yyn = yyr1[yyn]; 2288 2289 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2290 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2291 yystate = yytable[yystate]; 2292 else 2293 yystate = yydefgoto[yyn - YYNTOKENS]; 2294 2295 goto yynewstate; 2296 2297 2298 /*------------------------------------. 2299 | yyerrlab -- here on detecting error | 2300 `------------------------------------*/ 2301 yyerrlab: 2302 /* If not already recovering from an error, report this error. */ 2303 if (!yyerrstatus) 2304 { 2305 ++yynerrs; 2306 #if ! YYERROR_VERBOSE 2307 yyerror (YY_("syntax error")); 2308 #else 2309 { 2310 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 2311 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 2312 { 2313 YYSIZE_T yyalloc = 2 * yysize; 2314 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 2315 yyalloc = YYSTACK_ALLOC_MAXIMUM; 2316 if (yymsg != yymsgbuf) 2317 YYSTACK_FREE (yymsg); 2318 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 2319 if (yymsg) 2320 yymsg_alloc = yyalloc; 2321 else 2322 { 2323 yymsg = yymsgbuf; 2324 yymsg_alloc = sizeof yymsgbuf; 2325 } 2326 } 2327 2328 if (0 < yysize && yysize <= yymsg_alloc) 2329 { 2330 (void) yysyntax_error (yymsg, yystate, yychar); 2331 yyerror (yymsg); 2332 } 2333 else 2334 { 2335 yyerror (YY_("syntax error")); 2336 if (yysize != 0) 2337 goto yyexhaustedlab; 2338 } 2339 } 2340 #endif 2341 } 2342 2343 2344 2345 if (yyerrstatus == 3) 2346 { 2347 /* If just tried and failed to reuse lookahead token after an 2348 error, discard it. */ 2349 2350 if (yychar <= YYEOF) 2351 { 2352 /* Return failure if at end of input. */ 2353 if (yychar == YYEOF) 2354 YYABORT; 2355 } 2356 else 2357 { 2358 yydestruct ("Error: discarding", 2359 yytoken, &yylval); 2360 yychar = YYEMPTY; 2361 } 2362 } 2363 2364 /* Else will try to reuse lookahead token after shifting the error 2365 token. */ 2366 goto yyerrlab1; 2367 2368 2369 /*---------------------------------------------------. 2370 | yyerrorlab -- error raised explicitly by YYERROR. | 2371 `---------------------------------------------------*/ 2372 yyerrorlab: 2373 2374 /* Pacify compilers like GCC when the user code never invokes 2375 YYERROR and the label yyerrorlab therefore never appears in user 2376 code. */ 2377 if (/*CONSTCOND*/ 0) 2378 goto yyerrorlab; 2379 2380 /* Do not reclaim the symbols of the rule which action triggered 2381 this YYERROR. */ 2382 YYPOPSTACK (yylen); 2383 yylen = 0; 2384 YY_STACK_PRINT (yyss, yyssp); 2385 yystate = *yyssp; 2386 goto yyerrlab1; 2387 2388 2389 /*-------------------------------------------------------------. 2390 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2391 `-------------------------------------------------------------*/ 2392 yyerrlab1: 2393 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2394 2395 for (;;) 2396 { 2397 yyn = yypact[yystate]; 2398 if (yyn != YYPACT_NINF) 2399 { 2400 yyn += YYTERROR; 2401 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2402 { 2403 yyn = yytable[yyn]; 2404 if (0 < yyn) 2405 break; 2406 } 2407 } 2408 2409 /* Pop the current state because it cannot handle the error token. */ 2410 if (yyssp == yyss) 2411 YYABORT; 2412 2413 2414 yydestruct ("Error: popping", 2415 yystos[yystate], yyvsp); 2416 YYPOPSTACK (1); 2417 yystate = *yyssp; 2418 YY_STACK_PRINT (yyss, yyssp); 2419 } 2420 2421 *++yyvsp = yylval; 2422 2423 2424 /* Shift the error token. */ 2425 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2426 2427 yystate = yyn; 2428 goto yynewstate; 2429 2430 2431 /*-------------------------------------. 2432 | yyacceptlab -- YYACCEPT comes here. | 2433 `-------------------------------------*/ 2434 yyacceptlab: 2435 yyresult = 0; 2436 goto yyreturn; 2437 2438 /*-----------------------------------. 2439 | yyabortlab -- YYABORT comes here. | 2440 `-----------------------------------*/ 2441 yyabortlab: 2442 yyresult = 1; 2443 goto yyreturn; 2444 2445 #if !defined(yyoverflow) || YYERROR_VERBOSE 2446 /*-------------------------------------------------. 2447 | yyexhaustedlab -- memory exhaustion comes here. | 2448 `-------------------------------------------------*/ 2449 yyexhaustedlab: 2450 yyerror (YY_("memory exhausted")); 2451 yyresult = 2; 2452 /* Fall through. */ 2453 #endif 2454 2455 yyreturn: 2456 if (yychar != YYEMPTY) 2457 yydestruct ("Cleanup: discarding lookahead", 2458 yytoken, &yylval); 2459 /* Do not reclaim the symbols of the rule which action triggered 2460 this YYABORT or YYACCEPT. */ 2461 YYPOPSTACK (yylen); 2462 YY_STACK_PRINT (yyss, yyssp); 2463 while (yyssp != yyss) 2464 { 2465 yydestruct ("Cleanup: popping", 2466 yystos[*yyssp], yyvsp); 2467 YYPOPSTACK (1); 2468 } 2469 #ifndef yyoverflow 2470 if (yyss != yyssa) 2471 YYSTACK_FREE (yyss); 2472 #endif 2473 #if YYERROR_VERBOSE 2474 if (yymsg != yymsgbuf) 2475 YYSTACK_FREE (yymsg); 2476 #endif 2477 /* Make sure YYID is used. */ 2478 return YYID (yyresult); 2479 } 2480 2481 2482 2483 /* Line 1675 of yacc.c */ 2484 #line 677 "go-exp.y" 2485 2486 2487 /* Wrapper on parse_c_float to get the type right for Go. */ 2488 2489 static int 2490 parse_go_float (struct gdbarch *gdbarch, const char *p, int len, 2491 DOUBLEST *d, struct type **t) 2492 { 2493 int result = parse_c_float (gdbarch, p, len, d, t); 2494 const struct builtin_type *builtin_types = builtin_type (gdbarch); 2495 const struct builtin_go_type *builtin_go_types = builtin_go_type (gdbarch); 2496 2497 if (*t == builtin_types->builtin_float) 2498 *t = builtin_go_types->builtin_float32; 2499 else if (*t == builtin_types->builtin_double) 2500 *t = builtin_go_types->builtin_float64; 2501 2502 return result; 2503 } 2504 2505 /* Take care of parsing a number (anything that starts with a digit). 2506 Set yylval and return the token type; update lexptr. 2507 LEN is the number of characters in it. */ 2508 2509 /* FIXME: Needs some error checking for the float case. */ 2510 /* FIXME(dje): IWBN to use c-exp.y's parse_number if we could. 2511 That will require moving the guts into a function that we both call 2512 as our YYSTYPE is different than c-exp.y's */ 2513 2514 static int 2515 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) 2516 { 2517 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values 2518 here, and we do kind of silly things like cast to unsigned. */ 2519 LONGEST n = 0; 2520 LONGEST prevn = 0; 2521 ULONGEST un; 2522 2523 int i = 0; 2524 int c; 2525 int base = input_radix; 2526 int unsigned_p = 0; 2527 2528 /* Number of "L" suffixes encountered. */ 2529 int long_p = 0; 2530 2531 /* We have found a "L" or "U" suffix. */ 2532 int found_suffix = 0; 2533 2534 ULONGEST high_bit; 2535 struct type *signed_type; 2536 struct type *unsigned_type; 2537 2538 if (parsed_float) 2539 { 2540 if (! parse_go_float (parse_gdbarch, p, len, 2541 &putithere->typed_val_float.dval, 2542 &putithere->typed_val_float.type)) 2543 return ERROR; 2544 return FLOAT; 2545 } 2546 2547 /* Handle base-switching prefixes 0x, 0t, 0d, 0. */ 2548 if (p[0] == '0') 2549 switch (p[1]) 2550 { 2551 case 'x': 2552 case 'X': 2553 if (len >= 3) 2554 { 2555 p += 2; 2556 base = 16; 2557 len -= 2; 2558 } 2559 break; 2560 2561 case 'b': 2562 case 'B': 2563 if (len >= 3) 2564 { 2565 p += 2; 2566 base = 2; 2567 len -= 2; 2568 } 2569 break; 2570 2571 case 't': 2572 case 'T': 2573 case 'd': 2574 case 'D': 2575 if (len >= 3) 2576 { 2577 p += 2; 2578 base = 10; 2579 len -= 2; 2580 } 2581 break; 2582 2583 default: 2584 base = 8; 2585 break; 2586 } 2587 2588 while (len-- > 0) 2589 { 2590 c = *p++; 2591 if (c >= 'A' && c <= 'Z') 2592 c += 'a' - 'A'; 2593 if (c != 'l' && c != 'u') 2594 n *= base; 2595 if (c >= '0' && c <= '9') 2596 { 2597 if (found_suffix) 2598 return ERROR; 2599 n += i = c - '0'; 2600 } 2601 else 2602 { 2603 if (base > 10 && c >= 'a' && c <= 'f') 2604 { 2605 if (found_suffix) 2606 return ERROR; 2607 n += i = c - 'a' + 10; 2608 } 2609 else if (c == 'l') 2610 { 2611 ++long_p; 2612 found_suffix = 1; 2613 } 2614 else if (c == 'u') 2615 { 2616 unsigned_p = 1; 2617 found_suffix = 1; 2618 } 2619 else 2620 return ERROR; /* Char not a digit */ 2621 } 2622 if (i >= base) 2623 return ERROR; /* Invalid digit in this base. */ 2624 2625 /* Portably test for overflow (only works for nonzero values, so make 2626 a second check for zero). FIXME: Can't we just make n and prevn 2627 unsigned and avoid this? */ 2628 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0) 2629 unsigned_p = 1; /* Try something unsigned. */ 2630 2631 /* Portably test for unsigned overflow. 2632 FIXME: This check is wrong; for example it doesn't find overflow 2633 on 0x123456789 when LONGEST is 32 bits. */ 2634 if (c != 'l' && c != 'u' && n != 0) 2635 { 2636 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n)) 2637 error (_("Numeric constant too large.")); 2638 } 2639 prevn = n; 2640 } 2641 2642 /* An integer constant is an int, a long, or a long long. An L 2643 suffix forces it to be long; an LL suffix forces it to be long 2644 long. If not forced to a larger size, it gets the first type of 2645 the above that it fits in. To figure out whether it fits, we 2646 shift it right and see whether anything remains. Note that we 2647 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one 2648 operation, because many compilers will warn about such a shift 2649 (which always produces a zero result). Sometimes gdbarch_int_bit 2650 or gdbarch_long_bit will be that big, sometimes not. To deal with 2651 the case where it is we just always shift the value more than 2652 once, with fewer bits each time. */ 2653 2654 un = (ULONGEST)n >> 2; 2655 if (long_p == 0 2656 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0) 2657 { 2658 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1); 2659 2660 /* A large decimal (not hex or octal) constant (between INT_MAX 2661 and UINT_MAX) is a long or unsigned long, according to ANSI, 2662 never an unsigned int, but this code treats it as unsigned 2663 int. This probably should be fixed. GCC gives a warning on 2664 such constants. */ 2665 2666 unsigned_type = parse_type->builtin_unsigned_int; 2667 signed_type = parse_type->builtin_int; 2668 } 2669 else if (long_p <= 1 2670 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0) 2671 { 2672 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1); 2673 unsigned_type = parse_type->builtin_unsigned_long; 2674 signed_type = parse_type->builtin_long; 2675 } 2676 else 2677 { 2678 int shift; 2679 if (sizeof (ULONGEST) * HOST_CHAR_BIT 2680 < gdbarch_long_long_bit (parse_gdbarch)) 2681 /* A long long does not fit in a LONGEST. */ 2682 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1); 2683 else 2684 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1); 2685 high_bit = (ULONGEST) 1 << shift; 2686 unsigned_type = parse_type->builtin_unsigned_long_long; 2687 signed_type = parse_type->builtin_long_long; 2688 } 2689 2690 putithere->typed_val_int.val = n; 2691 2692 /* If the high bit of the worked out type is set then this number 2693 has to be unsigned. */ 2694 2695 if (unsigned_p || (n & high_bit)) 2696 { 2697 putithere->typed_val_int.type = unsigned_type; 2698 } 2699 else 2700 { 2701 putithere->typed_val_int.type = signed_type; 2702 } 2703 2704 return INT; 2705 } 2706 2707 /* Temporary obstack used for holding strings. */ 2708 static struct obstack tempbuf; 2709 static int tempbuf_init; 2710 2711 /* Parse a string or character literal from TOKPTR. The string or 2712 character may be wide or unicode. *OUTPTR is set to just after the 2713 end of the literal in the input string. The resulting token is 2714 stored in VALUE. This returns a token value, either STRING or 2715 CHAR, depending on what was parsed. *HOST_CHARS is set to the 2716 number of host characters in the literal. */ 2717 2718 static int 2719 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value, 2720 int *host_chars) 2721 { 2722 int quote; 2723 2724 /* Build the gdb internal form of the input string in tempbuf. Note 2725 that the buffer is null byte terminated *only* for the 2726 convenience of debugging gdb itself and printing the buffer 2727 contents when the buffer contains no embedded nulls. Gdb does 2728 not depend upon the buffer being null byte terminated, it uses 2729 the length string instead. This allows gdb to handle C strings 2730 (as well as strings in other languages) with embedded null 2731 bytes */ 2732 2733 if (!tempbuf_init) 2734 tempbuf_init = 1; 2735 else 2736 obstack_free (&tempbuf, NULL); 2737 obstack_init (&tempbuf); 2738 2739 /* Skip the quote. */ 2740 quote = *tokptr; 2741 ++tokptr; 2742 2743 *host_chars = 0; 2744 2745 while (*tokptr) 2746 { 2747 char c = *tokptr; 2748 if (c == '\\') 2749 { 2750 ++tokptr; 2751 *host_chars += c_parse_escape (&tokptr, &tempbuf); 2752 } 2753 else if (c == quote) 2754 break; 2755 else 2756 { 2757 obstack_1grow (&tempbuf, c); 2758 ++tokptr; 2759 /* FIXME: this does the wrong thing with multi-byte host 2760 characters. We could use mbrlen here, but that would 2761 make "set host-charset" a bit less useful. */ 2762 ++*host_chars; 2763 } 2764 } 2765 2766 if (*tokptr != quote) 2767 { 2768 if (quote == '"') 2769 error (_("Unterminated string in expression.")); 2770 else 2771 error (_("Unmatched single quote.")); 2772 } 2773 ++tokptr; 2774 2775 value->type = C_STRING | (quote == '\'' ? C_CHAR : 0); /*FIXME*/ 2776 value->ptr = obstack_base (&tempbuf); 2777 value->length = obstack_object_size (&tempbuf); 2778 2779 *outptr = tokptr; 2780 2781 return quote == '\'' ? CHAR : STRING; 2782 } 2783 2784 struct token 2785 { 2786 char *operator; 2787 int token; 2788 enum exp_opcode opcode; 2789 }; 2790 2791 static const struct token tokentab3[] = 2792 { 2793 {">>=", ASSIGN_MODIFY, BINOP_RSH}, 2794 {"<<=", ASSIGN_MODIFY, BINOP_LSH}, 2795 /*{"&^=", ASSIGN_MODIFY, BINOP_BITWISE_ANDNOT}, TODO */ 2796 {"...", DOTDOTDOT, OP_NULL}, 2797 }; 2798 2799 static const struct token tokentab2[] = 2800 { 2801 {"+=", ASSIGN_MODIFY, BINOP_ADD}, 2802 {"-=", ASSIGN_MODIFY, BINOP_SUB}, 2803 {"*=", ASSIGN_MODIFY, BINOP_MUL}, 2804 {"/=", ASSIGN_MODIFY, BINOP_DIV}, 2805 {"%=", ASSIGN_MODIFY, BINOP_REM}, 2806 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR}, 2807 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, 2808 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, 2809 {"++", INCREMENT, BINOP_END}, 2810 {"--", DECREMENT, BINOP_END}, 2811 /*{"->", RIGHT_ARROW, BINOP_END}, Doesn't exist in Go. */ 2812 {"<-", LEFT_ARROW, BINOP_END}, 2813 {"&&", ANDAND, BINOP_END}, 2814 {"||", OROR, BINOP_END}, 2815 {"<<", LSH, BINOP_END}, 2816 {">>", RSH, BINOP_END}, 2817 {"==", EQUAL, BINOP_END}, 2818 {"!=", NOTEQUAL, BINOP_END}, 2819 {"<=", LEQ, BINOP_END}, 2820 {">=", GEQ, BINOP_END}, 2821 /*{"&^", ANDNOT, BINOP_END}, TODO */ 2822 }; 2823 2824 /* Identifier-like tokens. */ 2825 static const struct token ident_tokens[] = 2826 { 2827 {"true", TRUE_KEYWORD, OP_NULL}, 2828 {"false", FALSE_KEYWORD, OP_NULL}, 2829 {"nil", NIL_KEYWORD, OP_NULL}, 2830 {"const", CONST_KEYWORD, OP_NULL}, 2831 {"struct", STRUCT_KEYWORD, OP_NULL}, 2832 {"type", TYPE_KEYWORD, OP_NULL}, 2833 {"interface", INTERFACE_KEYWORD, OP_NULL}, 2834 {"chan", CHAN_KEYWORD, OP_NULL}, 2835 {"byte", BYTE_KEYWORD, OP_NULL}, /* An alias of uint8. */ 2836 {"len", LEN_KEYWORD, OP_NULL}, 2837 {"cap", CAP_KEYWORD, OP_NULL}, 2838 {"new", NEW_KEYWORD, OP_NULL}, 2839 {"iota", IOTA_KEYWORD, OP_NULL}, 2840 }; 2841 2842 /* This is set if a NAME token appeared at the very end of the input 2843 string, with no whitespace separating the name from the EOF. This 2844 is used only when parsing to do field name completion. */ 2845 static int saw_name_at_eof; 2846 2847 /* This is set if the previously-returned token was a structure 2848 operator -- either '.' or ARROW. This is used only when parsing to 2849 do field name completion. */ 2850 static int last_was_structop; 2851 2852 /* Read one token, getting characters through lexptr. */ 2853 2854 static int 2855 lex_one_token (void) 2856 { 2857 int c; 2858 int namelen; 2859 unsigned int i; 2860 char *tokstart; 2861 int saw_structop = last_was_structop; 2862 char *copy; 2863 2864 last_was_structop = 0; 2865 2866 retry: 2867 2868 prev_lexptr = lexptr; 2869 2870 tokstart = lexptr; 2871 /* See if it is a special token of length 3. */ 2872 for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++) 2873 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0) 2874 { 2875 lexptr += 3; 2876 yylval.opcode = tokentab3[i].opcode; 2877 return tokentab3[i].token; 2878 } 2879 2880 /* See if it is a special token of length 2. */ 2881 for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++) 2882 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0) 2883 { 2884 lexptr += 2; 2885 yylval.opcode = tokentab2[i].opcode; 2886 /* NOTE: -> doesn't exist in Go, so we don't need to watch for 2887 setting last_was_structop here. */ 2888 return tokentab2[i].token; 2889 } 2890 2891 switch (c = *tokstart) 2892 { 2893 case 0: 2894 if (saw_name_at_eof) 2895 { 2896 saw_name_at_eof = 0; 2897 return COMPLETE; 2898 } 2899 else if (saw_structop) 2900 return COMPLETE; 2901 else 2902 return 0; 2903 2904 case ' ': 2905 case '\t': 2906 case '\n': 2907 lexptr++; 2908 goto retry; 2909 2910 case '[': 2911 case '(': 2912 paren_depth++; 2913 lexptr++; 2914 return c; 2915 2916 case ']': 2917 case ')': 2918 if (paren_depth == 0) 2919 return 0; 2920 paren_depth--; 2921 lexptr++; 2922 return c; 2923 2924 case ',': 2925 if (comma_terminates 2926 && paren_depth == 0) 2927 return 0; 2928 lexptr++; 2929 return c; 2930 2931 case '.': 2932 /* Might be a floating point number. */ 2933 if (lexptr[1] < '0' || lexptr[1] > '9') 2934 { 2935 if (parse_completion) 2936 last_was_structop = 1; 2937 goto symbol; /* Nope, must be a symbol. */ 2938 } 2939 /* FALL THRU into number case. */ 2940 2941 case '0': 2942 case '1': 2943 case '2': 2944 case '3': 2945 case '4': 2946 case '5': 2947 case '6': 2948 case '7': 2949 case '8': 2950 case '9': 2951 { 2952 /* It's a number. */ 2953 int got_dot = 0, got_e = 0, toktype; 2954 char *p = tokstart; 2955 int hex = input_radix > 10; 2956 2957 if (c == '0' && (p[1] == 'x' || p[1] == 'X')) 2958 { 2959 p += 2; 2960 hex = 1; 2961 } 2962 2963 for (;; ++p) 2964 { 2965 /* This test includes !hex because 'e' is a valid hex digit 2966 and thus does not indicate a floating point number when 2967 the radix is hex. */ 2968 if (!hex && !got_e && (*p == 'e' || *p == 'E')) 2969 got_dot = got_e = 1; 2970 /* This test does not include !hex, because a '.' always indicates 2971 a decimal floating point number regardless of the radix. */ 2972 else if (!got_dot && *p == '.') 2973 got_dot = 1; 2974 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') 2975 && (*p == '-' || *p == '+')) 2976 /* This is the sign of the exponent, not the end of the 2977 number. */ 2978 continue; 2979 /* We will take any letters or digits. parse_number will 2980 complain if past the radix, or if L or U are not final. */ 2981 else if ((*p < '0' || *p > '9') 2982 && ((*p < 'a' || *p > 'z') 2983 && (*p < 'A' || *p > 'Z'))) 2984 break; 2985 } 2986 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); 2987 if (toktype == ERROR) 2988 { 2989 char *err_copy = (char *) alloca (p - tokstart + 1); 2990 2991 memcpy (err_copy, tokstart, p - tokstart); 2992 err_copy[p - tokstart] = 0; 2993 error (_("Invalid number \"%s\"."), err_copy); 2994 } 2995 lexptr = p; 2996 return toktype; 2997 } 2998 2999 case '@': 3000 { 3001 char *p = &tokstart[1]; 3002 size_t len = strlen ("entry"); 3003 3004 while (isspace (*p)) 3005 p++; 3006 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len]) 3007 && p[len] != '_') 3008 { 3009 lexptr = &p[len]; 3010 return ENTRY; 3011 } 3012 } 3013 /* FALLTHRU */ 3014 case '+': 3015 case '-': 3016 case '*': 3017 case '/': 3018 case '%': 3019 case '|': 3020 case '&': 3021 case '^': 3022 case '~': 3023 case '!': 3024 case '<': 3025 case '>': 3026 case '?': 3027 case ':': 3028 case '=': 3029 case '{': 3030 case '}': 3031 symbol: 3032 lexptr++; 3033 return c; 3034 3035 case '\'': 3036 case '"': 3037 case '`': 3038 { 3039 int host_len; 3040 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval, 3041 &host_len); 3042 if (result == CHAR) 3043 { 3044 if (host_len == 0) 3045 error (_("Empty character constant.")); 3046 else if (host_len > 2 && c == '\'') 3047 { 3048 ++tokstart; 3049 namelen = lexptr - tokstart - 1; 3050 goto tryname; 3051 } 3052 else if (host_len > 1) 3053 error (_("Invalid character constant.")); 3054 } 3055 return result; 3056 } 3057 } 3058 3059 if (!(c == '_' || c == '$' 3060 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) 3061 /* We must have come across a bad character (e.g. ';'). */ 3062 error (_("Invalid character '%c' in expression."), c); 3063 3064 /* It's a name. See how long it is. */ 3065 namelen = 0; 3066 for (c = tokstart[namelen]; 3067 (c == '_' || c == '$' || (c >= '0' && c <= '9') 3068 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));) 3069 { 3070 c = tokstart[++namelen]; 3071 } 3072 3073 /* The token "if" terminates the expression and is NOT removed from 3074 the input stream. It doesn't count if it appears in the 3075 expansion of a macro. */ 3076 if (namelen == 2 3077 && tokstart[0] == 'i' 3078 && tokstart[1] == 'f') 3079 { 3080 return 0; 3081 } 3082 3083 /* For the same reason (breakpoint conditions), "thread N" 3084 terminates the expression. "thread" could be an identifier, but 3085 an identifier is never followed by a number without intervening 3086 punctuation. 3087 Handle abbreviations of these, similarly to 3088 breakpoint.c:find_condition_and_thread. 3089 TODO: Watch for "goroutine" here? */ 3090 if (namelen >= 1 3091 && strncmp (tokstart, "thread", namelen) == 0 3092 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')) 3093 { 3094 char *p = tokstart + namelen + 1; 3095 while (*p == ' ' || *p == '\t') 3096 p++; 3097 if (*p >= '0' && *p <= '9') 3098 return 0; 3099 } 3100 3101 lexptr += namelen; 3102 3103 tryname: 3104 3105 yylval.sval.ptr = tokstart; 3106 yylval.sval.length = namelen; 3107 3108 /* Catch specific keywords. */ 3109 copy = copy_name (yylval.sval); 3110 for (i = 0; i < sizeof (ident_tokens) / sizeof (ident_tokens[0]); i++) 3111 if (strcmp (copy, ident_tokens[i].operator) == 0) 3112 { 3113 /* It is ok to always set this, even though we don't always 3114 strictly need to. */ 3115 yylval.opcode = ident_tokens[i].opcode; 3116 return ident_tokens[i].token; 3117 } 3118 3119 if (*tokstart == '$') 3120 return DOLLAR_VARIABLE; 3121 3122 if (parse_completion && *lexptr == '\0') 3123 saw_name_at_eof = 1; 3124 return NAME; 3125 } 3126 3127 /* An object of this type is pushed on a FIFO by the "outer" lexer. */ 3128 typedef struct 3129 { 3130 int token; 3131 YYSTYPE value; 3132 } token_and_value; 3133 3134 DEF_VEC_O (token_and_value); 3135 3136 /* A FIFO of tokens that have been read but not yet returned to the 3137 parser. */ 3138 static VEC (token_and_value) *token_fifo; 3139 3140 /* Non-zero if the lexer should return tokens from the FIFO. */ 3141 static int popping; 3142 3143 /* Temporary storage for yylex; this holds symbol names as they are 3144 built up. */ 3145 static struct obstack name_obstack; 3146 3147 /* Build "package.name" in name_obstack. 3148 For convenience of the caller, the name is NUL-terminated, 3149 but the NUL is not included in the recorded length. */ 3150 3151 static struct stoken 3152 build_packaged_name (const char *package, int package_len, 3153 const char *name, int name_len) 3154 { 3155 struct stoken result; 3156 3157 obstack_free (&name_obstack, obstack_base (&name_obstack)); 3158 obstack_grow (&name_obstack, package, package_len); 3159 obstack_grow_str (&name_obstack, "."); 3160 obstack_grow (&name_obstack, name, name_len); 3161 obstack_grow (&name_obstack, "", 1); 3162 result.ptr = obstack_base (&name_obstack); 3163 result.length = obstack_object_size (&name_obstack) - 1; 3164 3165 return result; 3166 } 3167 3168 /* Return non-zero if NAME is a package name. 3169 BLOCK is the scope in which to interpret NAME; this can be NULL 3170 to mean the global scope. */ 3171 3172 static int 3173 package_name_p (const char *name, const struct block *block) 3174 { 3175 struct symbol *sym; 3176 struct field_of_this_result is_a_field_of_this; 3177 3178 sym = lookup_symbol (name, block, STRUCT_DOMAIN, &is_a_field_of_this); 3179 3180 if (sym 3181 && SYMBOL_CLASS (sym) == LOC_TYPEDEF 3182 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_MODULE) 3183 return 1; 3184 3185 return 0; 3186 } 3187 3188 /* Classify a (potential) function in the "unsafe" package. 3189 We fold these into "keywords" to keep things simple, at least until 3190 something more complex is warranted. */ 3191 3192 static int 3193 classify_unsafe_function (struct stoken function_name) 3194 { 3195 char *copy = copy_name (function_name); 3196 3197 if (strcmp (copy, "Sizeof") == 0) 3198 { 3199 yylval.sval = function_name; 3200 return SIZEOF_KEYWORD; 3201 } 3202 3203 error (_("Unknown function in `unsafe' package: %s"), copy); 3204 } 3205 3206 /* Classify token(s) "name1.name2" where name1 is known to be a package. 3207 The contents of the token are in `yylval'. 3208 Updates yylval and returns the new token type. 3209 3210 The result is one of NAME, NAME_OR_INT, or TYPENAME. */ 3211 3212 static int 3213 classify_packaged_name (const struct block *block) 3214 { 3215 char *copy; 3216 struct symbol *sym; 3217 struct field_of_this_result is_a_field_of_this; 3218 3219 copy = copy_name (yylval.sval); 3220 3221 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this); 3222 3223 if (sym) 3224 { 3225 yylval.ssym.sym = sym; 3226 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 3227 } 3228 3229 return NAME; 3230 } 3231 3232 /* Classify a NAME token. 3233 The contents of the token are in `yylval'. 3234 Updates yylval and returns the new token type. 3235 BLOCK is the block in which lookups start; this can be NULL 3236 to mean the global scope. 3237 3238 The result is one of NAME, NAME_OR_INT, or TYPENAME. */ 3239 3240 static int 3241 classify_name (const struct block *block) 3242 { 3243 struct type *type; 3244 struct symbol *sym; 3245 char *copy; 3246 struct field_of_this_result is_a_field_of_this; 3247 3248 copy = copy_name (yylval.sval); 3249 3250 /* Try primitive types first so they win over bad/weird debug info. */ 3251 type = language_lookup_primitive_type_by_name (parse_language, 3252 parse_gdbarch, copy); 3253 if (type != NULL) 3254 { 3255 /* NOTE: We take advantage of the fact that yylval coming in was a 3256 NAME, and that struct ttype is a compatible extension of struct 3257 stoken, so yylval.tsym.stoken is already filled in. */ 3258 yylval.tsym.type = type; 3259 return TYPENAME; 3260 } 3261 3262 /* TODO: What about other types? */ 3263 3264 sym = lookup_symbol (copy, block, VAR_DOMAIN, &is_a_field_of_this); 3265 3266 if (sym) 3267 { 3268 yylval.ssym.sym = sym; 3269 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 3270 return NAME; 3271 } 3272 3273 /* If we didn't find a symbol, look again in the current package. 3274 This is to, e.g., make "p global_var" work without having to specify 3275 the package name. We intentionally only looks for objects in the 3276 current package. */ 3277 3278 { 3279 char *current_package_name = go_block_package_name (block); 3280 3281 if (current_package_name != NULL) 3282 { 3283 struct stoken sval = 3284 build_packaged_name (current_package_name, 3285 strlen (current_package_name), 3286 copy, strlen (copy)); 3287 3288 xfree (current_package_name); 3289 sym = lookup_symbol (sval.ptr, block, VAR_DOMAIN, 3290 &is_a_field_of_this); 3291 if (sym) 3292 { 3293 yylval.ssym.stoken = sval; 3294 yylval.ssym.sym = sym; 3295 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; 3296 return NAME; 3297 } 3298 } 3299 } 3300 3301 /* Input names that aren't symbols but ARE valid hex numbers, when 3302 the input radix permits them, can be names or numbers depending 3303 on the parse. Note we support radixes > 16 here. */ 3304 if ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10) 3305 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)) 3306 { 3307 YYSTYPE newlval; /* Its value is ignored. */ 3308 int hextype = parse_number (copy, yylval.sval.length, 0, &newlval); 3309 if (hextype == INT) 3310 { 3311 yylval.ssym.sym = NULL; 3312 yylval.ssym.is_a_field_of_this = 0; 3313 return NAME_OR_INT; 3314 } 3315 } 3316 3317 yylval.ssym.sym = NULL; 3318 yylval.ssym.is_a_field_of_this = 0; 3319 return NAME; 3320 } 3321 3322 /* This is taken from c-exp.y mostly to get something working. 3323 The basic structure has been kept because we may yet need some of it. */ 3324 3325 static int 3326 yylex (void) 3327 { 3328 token_and_value current, next; 3329 3330 if (popping && !VEC_empty (token_and_value, token_fifo)) 3331 { 3332 token_and_value tv = *VEC_index (token_and_value, token_fifo, 0); 3333 VEC_ordered_remove (token_and_value, token_fifo, 0); 3334 yylval = tv.value; 3335 /* There's no need to fall through to handle package.name 3336 as that can never happen here. In theory. */ 3337 return tv.token; 3338 } 3339 popping = 0; 3340 3341 current.token = lex_one_token (); 3342 3343 /* TODO: Need a way to force specifying name1 as a package. 3344 .name1.name2 ? */ 3345 3346 if (current.token != NAME) 3347 return current.token; 3348 3349 /* See if we have "name1 . name2". */ 3350 3351 current.value = yylval; 3352 next.token = lex_one_token (); 3353 next.value = yylval; 3354 3355 if (next.token == '.') 3356 { 3357 token_and_value name2; 3358 3359 name2.token = lex_one_token (); 3360 name2.value = yylval; 3361 3362 if (name2.token == NAME) 3363 { 3364 /* Ok, we have "name1 . name2". */ 3365 char *copy; 3366 3367 copy = copy_name (current.value.sval); 3368 3369 if (strcmp (copy, "unsafe") == 0) 3370 { 3371 popping = 1; 3372 return classify_unsafe_function (name2.value.sval); 3373 } 3374 3375 if (package_name_p (copy, expression_context_block)) 3376 { 3377 popping = 1; 3378 yylval.sval = build_packaged_name (current.value.sval.ptr, 3379 current.value.sval.length, 3380 name2.value.sval.ptr, 3381 name2.value.sval.length); 3382 return classify_packaged_name (expression_context_block); 3383 } 3384 } 3385 3386 VEC_safe_push (token_and_value, token_fifo, &next); 3387 VEC_safe_push (token_and_value, token_fifo, &name2); 3388 } 3389 else 3390 { 3391 VEC_safe_push (token_and_value, token_fifo, &next); 3392 } 3393 3394 /* If we arrive here we don't have a package-qualified name. */ 3395 3396 popping = 1; 3397 yylval = current.value; 3398 return classify_name (expression_context_block); 3399 } 3400 3401 int 3402 go_parse (void) 3403 { 3404 int result; 3405 struct cleanup *back_to = make_cleanup (null_cleanup, NULL); 3406 3407 make_cleanup_restore_integer (&yydebug); 3408 yydebug = parser_debug; 3409 3410 /* Initialize some state used by the lexer. */ 3411 last_was_structop = 0; 3412 saw_name_at_eof = 0; 3413 3414 VEC_free (token_and_value, token_fifo); 3415 popping = 0; 3416 obstack_init (&name_obstack); 3417 make_cleanup_obstack_free (&name_obstack); 3418 3419 result = yyparse (); 3420 do_cleanups (back_to); 3421 return result; 3422 } 3423 3424 void 3425 yyerror (char *msg) 3426 { 3427 if (prev_lexptr) 3428 lexptr = prev_lexptr; 3429 3430 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr); 3431 } 3432 3433