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