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