1 /* A Bison parser, made by GNU Bison 3.0.5. */ 2 3 /* Bison implementation for Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018 Free Software Foundation, Inc. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 /* As a special exception, you may create a larger work that contains 21 part or all of the Bison parser skeleton and distribute that work 22 under terms of your choice, so long as that work isn't itself a 23 parser generator using the skeleton or a modified version thereof 24 as a parser skeleton. Alternatively, if you modify or redistribute 25 the parser skeleton itself, you may (at your option) remove this 26 special exception, which will cause the skeleton and the resulting 27 Bison output files to be licensed under the GNU General Public 28 License without this special exception. 29 30 This special exception was added by the Free Software Foundation in 31 version 2.2 of Bison. */ 32 33 /* C LALR(1) parser skeleton written by Richard Stallman, by 34 simplifying the original so-called "semantic" parser. */ 35 36 /* All symbols defined below should begin with yy or YY, to avoid 37 infringing on user name space. This should be done even for local 38 variables, as they might otherwise be expanded by user macros. 39 There are some unavoidable exceptions within include files to 40 define necessary library symbols; they are noted "INFRINGES ON 41 USER NAME SPACE" below. */ 42 43 /* Identify Bison output. */ 44 #define YYBISON 1 45 46 /* Bison version. */ 47 #define YYBISON_VERSION "3.0.5" 48 49 /* Skeleton name. */ 50 #define YYSKELETON_NAME "yacc.c" 51 52 /* Pure parsers. */ 53 #define YYPURE 0 54 55 /* Push parsers. */ 56 #define YYPUSH 0 57 58 /* Pull parsers. */ 59 #define YYPULL 1 60 61 62 63 64 /* Copy the first part of user declarations. */ 65 #line 1 "defparse.y" /* yacc.c:339 */ 66 /* defparse.y - parser for .def files */ 67 68 /* Copyright (C) 1995-2020 Free Software Foundation, Inc. 69 70 This file is part of GNU Binutils. 71 72 This program is free software; you can redistribute it and/or modify 73 it under the terms of the GNU General Public License as published by 74 the Free Software Foundation; either version 3 of the License, or 75 (at your option) any later version. 76 77 This program is distributed in the hope that it will be useful, 78 but WITHOUT ANY WARRANTY; without even the implied warranty of 79 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 80 GNU General Public License for more details. 81 82 You should have received a copy of the GNU General Public License 83 along with this program; if not, write to the Free Software 84 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 85 MA 02110-1301, USA. */ 86 87 #include "sysdep.h" 88 #include "bfd.h" 89 #include "libiberty.h" 90 #include "dlltool.h" 91 92 #line 93 "defparse.c" /* yacc.c:339 */ 93 94 # ifndef YY_NULLPTR 95 # if defined __cplusplus && 201103L <= __cplusplus 96 # define YY_NULLPTR nullptr 97 # else 98 # define YY_NULLPTR 0 99 # endif 100 # endif 101 102 /* Enabling verbose error messages. */ 103 #ifdef YYERROR_VERBOSE 104 # undef YYERROR_VERBOSE 105 # define YYERROR_VERBOSE 1 106 #else 107 # define YYERROR_VERBOSE 0 108 #endif 109 110 /* In a future release of Bison, this section will be replaced 111 by #include "y.tab.h". */ 112 #ifndef YY_YY_DEFPARSE_H_INCLUDED 113 # define YY_YY_DEFPARSE_H_INCLUDED 114 /* Debug traces. */ 115 #ifndef YYDEBUG 116 # define YYDEBUG 0 117 #endif 118 #if YYDEBUG 119 extern int yydebug; 120 #endif 121 122 /* Token type. */ 123 #ifndef YYTOKENTYPE 124 # define YYTOKENTYPE 125 enum yytokentype 126 { 127 NAME = 258, 128 LIBRARY = 259, 129 DESCRIPTION = 260, 130 STACKSIZE = 261, 131 HEAPSIZE = 262, 132 CODE = 263, 133 DATA = 264, 134 SECTIONS = 265, 135 EXPORTS = 266, 136 IMPORTS = 267, 137 VERSIONK = 268, 138 BASE = 269, 139 CONSTANT = 270, 140 READ = 271, 141 WRITE = 272, 142 EXECUTE = 273, 143 SHARED = 274, 144 NONSHARED = 275, 145 NONAME = 276, 146 PRIVATE = 277, 147 SINGLE = 278, 148 MULTIPLE = 279, 149 INITINSTANCE = 280, 150 INITGLOBAL = 281, 151 TERMINSTANCE = 282, 152 TERMGLOBAL = 283, 153 EQUAL = 284, 154 ID = 285, 155 NUMBER = 286 156 }; 157 #endif 158 /* Tokens. */ 159 #define NAME 258 160 #define LIBRARY 259 161 #define DESCRIPTION 260 162 #define STACKSIZE 261 163 #define HEAPSIZE 262 164 #define CODE 263 165 #define DATA 264 166 #define SECTIONS 265 167 #define EXPORTS 266 168 #define IMPORTS 267 169 #define VERSIONK 268 170 #define BASE 269 171 #define CONSTANT 270 172 #define READ 271 173 #define WRITE 272 174 #define EXECUTE 273 175 #define SHARED 274 176 #define NONSHARED 275 177 #define NONAME 276 178 #define PRIVATE 277 179 #define SINGLE 278 180 #define MULTIPLE 279 181 #define INITINSTANCE 280 182 #define INITGLOBAL 281 183 #define TERMINSTANCE 282 184 #define TERMGLOBAL 283 185 #define EQUAL 284 186 #define ID 285 187 #define NUMBER 286 188 189 /* Value type. */ 190 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 191 192 union YYSTYPE 193 { 194 #line 28 "defparse.y" /* yacc.c:355 */ 195 196 char *id; 197 const char *id_const; 198 int number; 199 200 #line 201 "defparse.c" /* yacc.c:355 */ 201 }; 202 203 typedef union YYSTYPE YYSTYPE; 204 # define YYSTYPE_IS_TRIVIAL 1 205 # define YYSTYPE_IS_DECLARED 1 206 #endif 207 208 209 extern YYSTYPE yylval; 210 211 int yyparse (void); 212 213 #endif /* !YY_YY_DEFPARSE_H_INCLUDED */ 214 215 /* Copy the second part of user declarations. */ 216 217 #line 218 "defparse.c" /* yacc.c:358 */ 218 219 #ifdef short 220 # undef short 221 #endif 222 223 #ifdef YYTYPE_UINT8 224 typedef YYTYPE_UINT8 yytype_uint8; 225 #else 226 typedef unsigned char yytype_uint8; 227 #endif 228 229 #ifdef YYTYPE_INT8 230 typedef YYTYPE_INT8 yytype_int8; 231 #else 232 typedef signed char yytype_int8; 233 #endif 234 235 #ifdef YYTYPE_UINT16 236 typedef YYTYPE_UINT16 yytype_uint16; 237 #else 238 typedef unsigned short int yytype_uint16; 239 #endif 240 241 #ifdef YYTYPE_INT16 242 typedef YYTYPE_INT16 yytype_int16; 243 #else 244 typedef short int yytype_int16; 245 #endif 246 247 #ifndef YYSIZE_T 248 # ifdef __SIZE_TYPE__ 249 # define YYSIZE_T __SIZE_TYPE__ 250 # elif defined size_t 251 # define YYSIZE_T size_t 252 # elif ! defined YYSIZE_T 253 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 254 # define YYSIZE_T size_t 255 # else 256 # define YYSIZE_T unsigned int 257 # endif 258 #endif 259 260 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 261 262 #ifndef YY_ 263 # if defined YYENABLE_NLS && YYENABLE_NLS 264 # if ENABLE_NLS 265 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 266 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 267 # endif 268 # endif 269 # ifndef YY_ 270 # define YY_(Msgid) Msgid 271 # endif 272 #endif 273 274 #ifndef YY_ATTRIBUTE 275 # if (defined __GNUC__ \ 276 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ 277 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C 278 # define YY_ATTRIBUTE(Spec) __attribute__(Spec) 279 # else 280 # define YY_ATTRIBUTE(Spec) /* empty */ 281 # endif 282 #endif 283 284 #ifndef YY_ATTRIBUTE_PURE 285 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) 286 #endif 287 288 #ifndef YY_ATTRIBUTE_UNUSED 289 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) 290 #endif 291 292 #if !defined _Noreturn \ 293 && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) 294 # if defined _MSC_VER && 1200 <= _MSC_VER 295 # define _Noreturn __declspec (noreturn) 296 # else 297 # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) 298 # endif 299 #endif 300 301 /* Suppress unused-variable warnings by "using" E. */ 302 #if ! defined lint || defined __GNUC__ 303 # define YYUSE(E) ((void) (E)) 304 #else 305 # define YYUSE(E) /* empty */ 306 #endif 307 308 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ 309 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 310 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 311 _Pragma ("GCC diagnostic push") \ 312 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ 313 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 314 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 315 _Pragma ("GCC diagnostic pop") 316 #else 317 # define YY_INITIAL_VALUE(Value) Value 318 #endif 319 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 320 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 321 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 322 #endif 323 #ifndef YY_INITIAL_VALUE 324 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 325 #endif 326 327 328 #if ! defined yyoverflow || YYERROR_VERBOSE 329 330 /* The parser invokes alloca or malloc; define the necessary symbols. */ 331 332 # ifdef YYSTACK_USE_ALLOCA 333 # if YYSTACK_USE_ALLOCA 334 # ifdef __GNUC__ 335 # define YYSTACK_ALLOC __builtin_alloca 336 # elif defined __BUILTIN_VA_ARG_INCR 337 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 338 # elif defined _AIX 339 # define YYSTACK_ALLOC __alloca 340 # elif defined _MSC_VER 341 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 342 # define alloca _alloca 343 # else 344 # define YYSTACK_ALLOC alloca 345 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 346 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 347 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 348 # ifndef EXIT_SUCCESS 349 # define EXIT_SUCCESS 0 350 # endif 351 # endif 352 # endif 353 # endif 354 # endif 355 356 # ifdef YYSTACK_ALLOC 357 /* Pacify GCC's 'empty if-body' warning. */ 358 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 359 # ifndef YYSTACK_ALLOC_MAXIMUM 360 /* The OS might guarantee only one guard page at the bottom of the stack, 361 and a page size can be as small as 4096 bytes. So we cannot safely 362 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 363 to allow for a few compiler-allocated temporary stack slots. */ 364 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 365 # endif 366 # else 367 # define YYSTACK_ALLOC YYMALLOC 368 # define YYSTACK_FREE YYFREE 369 # ifndef YYSTACK_ALLOC_MAXIMUM 370 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 371 # endif 372 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 373 && ! ((defined YYMALLOC || defined malloc) \ 374 && (defined YYFREE || defined free))) 375 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 376 # ifndef EXIT_SUCCESS 377 # define EXIT_SUCCESS 0 378 # endif 379 # endif 380 # ifndef YYMALLOC 381 # define YYMALLOC malloc 382 # if ! defined malloc && ! defined EXIT_SUCCESS 383 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 384 # endif 385 # endif 386 # ifndef YYFREE 387 # define YYFREE free 388 # if ! defined free && ! defined EXIT_SUCCESS 389 void free (void *); /* INFRINGES ON USER NAME SPACE */ 390 # endif 391 # endif 392 # endif 393 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 394 395 396 #if (! defined yyoverflow \ 397 && (! defined __cplusplus \ 398 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 399 400 /* A type that is properly aligned for any stack member. */ 401 union yyalloc 402 { 403 yytype_int16 yyss_alloc; 404 YYSTYPE yyvs_alloc; 405 }; 406 407 /* The size of the maximum gap between one aligned stack and the next. */ 408 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 409 410 /* The size of an array large to enough to hold all stacks, each with 411 N elements. */ 412 # define YYSTACK_BYTES(N) \ 413 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 414 + YYSTACK_GAP_MAXIMUM) 415 416 # define YYCOPY_NEEDED 1 417 418 /* Relocate STACK from its old location to the new one. The 419 local variables YYSIZE and YYSTACKSIZE give the old and new number of 420 elements in the stack, and YYPTR gives the new location of the 421 stack. Advance YYPTR to a properly aligned location for the next 422 stack. */ 423 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 424 do \ 425 { \ 426 YYSIZE_T yynewbytes; \ 427 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 428 Stack = &yyptr->Stack_alloc; \ 429 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 430 yyptr += yynewbytes / sizeof (*yyptr); \ 431 } \ 432 while (0) 433 434 #endif 435 436 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 437 /* Copy COUNT objects from SRC to DST. The source and destination do 438 not overlap. */ 439 # ifndef YYCOPY 440 # if defined __GNUC__ && 1 < __GNUC__ 441 # define YYCOPY(Dst, Src, Count) \ 442 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) 443 # else 444 # define YYCOPY(Dst, Src, Count) \ 445 do \ 446 { \ 447 YYSIZE_T yyi; \ 448 for (yyi = 0; yyi < (Count); yyi++) \ 449 (Dst)[yyi] = (Src)[yyi]; \ 450 } \ 451 while (0) 452 # endif 453 # endif 454 #endif /* !YYCOPY_NEEDED */ 455 456 /* YYFINAL -- State number of the termination state. */ 457 #define YYFINAL 66 458 /* YYLAST -- Last index in YYTABLE. */ 459 #define YYLAST 141 460 461 /* YYNTOKENS -- Number of terminals. */ 462 #define YYNTOKENS 36 463 /* YYNNTS -- Number of nonterminals. */ 464 #define YYNNTS 26 465 /* YYNRULES -- Number of rules. */ 466 #define YYNRULES 98 467 /* YYNSTATES -- Number of states. */ 468 #define YYNSTATES 139 469 470 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned 471 by yylex, with out-of-bounds checking. */ 472 #define YYUNDEFTOK 2 473 #define YYMAXUTOK 286 474 475 #define YYTRANSLATE(YYX) \ 476 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 477 478 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 479 as returned by yylex, without out-of-bounds checking. */ 480 static const yytype_uint8 yytranslate[] = 481 { 482 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 483 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 486 2, 2, 2, 2, 34, 2, 32, 2, 2, 2, 487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 488 2, 33, 2, 2, 35, 2, 2, 2, 2, 2, 489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 502 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 503 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 504 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 505 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 506 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 507 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 508 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 509 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 510 25, 26, 27, 28, 29, 30, 31 511 }; 512 513 #if YYDEBUG 514 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 515 static const yytype_uint8 yyrline[] = 516 { 517 0, 48, 48, 49, 53, 54, 55, 56, 57, 58, 518 59, 60, 61, 62, 63, 64, 68, 70, 74, 79, 519 80, 84, 86, 88, 90, 92, 94, 96, 98, 103, 520 104, 108, 112, 113, 117, 118, 120, 121, 125, 126, 521 127, 128, 129, 130, 131, 135, 136, 140, 141, 145, 522 146, 150, 151, 154, 159, 160, 161, 162, 163, 164, 523 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 524 175, 176, 177, 178, 179, 180, 181, 182, 185, 186, 525 192, 198, 204, 211, 212, 216, 217, 221, 222, 226, 526 227, 230, 231, 234, 236, 240, 241, 242, 243 527 }; 528 #endif 529 530 #if YYDEBUG || YYERROR_VERBOSE || 0 531 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 532 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 533 static const char *const yytname[] = 534 { 535 "$end", "error", "$undefined", "NAME", "LIBRARY", "DESCRIPTION", 536 "STACKSIZE", "HEAPSIZE", "CODE", "DATA", "SECTIONS", "EXPORTS", 537 "IMPORTS", "VERSIONK", "BASE", "CONSTANT", "READ", "WRITE", "EXECUTE", 538 "SHARED", "NONSHARED", "NONAME", "PRIVATE", "SINGLE", "MULTIPLE", 539 "INITINSTANCE", "INITGLOBAL", "TERMINSTANCE", "TERMGLOBAL", "EQUAL", 540 "ID", "NUMBER", "'.'", "'='", "','", "'@'", "$accept", "start", 541 "command", "explist", "expline", "implist", "impline", "seclist", 542 "secline", "attr_list", "opt_comma", "opt_number", "attr", 543 "opt_CONSTANT", "opt_NONAME", "opt_DATA", "opt_PRIVATE", 544 "keyword_as_name", "opt_name2", "opt_name", "opt_ordinal", 545 "opt_import_name", "opt_equal_name", "opt_base", "option_list", "option", YY_NULLPTR 546 }; 547 #endif 548 549 # ifdef YYPRINT 550 /* YYTOKNUM[NUM] -- (External) token number corresponding to the 551 (internal) symbol number NUM (which must be that of a token). */ 552 static const yytype_uint16 yytoknum[] = 553 { 554 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 555 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 556 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 557 285, 286, 46, 61, 44, 64 558 }; 559 # endif 560 561 #define YYPACT_NINF -96 562 563 #define yypact_value_is_default(Yystate) \ 564 (!!((Yystate) == (-96))) 565 566 #define YYTABLE_NINF -36 567 568 #define yytable_value_is_error(Yytable_value) \ 569 0 570 571 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 572 STATE-NUM. */ 573 static const yytype_int8 yypact[] = 574 { 575 38, 61, 61, -22, -1, 8, 39, 39, -7, -96, 576 23, 59, 92, -96, -96, -96, -96, -96, -96, -96, 577 -96, -96, -96, -96, -96, -96, -96, -96, -96, -96, 578 -96, -96, -96, -96, -96, -96, -96, -96, -96, 62, 579 61, 79, -96, 96, 96, -96, 80, 80, -96, -96, 580 -96, -96, -96, -96, -96, -13, -96, -13, 39, -7, 581 -96, 82, 1, 23, -96, 81, -96, -96, 61, 79, 582 -96, 61, 83, -96, -96, 84, -96, -96, -96, 39, 583 -13, -96, 85, -96, 5, 87, -96, 88, -96, -96, 584 89, -12, -96, -96, 61, 86, -20, 93, 91, -96, 585 -96, -8, -96, 94, 103, 61, 30, -96, -96, 76, 586 -96, -96, -96, -96, -96, -96, -96, 111, -96, 93, 587 93, 0, 93, -96, 118, -96, -96, 78, -96, -96, 588 -96, 106, 93, 93, -96, 93, -96, -96, -96 589 }; 590 591 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 592 Performed when YYTABLE does not specify something else to do. Zero 593 means the default is an error. */ 594 static const yytype_uint8 yydefact[] = 595 { 596 0, 84, 84, 0, 0, 0, 0, 0, 0, 16, 597 0, 0, 0, 3, 53, 54, 55, 56, 57, 58, 598 59, 60, 61, 62, 63, 64, 67, 68, 69, 70, 599 71, 65, 66, 72, 73, 74, 75, 76, 77, 78, 600 0, 0, 83, 92, 92, 7, 37, 37, 38, 39, 601 40, 41, 42, 43, 44, 10, 33, 11, 0, 12, 602 30, 6, 0, 13, 20, 14, 1, 2, 0, 79, 603 80, 0, 0, 4, 93, 0, 8, 9, 34, 0, 604 31, 29, 90, 17, 0, 0, 19, 0, 82, 81, 605 0, 5, 36, 32, 0, 86, 88, 88, 0, 15, 606 91, 0, 89, 0, 48, 0, 0, 27, 28, 0, 607 95, 96, 97, 98, 94, 85, 47, 46, 87, 88, 608 88, 88, 88, 45, 50, 25, 26, 0, 23, 24, 609 49, 52, 88, 88, 51, 88, 21, 22, 18 610 }; 611 612 /* YYPGOTO[NTERM-NUM]. */ 613 static const yytype_int16 yypgoto[] = 614 { 615 -96, -96, 117, -96, -96, -96, 67, -96, 72, -6, 616 41, 90, 54, -96, -96, -96, -96, 95, -40, 132, 617 -96, -95, -96, 97, -96, -96 618 }; 619 620 /* YYDEFGOTO[NTERM-NUM]. */ 621 static const yytype_int16 yydefgoto[] = 622 { 623 -1, 12, 13, 61, 83, 63, 64, 59, 60, 55, 624 79, 76, 56, 124, 117, 131, 135, 41, 42, 43, 625 104, 107, 95, 73, 91, 114 626 }; 627 628 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 629 positive, shift that token. If negative, reduce the rule whose 630 number is the opposite. If YYTABLE_NINF, syntax error. */ 631 static const yytype_int16 yytable[] = 632 { 633 70, 57, 108, -35, -35, -35, -35, -35, 45, 105, 634 -35, -35, 106, -35, -35, -35, -35, 110, 111, 112, 635 113, 78, 78, 58, 125, 126, 128, 129, 88, 105, 636 46, 89, 127, 84, 85, 96, 97, 136, 137, 47, 637 138, 1, 2, 3, 4, 5, 6, 7, 8, 9, 638 10, 11, 80, 62, 102, 48, 49, 50, 51, 52, 639 119, 120, 53, 54, 14, 118, 15, 16, 17, 18, 640 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 641 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 642 65, 39, 66, 40, 68, 1, 2, 3, 4, 5, 643 6, 7, 8, 9, 10, 11, 121, 122, 132, 133, 644 72, 71, 82, 87, 75, 92, 90, 98, 94, 99, 645 100, 103, 105, 109, 116, 115, 123, 130, 134, 67, 646 86, 81, 101, 93, 44, 69, 0, 77, 0, 0, 647 0, 74 648 }; 649 650 static const yytype_int16 yycheck[] = 651 { 652 40, 7, 97, 16, 17, 18, 19, 20, 30, 29, 653 23, 24, 32, 25, 26, 27, 28, 25, 26, 27, 654 28, 34, 34, 30, 119, 120, 121, 122, 68, 29, 655 31, 71, 32, 32, 33, 30, 31, 132, 133, 31, 656 135, 3, 4, 5, 6, 7, 8, 9, 10, 11, 657 12, 13, 58, 30, 94, 16, 17, 18, 19, 20, 658 30, 31, 23, 24, 3, 105, 5, 6, 7, 8, 659 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 660 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 661 31, 30, 0, 32, 32, 3, 4, 5, 6, 7, 662 8, 9, 10, 11, 12, 13, 30, 31, 30, 31, 663 14, 32, 30, 32, 34, 31, 33, 30, 33, 31, 664 31, 35, 29, 32, 21, 31, 15, 9, 22, 12, 665 63, 59, 91, 79, 2, 40, -1, 47, -1, -1, 666 -1, 44 667 }; 668 669 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 670 symbol of state STATE-NUM. */ 671 static const yytype_uint8 yystos[] = 672 { 673 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 674 12, 13, 37, 38, 3, 5, 6, 7, 8, 9, 675 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 676 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 677 32, 53, 54, 55, 55, 30, 31, 31, 16, 17, 678 18, 19, 20, 23, 24, 45, 48, 45, 30, 43, 679 44, 39, 30, 41, 42, 31, 0, 38, 32, 53, 680 54, 32, 14, 59, 59, 34, 47, 47, 34, 46, 681 45, 44, 30, 40, 32, 33, 42, 32, 54, 54, 682 33, 60, 31, 48, 33, 58, 30, 31, 30, 31, 683 31, 46, 54, 35, 56, 29, 32, 57, 57, 32, 684 25, 26, 27, 28, 61, 31, 21, 50, 54, 30, 685 31, 30, 31, 15, 49, 57, 57, 32, 57, 57, 686 9, 51, 30, 31, 22, 52, 57, 57, 57 687 }; 688 689 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 690 static const yytype_uint8 yyr1[] = 691 { 692 0, 36, 37, 37, 38, 38, 38, 38, 38, 38, 693 38, 38, 38, 38, 38, 38, 39, 39, 40, 41, 694 41, 42, 42, 42, 42, 42, 42, 42, 42, 43, 695 43, 44, 45, 45, 46, 46, 47, 47, 48, 48, 696 48, 48, 48, 48, 48, 49, 49, 50, 50, 51, 697 51, 52, 52, 53, 53, 53, 53, 53, 53, 53, 698 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 699 53, 53, 53, 53, 53, 53, 53, 53, 54, 54, 700 54, 54, 54, 55, 55, 56, 56, 57, 57, 58, 701 58, 59, 59, 60, 60, 61, 61, 61, 61 702 }; 703 704 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ 705 static const yytype_uint8 yyr2[] = 706 { 707 0, 2, 2, 1, 3, 4, 2, 2, 3, 3, 708 2, 2, 2, 2, 2, 4, 0, 2, 8, 2, 709 1, 8, 8, 6, 6, 6, 6, 4, 4, 2, 710 1, 2, 3, 1, 1, 0, 2, 0, 1, 1, 711 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 712 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 713 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 714 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 715 2, 3, 3, 1, 0, 2, 0, 2, 0, 2, 716 0, 3, 0, 0, 3, 1, 1, 1, 1 717 }; 718 719 720 #define yyerrok (yyerrstatus = 0) 721 #define yyclearin (yychar = YYEMPTY) 722 #define YYEMPTY (-2) 723 #define YYEOF 0 724 725 #define YYACCEPT goto yyacceptlab 726 #define YYABORT goto yyabortlab 727 #define YYERROR goto yyerrorlab 728 729 730 #define YYRECOVERING() (!!yyerrstatus) 731 732 #define YYBACKUP(Token, Value) \ 733 do \ 734 if (yychar == YYEMPTY) \ 735 { \ 736 yychar = (Token); \ 737 yylval = (Value); \ 738 YYPOPSTACK (yylen); \ 739 yystate = *yyssp; \ 740 goto yybackup; \ 741 } \ 742 else \ 743 { \ 744 yyerror (YY_("syntax error: cannot back up")); \ 745 YYERROR; \ 746 } \ 747 while (0) 748 749 /* Error token number */ 750 #define YYTERROR 1 751 #define YYERRCODE 256 752 753 754 755 /* Enable debugging if requested. */ 756 #if YYDEBUG 757 758 # ifndef YYFPRINTF 759 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 760 # define YYFPRINTF fprintf 761 # endif 762 763 # define YYDPRINTF(Args) \ 764 do { \ 765 if (yydebug) \ 766 YYFPRINTF Args; \ 767 } while (0) 768 769 /* This macro is provided for backward compatibility. */ 770 #ifndef YY_LOCATION_PRINT 771 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 772 #endif 773 774 775 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 776 do { \ 777 if (yydebug) \ 778 { \ 779 YYFPRINTF (stderr, "%s ", Title); \ 780 yy_symbol_print (stderr, \ 781 Type, Value); \ 782 YYFPRINTF (stderr, "\n"); \ 783 } \ 784 } while (0) 785 786 787 /*----------------------------------------. 788 | Print this symbol's value on YYOUTPUT. | 789 `----------------------------------------*/ 790 791 static void 792 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 793 { 794 FILE *yyo = yyoutput; 795 YYUSE (yyo); 796 if (!yyvaluep) 797 return; 798 # ifdef YYPRINT 799 if (yytype < YYNTOKENS) 800 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 801 # endif 802 YYUSE (yytype); 803 } 804 805 806 /*--------------------------------. 807 | Print this symbol on YYOUTPUT. | 808 `--------------------------------*/ 809 810 static void 811 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 812 { 813 YYFPRINTF (yyoutput, "%s %s (", 814 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); 815 816 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 817 YYFPRINTF (yyoutput, ")"); 818 } 819 820 /*------------------------------------------------------------------. 821 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 822 | TOP (included). | 823 `------------------------------------------------------------------*/ 824 825 static void 826 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 827 { 828 YYFPRINTF (stderr, "Stack now"); 829 for (; yybottom <= yytop; yybottom++) 830 { 831 int yybot = *yybottom; 832 YYFPRINTF (stderr, " %d", yybot); 833 } 834 YYFPRINTF (stderr, "\n"); 835 } 836 837 # define YY_STACK_PRINT(Bottom, Top) \ 838 do { \ 839 if (yydebug) \ 840 yy_stack_print ((Bottom), (Top)); \ 841 } while (0) 842 843 844 /*------------------------------------------------. 845 | Report that the YYRULE is going to be reduced. | 846 `------------------------------------------------*/ 847 848 static void 849 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule) 850 { 851 unsigned long int yylno = yyrline[yyrule]; 852 int yynrhs = yyr2[yyrule]; 853 int yyi; 854 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 855 yyrule - 1, yylno); 856 /* The symbols being reduced. */ 857 for (yyi = 0; yyi < yynrhs; yyi++) 858 { 859 YYFPRINTF (stderr, " $%d = ", yyi + 1); 860 yy_symbol_print (stderr, 861 yystos[yyssp[yyi + 1 - yynrhs]], 862 &(yyvsp[(yyi + 1) - (yynrhs)]) 863 ); 864 YYFPRINTF (stderr, "\n"); 865 } 866 } 867 868 # define YY_REDUCE_PRINT(Rule) \ 869 do { \ 870 if (yydebug) \ 871 yy_reduce_print (yyssp, yyvsp, Rule); \ 872 } while (0) 873 874 /* Nonzero means print parse trace. It is left uninitialized so that 875 multiple parsers can coexist. */ 876 int yydebug; 877 #else /* !YYDEBUG */ 878 # define YYDPRINTF(Args) 879 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 880 # define YY_STACK_PRINT(Bottom, Top) 881 # define YY_REDUCE_PRINT(Rule) 882 #endif /* !YYDEBUG */ 883 884 885 /* YYINITDEPTH -- initial size of the parser's stacks. */ 886 #ifndef YYINITDEPTH 887 # define YYINITDEPTH 200 888 #endif 889 890 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 891 if the built-in stack extension method is used). 892 893 Do not make this value too large; the results are undefined if 894 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 895 evaluated with infinite-precision integer arithmetic. */ 896 897 #ifndef YYMAXDEPTH 898 # define YYMAXDEPTH 10000 899 #endif 900 901 902 #if YYERROR_VERBOSE 903 904 # ifndef yystrlen 905 # if defined __GLIBC__ && defined _STRING_H 906 # define yystrlen strlen 907 # else 908 /* Return the length of YYSTR. */ 909 static YYSIZE_T 910 yystrlen (const char *yystr) 911 { 912 YYSIZE_T yylen; 913 for (yylen = 0; yystr[yylen]; yylen++) 914 continue; 915 return yylen; 916 } 917 # endif 918 # endif 919 920 # ifndef yystpcpy 921 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 922 # define yystpcpy stpcpy 923 # else 924 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 925 YYDEST. */ 926 static char * 927 yystpcpy (char *yydest, const char *yysrc) 928 { 929 char *yyd = yydest; 930 const char *yys = yysrc; 931 932 while ((*yyd++ = *yys++) != '\0') 933 continue; 934 935 return yyd - 1; 936 } 937 # endif 938 # endif 939 940 # ifndef yytnamerr 941 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 942 quotes and backslashes, so that it's suitable for yyerror. The 943 heuristic is that double-quoting is unnecessary unless the string 944 contains an apostrophe, a comma, or backslash (other than 945 backslash-backslash). YYSTR is taken from yytname. If YYRES is 946 null, do not copy; instead, return the length of what the result 947 would have been. */ 948 static YYSIZE_T 949 yytnamerr (char *yyres, const char *yystr) 950 { 951 if (*yystr == '"') 952 { 953 YYSIZE_T yyn = 0; 954 char const *yyp = yystr; 955 956 for (;;) 957 switch (*++yyp) 958 { 959 case '\'': 960 case ',': 961 goto do_not_strip_quotes; 962 963 case '\\': 964 if (*++yyp != '\\') 965 goto do_not_strip_quotes; 966 /* Fall through. */ 967 default: 968 if (yyres) 969 yyres[yyn] = *yyp; 970 yyn++; 971 break; 972 973 case '"': 974 if (yyres) 975 yyres[yyn] = '\0'; 976 return yyn; 977 } 978 do_not_strip_quotes: ; 979 } 980 981 if (! yyres) 982 return yystrlen (yystr); 983 984 return yystpcpy (yyres, yystr) - yyres; 985 } 986 # endif 987 988 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message 989 about the unexpected token YYTOKEN for the state stack whose top is 990 YYSSP. 991 992 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is 993 not large enough to hold the message. In that case, also set 994 *YYMSG_ALLOC to the required number of bytes. Return 2 if the 995 required number of bytes is too large to store. */ 996 static int 997 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, 998 yytype_int16 *yyssp, int yytoken) 999 { 1000 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); 1001 YYSIZE_T yysize = yysize0; 1002 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1003 /* Internationalized format string. */ 1004 const char *yyformat = YY_NULLPTR; 1005 /* Arguments of yyformat. */ 1006 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1007 /* Number of reported tokens (one for the "unexpected", one per 1008 "expected"). */ 1009 int yycount = 0; 1010 1011 /* There are many possibilities here to consider: 1012 - If this state is a consistent state with a default action, then 1013 the only way this function was invoked is if the default action 1014 is an error action. In that case, don't check for expected 1015 tokens because there are none. 1016 - The only way there can be no lookahead present (in yychar) is if 1017 this state is a consistent state with a default action. Thus, 1018 detecting the absence of a lookahead is sufficient to determine 1019 that there is no unexpected or expected token to report. In that 1020 case, just report a simple "syntax error". 1021 - Don't assume there isn't a lookahead just because this state is a 1022 consistent state with a default action. There might have been a 1023 previous inconsistent state, consistent state with a non-default 1024 action, or user semantic action that manipulated yychar. 1025 - Of course, the expected token list depends on states to have 1026 correct lookahead information, and it depends on the parser not 1027 to perform extra reductions after fetching a lookahead from the 1028 scanner and before detecting a syntax error. Thus, state merging 1029 (from LALR or IELR) and default reductions corrupt the expected 1030 token list. However, the list is correct for canonical LR with 1031 one exception: it will still contain any token that will not be 1032 accepted due to an error action in a later state. 1033 */ 1034 if (yytoken != YYEMPTY) 1035 { 1036 int yyn = yypact[*yyssp]; 1037 yyarg[yycount++] = yytname[yytoken]; 1038 if (!yypact_value_is_default (yyn)) 1039 { 1040 /* Start YYX at -YYN if negative to avoid negative indexes in 1041 YYCHECK. In other words, skip the first -YYN actions for 1042 this state because they are default actions. */ 1043 int yyxbegin = yyn < 0 ? -yyn : 0; 1044 /* Stay within bounds of both yycheck and yytname. */ 1045 int yychecklim = YYLAST - yyn + 1; 1046 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1047 int yyx; 1048 1049 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1050 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR 1051 && !yytable_value_is_error (yytable[yyx + yyn])) 1052 { 1053 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1054 { 1055 yycount = 1; 1056 yysize = yysize0; 1057 break; 1058 } 1059 yyarg[yycount++] = yytname[yyx]; 1060 { 1061 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); 1062 if (! (yysize <= yysize1 1063 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1064 return 2; 1065 yysize = yysize1; 1066 } 1067 } 1068 } 1069 } 1070 1071 switch (yycount) 1072 { 1073 # define YYCASE_(N, S) \ 1074 case N: \ 1075 yyformat = S; \ 1076 break 1077 default: /* Avoid compiler warnings. */ 1078 YYCASE_(0, YY_("syntax error")); 1079 YYCASE_(1, YY_("syntax error, unexpected %s")); 1080 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); 1081 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); 1082 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); 1083 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); 1084 # undef YYCASE_ 1085 } 1086 1087 { 1088 YYSIZE_T yysize1 = yysize + yystrlen (yyformat); 1089 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) 1090 return 2; 1091 yysize = yysize1; 1092 } 1093 1094 if (*yymsg_alloc < yysize) 1095 { 1096 *yymsg_alloc = 2 * yysize; 1097 if (! (yysize <= *yymsg_alloc 1098 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) 1099 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; 1100 return 1; 1101 } 1102 1103 /* Avoid sprintf, as that infringes on the user's name space. 1104 Don't have undefined behavior even if the translation 1105 produced a string with the wrong number of "%s"s. */ 1106 { 1107 char *yyp = *yymsg; 1108 int yyi = 0; 1109 while ((*yyp = *yyformat) != '\0') 1110 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) 1111 { 1112 yyp += yytnamerr (yyp, yyarg[yyi++]); 1113 yyformat += 2; 1114 } 1115 else 1116 { 1117 yyp++; 1118 yyformat++; 1119 } 1120 } 1121 return 0; 1122 } 1123 #endif /* YYERROR_VERBOSE */ 1124 1125 /*-----------------------------------------------. 1126 | Release the memory associated to this symbol. | 1127 `-----------------------------------------------*/ 1128 1129 static void 1130 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1131 { 1132 YYUSE (yyvaluep); 1133 if (!yymsg) 1134 yymsg = "Deleting"; 1135 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1136 1137 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1138 YYUSE (yytype); 1139 YY_IGNORE_MAYBE_UNINITIALIZED_END 1140 } 1141 1142 1143 1144 1145 /* The lookahead symbol. */ 1146 int yychar; 1147 1148 /* The semantic value of the lookahead symbol. */ 1149 YYSTYPE yylval; 1150 /* Number of syntax errors so far. */ 1151 int yynerrs; 1152 1153 1154 /*----------. 1155 | yyparse. | 1156 `----------*/ 1157 1158 int 1159 yyparse (void) 1160 { 1161 int yystate; 1162 /* Number of tokens to shift before error messages enabled. */ 1163 int yyerrstatus; 1164 1165 /* The stacks and their tools: 1166 'yyss': related to states. 1167 'yyvs': related to semantic values. 1168 1169 Refer to the stacks through separate pointers, to allow yyoverflow 1170 to reallocate them elsewhere. */ 1171 1172 /* The state stack. */ 1173 yytype_int16 yyssa[YYINITDEPTH]; 1174 yytype_int16 *yyss; 1175 yytype_int16 *yyssp; 1176 1177 /* The semantic value stack. */ 1178 YYSTYPE yyvsa[YYINITDEPTH]; 1179 YYSTYPE *yyvs; 1180 YYSTYPE *yyvsp; 1181 1182 YYSIZE_T yystacksize; 1183 1184 int yyn; 1185 int yyresult; 1186 /* Lookahead token as an internal (translated) token number. */ 1187 int yytoken = 0; 1188 /* The variables used to return semantic value and location from the 1189 action routines. */ 1190 YYSTYPE yyval; 1191 1192 #if YYERROR_VERBOSE 1193 /* Buffer for error messages, and its allocated size. */ 1194 char yymsgbuf[128]; 1195 char *yymsg = yymsgbuf; 1196 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1197 #endif 1198 1199 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1200 1201 /* The number of symbols on the RHS of the reduced rule. 1202 Keep to zero when no symbol should be popped. */ 1203 int yylen = 0; 1204 1205 yyssp = yyss = yyssa; 1206 yyvsp = yyvs = yyvsa; 1207 yystacksize = YYINITDEPTH; 1208 1209 YYDPRINTF ((stderr, "Starting parse\n")); 1210 1211 yystate = 0; 1212 yyerrstatus = 0; 1213 yynerrs = 0; 1214 yychar = YYEMPTY; /* Cause a token to be read. */ 1215 goto yysetstate; 1216 1217 /*------------------------------------------------------------. 1218 | yynewstate -- Push a new state, which is found in yystate. | 1219 `------------------------------------------------------------*/ 1220 yynewstate: 1221 /* In all cases, when you get here, the value and location stacks 1222 have just been pushed. So pushing a state here evens the stacks. */ 1223 yyssp++; 1224 1225 yysetstate: 1226 *yyssp = yystate; 1227 1228 if (yyss + yystacksize - 1 <= yyssp) 1229 { 1230 /* Get the current used size of the three stacks, in elements. */ 1231 YYSIZE_T yysize = yyssp - yyss + 1; 1232 1233 #ifdef yyoverflow 1234 { 1235 /* Give user a chance to reallocate the stack. Use copies of 1236 these so that the &'s don't force the real ones into 1237 memory. */ 1238 YYSTYPE *yyvs1 = yyvs; 1239 yytype_int16 *yyss1 = yyss; 1240 1241 /* Each stack pointer address is followed by the size of the 1242 data in use in that stack, in bytes. This used to be a 1243 conditional around just the two extra args, but that might 1244 be undefined if yyoverflow is a macro. */ 1245 yyoverflow (YY_("memory exhausted"), 1246 &yyss1, yysize * sizeof (*yyssp), 1247 &yyvs1, yysize * sizeof (*yyvsp), 1248 &yystacksize); 1249 1250 yyss = yyss1; 1251 yyvs = yyvs1; 1252 } 1253 #else /* no yyoverflow */ 1254 # ifndef YYSTACK_RELOCATE 1255 goto yyexhaustedlab; 1256 # else 1257 /* Extend the stack our own way. */ 1258 if (YYMAXDEPTH <= yystacksize) 1259 goto yyexhaustedlab; 1260 yystacksize *= 2; 1261 if (YYMAXDEPTH < yystacksize) 1262 yystacksize = YYMAXDEPTH; 1263 1264 { 1265 yytype_int16 *yyss1 = yyss; 1266 union yyalloc *yyptr = 1267 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1268 if (! yyptr) 1269 goto yyexhaustedlab; 1270 YYSTACK_RELOCATE (yyss_alloc, yyss); 1271 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1272 # undef YYSTACK_RELOCATE 1273 if (yyss1 != yyssa) 1274 YYSTACK_FREE (yyss1); 1275 } 1276 # endif 1277 #endif /* no yyoverflow */ 1278 1279 yyssp = yyss + yysize - 1; 1280 yyvsp = yyvs + yysize - 1; 1281 1282 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1283 (unsigned long int) yystacksize)); 1284 1285 if (yyss + yystacksize - 1 <= yyssp) 1286 YYABORT; 1287 } 1288 1289 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1290 1291 if (yystate == YYFINAL) 1292 YYACCEPT; 1293 1294 goto yybackup; 1295 1296 /*-----------. 1297 | yybackup. | 1298 `-----------*/ 1299 yybackup: 1300 1301 /* Do appropriate processing given the current state. Read a 1302 lookahead token if we need one and don't already have one. */ 1303 1304 /* First try to decide what to do without reference to lookahead token. */ 1305 yyn = yypact[yystate]; 1306 if (yypact_value_is_default (yyn)) 1307 goto yydefault; 1308 1309 /* Not known => get a lookahead token if don't already have one. */ 1310 1311 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1312 if (yychar == YYEMPTY) 1313 { 1314 YYDPRINTF ((stderr, "Reading a token: ")); 1315 yychar = yylex (); 1316 } 1317 1318 if (yychar <= YYEOF) 1319 { 1320 yychar = yytoken = YYEOF; 1321 YYDPRINTF ((stderr, "Now at end of input.\n")); 1322 } 1323 else 1324 { 1325 yytoken = YYTRANSLATE (yychar); 1326 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1327 } 1328 1329 /* If the proper action on seeing token YYTOKEN is to reduce or to 1330 detect an error, take that action. */ 1331 yyn += yytoken; 1332 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1333 goto yydefault; 1334 yyn = yytable[yyn]; 1335 if (yyn <= 0) 1336 { 1337 if (yytable_value_is_error (yyn)) 1338 goto yyerrlab; 1339 yyn = -yyn; 1340 goto yyreduce; 1341 } 1342 1343 /* Count tokens shifted since error; after three, turn off error 1344 status. */ 1345 if (yyerrstatus) 1346 yyerrstatus--; 1347 1348 /* Shift the lookahead token. */ 1349 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1350 1351 /* Discard the shifted token. */ 1352 yychar = YYEMPTY; 1353 1354 yystate = yyn; 1355 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1356 *++yyvsp = yylval; 1357 YY_IGNORE_MAYBE_UNINITIALIZED_END 1358 1359 goto yynewstate; 1360 1361 1362 /*-----------------------------------------------------------. 1363 | yydefault -- do the default action for the current state. | 1364 `-----------------------------------------------------------*/ 1365 yydefault: 1366 yyn = yydefact[yystate]; 1367 if (yyn == 0) 1368 goto yyerrlab; 1369 goto yyreduce; 1370 1371 1372 /*-----------------------------. 1373 | yyreduce -- Do a reduction. | 1374 `-----------------------------*/ 1375 yyreduce: 1376 /* yyn is the number of a rule to reduce with. */ 1377 yylen = yyr2[yyn]; 1378 1379 /* If YYLEN is nonzero, implement the default value of the action: 1380 '$$ = $1'. 1381 1382 Otherwise, the following line sets YYVAL to garbage. 1383 This behavior is undocumented and Bison 1384 users should not rely upon it. Assigning to YYVAL 1385 unconditionally makes the parser a bit smaller, and it avoids a 1386 GCC warning that YYVAL may be used uninitialized. */ 1387 yyval = yyvsp[1-yylen]; 1388 1389 1390 YY_REDUCE_PRINT (yyn); 1391 switch (yyn) 1392 { 1393 case 4: 1394 #line 53 "defparse.y" /* yacc.c:1648 */ 1395 { def_name ((yyvsp[-1].id), (yyvsp[0].number)); } 1396 #line 1397 "defparse.c" /* yacc.c:1648 */ 1397 break; 1398 1399 case 5: 1400 #line 54 "defparse.y" /* yacc.c:1648 */ 1401 { def_library ((yyvsp[-2].id), (yyvsp[-1].number)); } 1402 #line 1403 "defparse.c" /* yacc.c:1648 */ 1403 break; 1404 1405 case 7: 1406 #line 56 "defparse.y" /* yacc.c:1648 */ 1407 { def_description ((yyvsp[0].id));} 1408 #line 1409 "defparse.c" /* yacc.c:1648 */ 1409 break; 1410 1411 case 8: 1412 #line 57 "defparse.y" /* yacc.c:1648 */ 1413 { def_stacksize ((yyvsp[-1].number), (yyvsp[0].number));} 1414 #line 1415 "defparse.c" /* yacc.c:1648 */ 1415 break; 1416 1417 case 9: 1418 #line 58 "defparse.y" /* yacc.c:1648 */ 1419 { def_heapsize ((yyvsp[-1].number), (yyvsp[0].number));} 1420 #line 1421 "defparse.c" /* yacc.c:1648 */ 1421 break; 1422 1423 case 10: 1424 #line 59 "defparse.y" /* yacc.c:1648 */ 1425 { def_code ((yyvsp[0].number));} 1426 #line 1427 "defparse.c" /* yacc.c:1648 */ 1427 break; 1428 1429 case 11: 1430 #line 60 "defparse.y" /* yacc.c:1648 */ 1431 { def_data ((yyvsp[0].number));} 1432 #line 1433 "defparse.c" /* yacc.c:1648 */ 1433 break; 1434 1435 case 14: 1436 #line 63 "defparse.y" /* yacc.c:1648 */ 1437 { def_version ((yyvsp[0].number),0);} 1438 #line 1439 "defparse.c" /* yacc.c:1648 */ 1439 break; 1440 1441 case 15: 1442 #line 64 "defparse.y" /* yacc.c:1648 */ 1443 { def_version ((yyvsp[-2].number),(yyvsp[0].number));} 1444 #line 1445 "defparse.c" /* yacc.c:1648 */ 1445 break; 1446 1447 case 18: 1448 #line 76 "defparse.y" /* yacc.c:1648 */ 1449 { def_exports ((yyvsp[-7].id), (yyvsp[-6].id), (yyvsp[-5].number), (yyvsp[-4].number), (yyvsp[-3].number), (yyvsp[-2].number), (yyvsp[-1].number), (yyvsp[0].id));} 1450 #line 1451 "defparse.c" /* yacc.c:1648 */ 1451 break; 1452 1453 case 21: 1454 #line 85 "defparse.y" /* yacc.c:1648 */ 1455 { def_import ((yyvsp[-7].id),(yyvsp[-5].id),(yyvsp[-3].id),(yyvsp[-1].id), 0, (yyvsp[0].id)); } 1456 #line 1457 "defparse.c" /* yacc.c:1648 */ 1457 break; 1458 1459 case 22: 1460 #line 87 "defparse.y" /* yacc.c:1648 */ 1461 { def_import ((yyvsp[-7].id),(yyvsp[-5].id),(yyvsp[-3].id), 0,(yyvsp[-1].number), (yyvsp[0].id)); } 1462 #line 1463 "defparse.c" /* yacc.c:1648 */ 1463 break; 1464 1465 case 23: 1466 #line 89 "defparse.y" /* yacc.c:1648 */ 1467 { def_import ((yyvsp[-5].id),(yyvsp[-3].id), 0,(yyvsp[-1].id), 0, (yyvsp[0].id)); } 1468 #line 1469 "defparse.c" /* yacc.c:1648 */ 1469 break; 1470 1471 case 24: 1472 #line 91 "defparse.y" /* yacc.c:1648 */ 1473 { def_import ((yyvsp[-5].id),(yyvsp[-3].id), 0, 0,(yyvsp[-1].number), (yyvsp[0].id)); } 1474 #line 1475 "defparse.c" /* yacc.c:1648 */ 1475 break; 1476 1477 case 25: 1478 #line 93 "defparse.y" /* yacc.c:1648 */ 1479 { def_import ( 0,(yyvsp[-5].id),(yyvsp[-3].id),(yyvsp[-1].id), 0, (yyvsp[0].id)); } 1480 #line 1481 "defparse.c" /* yacc.c:1648 */ 1481 break; 1482 1483 case 26: 1484 #line 95 "defparse.y" /* yacc.c:1648 */ 1485 { def_import ( 0,(yyvsp[-5].id),(yyvsp[-3].id), 0,(yyvsp[-1].number), (yyvsp[0].id)); } 1486 #line 1487 "defparse.c" /* yacc.c:1648 */ 1487 break; 1488 1489 case 27: 1490 #line 97 "defparse.y" /* yacc.c:1648 */ 1491 { def_import ( 0,(yyvsp[-3].id), 0,(yyvsp[-1].id), 0, (yyvsp[0].id)); } 1492 #line 1493 "defparse.c" /* yacc.c:1648 */ 1493 break; 1494 1495 case 28: 1496 #line 99 "defparse.y" /* yacc.c:1648 */ 1497 { def_import ( 0,(yyvsp[-3].id), 0, 0,(yyvsp[-1].number), (yyvsp[0].id)); } 1498 #line 1499 "defparse.c" /* yacc.c:1648 */ 1499 break; 1500 1501 case 31: 1502 #line 108 "defparse.y" /* yacc.c:1648 */ 1503 { def_section ((yyvsp[-1].id),(yyvsp[0].number));} 1504 #line 1505 "defparse.c" /* yacc.c:1648 */ 1505 break; 1506 1507 case 36: 1508 #line 120 "defparse.y" /* yacc.c:1648 */ 1509 { (yyval.number)=(yyvsp[0].number);} 1510 #line 1511 "defparse.c" /* yacc.c:1648 */ 1511 break; 1512 1513 case 37: 1514 #line 121 "defparse.y" /* yacc.c:1648 */ 1515 { (yyval.number)=-1;} 1516 #line 1517 "defparse.c" /* yacc.c:1648 */ 1517 break; 1518 1519 case 38: 1520 #line 125 "defparse.y" /* yacc.c:1648 */ 1521 { (yyval.number) = 1; } 1522 #line 1523 "defparse.c" /* yacc.c:1648 */ 1523 break; 1524 1525 case 39: 1526 #line 126 "defparse.y" /* yacc.c:1648 */ 1527 { (yyval.number) = 2; } 1528 #line 1529 "defparse.c" /* yacc.c:1648 */ 1529 break; 1530 1531 case 40: 1532 #line 127 "defparse.y" /* yacc.c:1648 */ 1533 { (yyval.number) = 4; } 1534 #line 1535 "defparse.c" /* yacc.c:1648 */ 1535 break; 1536 1537 case 41: 1538 #line 128 "defparse.y" /* yacc.c:1648 */ 1539 { (yyval.number) = 8; } 1540 #line 1541 "defparse.c" /* yacc.c:1648 */ 1541 break; 1542 1543 case 42: 1544 #line 129 "defparse.y" /* yacc.c:1648 */ 1545 { (yyval.number) = 0; } 1546 #line 1547 "defparse.c" /* yacc.c:1648 */ 1547 break; 1548 1549 case 43: 1550 #line 130 "defparse.y" /* yacc.c:1648 */ 1551 { (yyval.number) = 0; } 1552 #line 1553 "defparse.c" /* yacc.c:1648 */ 1553 break; 1554 1555 case 44: 1556 #line 131 "defparse.y" /* yacc.c:1648 */ 1557 { (yyval.number) = 0; } 1558 #line 1559 "defparse.c" /* yacc.c:1648 */ 1559 break; 1560 1561 case 45: 1562 #line 135 "defparse.y" /* yacc.c:1648 */ 1563 {(yyval.number)=1;} 1564 #line 1565 "defparse.c" /* yacc.c:1648 */ 1565 break; 1566 1567 case 46: 1568 #line 136 "defparse.y" /* yacc.c:1648 */ 1569 {(yyval.number)=0;} 1570 #line 1571 "defparse.c" /* yacc.c:1648 */ 1571 break; 1572 1573 case 47: 1574 #line 140 "defparse.y" /* yacc.c:1648 */ 1575 {(yyval.number)=1;} 1576 #line 1577 "defparse.c" /* yacc.c:1648 */ 1577 break; 1578 1579 case 48: 1580 #line 141 "defparse.y" /* yacc.c:1648 */ 1581 {(yyval.number)=0;} 1582 #line 1583 "defparse.c" /* yacc.c:1648 */ 1583 break; 1584 1585 case 49: 1586 #line 145 "defparse.y" /* yacc.c:1648 */ 1587 { (yyval.number) = 1; } 1588 #line 1589 "defparse.c" /* yacc.c:1648 */ 1589 break; 1590 1591 case 50: 1592 #line 146 "defparse.y" /* yacc.c:1648 */ 1593 { (yyval.number) = 0; } 1594 #line 1595 "defparse.c" /* yacc.c:1648 */ 1595 break; 1596 1597 case 51: 1598 #line 150 "defparse.y" /* yacc.c:1648 */ 1599 { (yyval.number) = 1; } 1600 #line 1601 "defparse.c" /* yacc.c:1648 */ 1601 break; 1602 1603 case 52: 1604 #line 151 "defparse.y" /* yacc.c:1648 */ 1605 { (yyval.number) = 0; } 1606 #line 1607 "defparse.c" /* yacc.c:1648 */ 1607 break; 1608 1609 case 53: 1610 #line 154 "defparse.y" /* yacc.c:1648 */ 1611 { (yyval.id_const) = "NAME"; } 1612 #line 1613 "defparse.c" /* yacc.c:1648 */ 1613 break; 1614 1615 case 54: 1616 #line 159 "defparse.y" /* yacc.c:1648 */ 1617 { (yyval.id_const) = "DESCRIPTION"; } 1618 #line 1619 "defparse.c" /* yacc.c:1648 */ 1619 break; 1620 1621 case 55: 1622 #line 160 "defparse.y" /* yacc.c:1648 */ 1623 { (yyval.id_const) = "STACKSIZE"; } 1624 #line 1625 "defparse.c" /* yacc.c:1648 */ 1625 break; 1626 1627 case 56: 1628 #line 161 "defparse.y" /* yacc.c:1648 */ 1629 { (yyval.id_const) = "HEAPSIZE"; } 1630 #line 1631 "defparse.c" /* yacc.c:1648 */ 1631 break; 1632 1633 case 57: 1634 #line 162 "defparse.y" /* yacc.c:1648 */ 1635 { (yyval.id_const) = "CODE"; } 1636 #line 1637 "defparse.c" /* yacc.c:1648 */ 1637 break; 1638 1639 case 58: 1640 #line 163 "defparse.y" /* yacc.c:1648 */ 1641 { (yyval.id_const) = "DATA"; } 1642 #line 1643 "defparse.c" /* yacc.c:1648 */ 1643 break; 1644 1645 case 59: 1646 #line 164 "defparse.y" /* yacc.c:1648 */ 1647 { (yyval.id_const) = "SECTIONS"; } 1648 #line 1649 "defparse.c" /* yacc.c:1648 */ 1649 break; 1650 1651 case 60: 1652 #line 165 "defparse.y" /* yacc.c:1648 */ 1653 { (yyval.id_const) = "EXPORTS"; } 1654 #line 1655 "defparse.c" /* yacc.c:1648 */ 1655 break; 1656 1657 case 61: 1658 #line 166 "defparse.y" /* yacc.c:1648 */ 1659 { (yyval.id_const) = "IMPORTS"; } 1660 #line 1661 "defparse.c" /* yacc.c:1648 */ 1661 break; 1662 1663 case 62: 1664 #line 167 "defparse.y" /* yacc.c:1648 */ 1665 { (yyval.id_const) = "VERSION"; } 1666 #line 1667 "defparse.c" /* yacc.c:1648 */ 1667 break; 1668 1669 case 63: 1670 #line 168 "defparse.y" /* yacc.c:1648 */ 1671 { (yyval.id_const) = "BASE"; } 1672 #line 1673 "defparse.c" /* yacc.c:1648 */ 1673 break; 1674 1675 case 64: 1676 #line 169 "defparse.y" /* yacc.c:1648 */ 1677 { (yyval.id_const) = "CONSTANT"; } 1678 #line 1679 "defparse.c" /* yacc.c:1648 */ 1679 break; 1680 1681 case 65: 1682 #line 170 "defparse.y" /* yacc.c:1648 */ 1683 { (yyval.id_const) = "NONAME"; } 1684 #line 1685 "defparse.c" /* yacc.c:1648 */ 1685 break; 1686 1687 case 66: 1688 #line 171 "defparse.y" /* yacc.c:1648 */ 1689 { (yyval.id_const) = "PRIVATE"; } 1690 #line 1691 "defparse.c" /* yacc.c:1648 */ 1691 break; 1692 1693 case 67: 1694 #line 172 "defparse.y" /* yacc.c:1648 */ 1695 { (yyval.id_const) = "READ"; } 1696 #line 1697 "defparse.c" /* yacc.c:1648 */ 1697 break; 1698 1699 case 68: 1700 #line 173 "defparse.y" /* yacc.c:1648 */ 1701 { (yyval.id_const) = "WRITE"; } 1702 #line 1703 "defparse.c" /* yacc.c:1648 */ 1703 break; 1704 1705 case 69: 1706 #line 174 "defparse.y" /* yacc.c:1648 */ 1707 { (yyval.id_const) = "EXECUTE"; } 1708 #line 1709 "defparse.c" /* yacc.c:1648 */ 1709 break; 1710 1711 case 70: 1712 #line 175 "defparse.y" /* yacc.c:1648 */ 1713 { (yyval.id_const) = "SHARED"; } 1714 #line 1715 "defparse.c" /* yacc.c:1648 */ 1715 break; 1716 1717 case 71: 1718 #line 176 "defparse.y" /* yacc.c:1648 */ 1719 { (yyval.id_const) = "NONSHARED"; } 1720 #line 1721 "defparse.c" /* yacc.c:1648 */ 1721 break; 1722 1723 case 72: 1724 #line 177 "defparse.y" /* yacc.c:1648 */ 1725 { (yyval.id_const) = "SINGLE"; } 1726 #line 1727 "defparse.c" /* yacc.c:1648 */ 1727 break; 1728 1729 case 73: 1730 #line 178 "defparse.y" /* yacc.c:1648 */ 1731 { (yyval.id_const) = "MULTIPLE"; } 1732 #line 1733 "defparse.c" /* yacc.c:1648 */ 1733 break; 1734 1735 case 74: 1736 #line 179 "defparse.y" /* yacc.c:1648 */ 1737 { (yyval.id_const) = "INITINSTANCE"; } 1738 #line 1739 "defparse.c" /* yacc.c:1648 */ 1739 break; 1740 1741 case 75: 1742 #line 180 "defparse.y" /* yacc.c:1648 */ 1743 { (yyval.id_const) = "INITGLOBAL"; } 1744 #line 1745 "defparse.c" /* yacc.c:1648 */ 1745 break; 1746 1747 case 76: 1748 #line 181 "defparse.y" /* yacc.c:1648 */ 1749 { (yyval.id_const) = "TERMINSTANCE"; } 1750 #line 1751 "defparse.c" /* yacc.c:1648 */ 1751 break; 1752 1753 case 77: 1754 #line 182 "defparse.y" /* yacc.c:1648 */ 1755 { (yyval.id_const) = "TERMGLOBAL"; } 1756 #line 1757 "defparse.c" /* yacc.c:1648 */ 1757 break; 1758 1759 case 78: 1760 #line 185 "defparse.y" /* yacc.c:1648 */ 1761 { (yyval.id) = (yyvsp[0].id); } 1762 #line 1763 "defparse.c" /* yacc.c:1648 */ 1763 break; 1764 1765 case 79: 1766 #line 187 "defparse.y" /* yacc.c:1648 */ 1767 { 1768 char *name = xmalloc (strlen ((yyvsp[0].id_const)) + 2); 1769 sprintf (name, ".%s", (yyvsp[0].id_const)); 1770 (yyval.id) = name; 1771 } 1772 #line 1773 "defparse.c" /* yacc.c:1648 */ 1773 break; 1774 1775 case 80: 1776 #line 193 "defparse.y" /* yacc.c:1648 */ 1777 { 1778 char *name = xmalloc (strlen ((yyvsp[0].id)) + 2); 1779 sprintf (name, ".%s", (yyvsp[0].id)); 1780 (yyval.id) = name; 1781 } 1782 #line 1783 "defparse.c" /* yacc.c:1648 */ 1783 break; 1784 1785 case 81: 1786 #line 199 "defparse.y" /* yacc.c:1648 */ 1787 { 1788 char *name = xmalloc (strlen ((yyvsp[-2].id_const)) + 1 + strlen ((yyvsp[0].id)) + 1); 1789 sprintf (name, "%s.%s", (yyvsp[-2].id_const), (yyvsp[0].id)); 1790 (yyval.id) = name; 1791 } 1792 #line 1793 "defparse.c" /* yacc.c:1648 */ 1793 break; 1794 1795 case 82: 1796 #line 205 "defparse.y" /* yacc.c:1648 */ 1797 { 1798 char *name = xmalloc (strlen ((yyvsp[-2].id)) + 1 + strlen ((yyvsp[0].id)) + 1); 1799 sprintf (name, "%s.%s", (yyvsp[-2].id), (yyvsp[0].id)); 1800 (yyval.id) = name; 1801 } 1802 #line 1803 "defparse.c" /* yacc.c:1648 */ 1803 break; 1804 1805 case 83: 1806 #line 211 "defparse.y" /* yacc.c:1648 */ 1807 { (yyval.id) =(yyvsp[0].id); } 1808 #line 1809 "defparse.c" /* yacc.c:1648 */ 1809 break; 1810 1811 case 84: 1812 #line 212 "defparse.y" /* yacc.c:1648 */ 1813 { (yyval.id)=""; } 1814 #line 1815 "defparse.c" /* yacc.c:1648 */ 1815 break; 1816 1817 case 85: 1818 #line 216 "defparse.y" /* yacc.c:1648 */ 1819 { (yyval.number)=(yyvsp[0].number);} 1820 #line 1821 "defparse.c" /* yacc.c:1648 */ 1821 break; 1822 1823 case 86: 1824 #line 217 "defparse.y" /* yacc.c:1648 */ 1825 { (yyval.number)=-1;} 1826 #line 1827 "defparse.c" /* yacc.c:1648 */ 1827 break; 1828 1829 case 87: 1830 #line 221 "defparse.y" /* yacc.c:1648 */ 1831 { (yyval.id) = (yyvsp[0].id); } 1832 #line 1833 "defparse.c" /* yacc.c:1648 */ 1833 break; 1834 1835 case 88: 1836 #line 222 "defparse.y" /* yacc.c:1648 */ 1837 { (yyval.id) = 0; } 1838 #line 1839 "defparse.c" /* yacc.c:1648 */ 1839 break; 1840 1841 case 89: 1842 #line 226 "defparse.y" /* yacc.c:1648 */ 1843 { (yyval.id) = (yyvsp[0].id); } 1844 #line 1845 "defparse.c" /* yacc.c:1648 */ 1845 break; 1846 1847 case 90: 1848 #line 227 "defparse.y" /* yacc.c:1648 */ 1849 { (yyval.id) = 0; } 1850 #line 1851 "defparse.c" /* yacc.c:1648 */ 1851 break; 1852 1853 case 91: 1854 #line 230 "defparse.y" /* yacc.c:1648 */ 1855 { (yyval.number)= (yyvsp[0].number);} 1856 #line 1857 "defparse.c" /* yacc.c:1648 */ 1857 break; 1858 1859 case 92: 1860 #line 231 "defparse.y" /* yacc.c:1648 */ 1861 { (yyval.number)=-1;} 1862 #line 1863 "defparse.c" /* yacc.c:1648 */ 1863 break; 1864 1865 1866 #line 1867 "defparse.c" /* yacc.c:1648 */ 1867 default: break; 1868 } 1869 /* User semantic actions sometimes alter yychar, and that requires 1870 that yytoken be updated with the new translation. We take the 1871 approach of translating immediately before every use of yytoken. 1872 One alternative is translating here after every semantic action, 1873 but that translation would be missed if the semantic action invokes 1874 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 1875 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 1876 incorrect destructor might then be invoked immediately. In the 1877 case of YYERROR or YYBACKUP, subsequent parser actions might lead 1878 to an incorrect destructor call or verbose syntax error message 1879 before the lookahead is translated. */ 1880 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1881 1882 YYPOPSTACK (yylen); 1883 yylen = 0; 1884 YY_STACK_PRINT (yyss, yyssp); 1885 1886 *++yyvsp = yyval; 1887 1888 /* Now 'shift' the result of the reduction. Determine what state 1889 that goes to, based on the state we popped back to and the rule 1890 number reduced by. */ 1891 1892 yyn = yyr1[yyn]; 1893 1894 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1895 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1896 yystate = yytable[yystate]; 1897 else 1898 yystate = yydefgoto[yyn - YYNTOKENS]; 1899 1900 goto yynewstate; 1901 1902 1903 /*--------------------------------------. 1904 | yyerrlab -- here on detecting error. | 1905 `--------------------------------------*/ 1906 yyerrlab: 1907 /* Make sure we have latest lookahead translation. See comments at 1908 user semantic actions for why this is necessary. */ 1909 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); 1910 1911 /* If not already recovering from an error, report this error. */ 1912 if (!yyerrstatus) 1913 { 1914 ++yynerrs; 1915 #if ! YYERROR_VERBOSE 1916 yyerror (YY_("syntax error")); 1917 #else 1918 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ 1919 yyssp, yytoken) 1920 { 1921 char const *yymsgp = YY_("syntax error"); 1922 int yysyntax_error_status; 1923 yysyntax_error_status = YYSYNTAX_ERROR; 1924 if (yysyntax_error_status == 0) 1925 yymsgp = yymsg; 1926 else if (yysyntax_error_status == 1) 1927 { 1928 if (yymsg != yymsgbuf) 1929 YYSTACK_FREE (yymsg); 1930 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); 1931 if (!yymsg) 1932 { 1933 yymsg = yymsgbuf; 1934 yymsg_alloc = sizeof yymsgbuf; 1935 yysyntax_error_status = 2; 1936 } 1937 else 1938 { 1939 yysyntax_error_status = YYSYNTAX_ERROR; 1940 yymsgp = yymsg; 1941 } 1942 } 1943 yyerror (yymsgp); 1944 if (yysyntax_error_status == 2) 1945 goto yyexhaustedlab; 1946 } 1947 # undef YYSYNTAX_ERROR 1948 #endif 1949 } 1950 1951 1952 1953 if (yyerrstatus == 3) 1954 { 1955 /* If just tried and failed to reuse lookahead token after an 1956 error, discard it. */ 1957 1958 if (yychar <= YYEOF) 1959 { 1960 /* Return failure if at end of input. */ 1961 if (yychar == YYEOF) 1962 YYABORT; 1963 } 1964 else 1965 { 1966 yydestruct ("Error: discarding", 1967 yytoken, &yylval); 1968 yychar = YYEMPTY; 1969 } 1970 } 1971 1972 /* Else will try to reuse lookahead token after shifting the error 1973 token. */ 1974 goto yyerrlab1; 1975 1976 1977 /*---------------------------------------------------. 1978 | yyerrorlab -- error raised explicitly by YYERROR. | 1979 `---------------------------------------------------*/ 1980 yyerrorlab: 1981 1982 /* Pacify compilers like GCC when the user code never invokes 1983 YYERROR and the label yyerrorlab therefore never appears in user 1984 code. */ 1985 if (/*CONSTCOND*/ 0) 1986 goto yyerrorlab; 1987 1988 /* Do not reclaim the symbols of the rule whose action triggered 1989 this YYERROR. */ 1990 YYPOPSTACK (yylen); 1991 yylen = 0; 1992 YY_STACK_PRINT (yyss, yyssp); 1993 yystate = *yyssp; 1994 goto yyerrlab1; 1995 1996 1997 /*-------------------------------------------------------------. 1998 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1999 `-------------------------------------------------------------*/ 2000 yyerrlab1: 2001 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2002 2003 for (;;) 2004 { 2005 yyn = yypact[yystate]; 2006 if (!yypact_value_is_default (yyn)) 2007 { 2008 yyn += YYTERROR; 2009 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2010 { 2011 yyn = yytable[yyn]; 2012 if (0 < yyn) 2013 break; 2014 } 2015 } 2016 2017 /* Pop the current state because it cannot handle the error token. */ 2018 if (yyssp == yyss) 2019 YYABORT; 2020 2021 2022 yydestruct ("Error: popping", 2023 yystos[yystate], yyvsp); 2024 YYPOPSTACK (1); 2025 yystate = *yyssp; 2026 YY_STACK_PRINT (yyss, yyssp); 2027 } 2028 2029 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2030 *++yyvsp = yylval; 2031 YY_IGNORE_MAYBE_UNINITIALIZED_END 2032 2033 2034 /* Shift the error token. */ 2035 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2036 2037 yystate = yyn; 2038 goto yynewstate; 2039 2040 2041 /*-------------------------------------. 2042 | yyacceptlab -- YYACCEPT comes here. | 2043 `-------------------------------------*/ 2044 yyacceptlab: 2045 yyresult = 0; 2046 goto yyreturn; 2047 2048 /*-----------------------------------. 2049 | yyabortlab -- YYABORT comes here. | 2050 `-----------------------------------*/ 2051 yyabortlab: 2052 yyresult = 1; 2053 goto yyreturn; 2054 2055 #if !defined yyoverflow || YYERROR_VERBOSE 2056 /*-------------------------------------------------. 2057 | yyexhaustedlab -- memory exhaustion comes here. | 2058 `-------------------------------------------------*/ 2059 yyexhaustedlab: 2060 yyerror (YY_("memory exhausted")); 2061 yyresult = 2; 2062 /* Fall through. */ 2063 #endif 2064 2065 yyreturn: 2066 if (yychar != YYEMPTY) 2067 { 2068 /* Make sure we have latest lookahead translation. See comments at 2069 user semantic actions for why this is necessary. */ 2070 yytoken = YYTRANSLATE (yychar); 2071 yydestruct ("Cleanup: discarding lookahead", 2072 yytoken, &yylval); 2073 } 2074 /* Do not reclaim the symbols of the rule whose action triggered 2075 this YYABORT or YYACCEPT. */ 2076 YYPOPSTACK (yylen); 2077 YY_STACK_PRINT (yyss, yyssp); 2078 while (yyssp != yyss) 2079 { 2080 yydestruct ("Cleanup: popping", 2081 yystos[*yyssp], yyvsp); 2082 YYPOPSTACK (1); 2083 } 2084 #ifndef yyoverflow 2085 if (yyss != yyssa) 2086 YYSTACK_FREE (yyss); 2087 #endif 2088 #if YYERROR_VERBOSE 2089 if (yymsg != yymsgbuf) 2090 YYSTACK_FREE (yymsg); 2091 #endif 2092 return yyresult; 2093 } 2094