ldgram.c revision 1.1.1.2
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 INT = 258, 70 NAME = 259, 71 LNAME = 260, 72 OREQ = 261, 73 ANDEQ = 262, 74 RSHIFTEQ = 263, 75 LSHIFTEQ = 264, 76 DIVEQ = 265, 77 MULTEQ = 266, 78 MINUSEQ = 267, 79 PLUSEQ = 268, 80 OROR = 269, 81 ANDAND = 270, 82 NE = 271, 83 EQ = 272, 84 GE = 273, 85 LE = 274, 86 RSHIFT = 275, 87 LSHIFT = 276, 88 UNARY = 277, 89 END = 278, 90 ALIGN_K = 279, 91 BLOCK = 280, 92 BIND = 281, 93 QUAD = 282, 94 SQUAD = 283, 95 LONG = 284, 96 SHORT = 285, 97 BYTE = 286, 98 SECTIONS = 287, 99 PHDRS = 288, 100 INSERT_K = 289, 101 AFTER = 290, 102 BEFORE = 291, 103 DATA_SEGMENT_ALIGN = 292, 104 DATA_SEGMENT_RELRO_END = 293, 105 DATA_SEGMENT_END = 294, 106 SORT_BY_NAME = 295, 107 SORT_BY_ALIGNMENT = 296, 108 SIZEOF_HEADERS = 297, 109 OUTPUT_FORMAT = 298, 110 FORCE_COMMON_ALLOCATION = 299, 111 OUTPUT_ARCH = 300, 112 INHIBIT_COMMON_ALLOCATION = 301, 113 SEGMENT_START = 302, 114 INCLUDE = 303, 115 MEMORY = 304, 116 REGION_ALIAS = 305, 117 LD_FEATURE = 306, 118 NOLOAD = 307, 119 DSECT = 308, 120 COPY = 309, 121 INFO = 310, 122 OVERLAY = 311, 123 DEFINED = 312, 124 TARGET_K = 313, 125 SEARCH_DIR = 314, 126 MAP = 315, 127 ENTRY = 316, 128 NEXT = 317, 129 SIZEOF = 318, 130 ALIGNOF = 319, 131 ADDR = 320, 132 LOADADDR = 321, 133 MAX_K = 322, 134 MIN_K = 323, 135 STARTUP = 324, 136 HLL = 325, 137 SYSLIB = 326, 138 FLOAT = 327, 139 NOFLOAT = 328, 140 NOCROSSREFS = 329, 141 ORIGIN = 330, 142 FILL = 331, 143 LENGTH = 332, 144 CREATE_OBJECT_SYMBOLS = 333, 145 INPUT = 334, 146 GROUP = 335, 147 OUTPUT = 336, 148 CONSTRUCTORS = 337, 149 ALIGNMOD = 338, 150 AT = 339, 151 SUBALIGN = 340, 152 PROVIDE = 341, 153 PROVIDE_HIDDEN = 342, 154 AS_NEEDED = 343, 155 CHIP = 344, 156 LIST = 345, 157 SECT = 346, 158 ABSOLUTE = 347, 159 LOAD = 348, 160 NEWLINE = 349, 161 ENDWORD = 350, 162 ORDER = 351, 163 NAMEWORD = 352, 164 ASSERT_K = 353, 165 FORMAT = 354, 166 PUBLIC = 355, 167 DEFSYMEND = 356, 168 BASE = 357, 169 ALIAS = 358, 170 TRUNCATE = 359, 171 REL = 360, 172 INPUT_SCRIPT = 361, 173 INPUT_MRI_SCRIPT = 362, 174 INPUT_DEFSYM = 363, 175 CASE = 364, 176 EXTERN = 365, 177 START = 366, 178 VERS_TAG = 367, 179 VERS_IDENTIFIER = 368, 180 GLOBAL = 369, 181 LOCAL = 370, 182 VERSIONK = 371, 183 INPUT_VERSION_SCRIPT = 372, 184 KEEP = 373, 185 ONLY_IF_RO = 374, 186 ONLY_IF_RW = 375, 187 SPECIAL = 376, 188 EXCLUDE_FILE = 377, 189 CONSTANT = 378, 190 INPUT_DYNAMIC_LIST = 379 191 }; 192 #endif 193 /* Tokens. */ 194 #define INT 258 195 #define NAME 259 196 #define LNAME 260 197 #define OREQ 261 198 #define ANDEQ 262 199 #define RSHIFTEQ 263 200 #define LSHIFTEQ 264 201 #define DIVEQ 265 202 #define MULTEQ 266 203 #define MINUSEQ 267 204 #define PLUSEQ 268 205 #define OROR 269 206 #define ANDAND 270 207 #define NE 271 208 #define EQ 272 209 #define GE 273 210 #define LE 274 211 #define RSHIFT 275 212 #define LSHIFT 276 213 #define UNARY 277 214 #define END 278 215 #define ALIGN_K 279 216 #define BLOCK 280 217 #define BIND 281 218 #define QUAD 282 219 #define SQUAD 283 220 #define LONG 284 221 #define SHORT 285 222 #define BYTE 286 223 #define SECTIONS 287 224 #define PHDRS 288 225 #define INSERT_K 289 226 #define AFTER 290 227 #define BEFORE 291 228 #define DATA_SEGMENT_ALIGN 292 229 #define DATA_SEGMENT_RELRO_END 293 230 #define DATA_SEGMENT_END 294 231 #define SORT_BY_NAME 295 232 #define SORT_BY_ALIGNMENT 296 233 #define SIZEOF_HEADERS 297 234 #define OUTPUT_FORMAT 298 235 #define FORCE_COMMON_ALLOCATION 299 236 #define OUTPUT_ARCH 300 237 #define INHIBIT_COMMON_ALLOCATION 301 238 #define SEGMENT_START 302 239 #define INCLUDE 303 240 #define MEMORY 304 241 #define REGION_ALIAS 305 242 #define LD_FEATURE 306 243 #define NOLOAD 307 244 #define DSECT 308 245 #define COPY 309 246 #define INFO 310 247 #define OVERLAY 311 248 #define DEFINED 312 249 #define TARGET_K 313 250 #define SEARCH_DIR 314 251 #define MAP 315 252 #define ENTRY 316 253 #define NEXT 317 254 #define SIZEOF 318 255 #define ALIGNOF 319 256 #define ADDR 320 257 #define LOADADDR 321 258 #define MAX_K 322 259 #define MIN_K 323 260 #define STARTUP 324 261 #define HLL 325 262 #define SYSLIB 326 263 #define FLOAT 327 264 #define NOFLOAT 328 265 #define NOCROSSREFS 329 266 #define ORIGIN 330 267 #define FILL 331 268 #define LENGTH 332 269 #define CREATE_OBJECT_SYMBOLS 333 270 #define INPUT 334 271 #define GROUP 335 272 #define OUTPUT 336 273 #define CONSTRUCTORS 337 274 #define ALIGNMOD 338 275 #define AT 339 276 #define SUBALIGN 340 277 #define PROVIDE 341 278 #define PROVIDE_HIDDEN 342 279 #define AS_NEEDED 343 280 #define CHIP 344 281 #define LIST 345 282 #define SECT 346 283 #define ABSOLUTE 347 284 #define LOAD 348 285 #define NEWLINE 349 286 #define ENDWORD 350 287 #define ORDER 351 288 #define NAMEWORD 352 289 #define ASSERT_K 353 290 #define FORMAT 354 291 #define PUBLIC 355 292 #define DEFSYMEND 356 293 #define BASE 357 294 #define ALIAS 358 295 #define TRUNCATE 359 296 #define REL 360 297 #define INPUT_SCRIPT 361 298 #define INPUT_MRI_SCRIPT 362 299 #define INPUT_DEFSYM 363 300 #define CASE 364 301 #define EXTERN 365 302 #define START 366 303 #define VERS_TAG 367 304 #define VERS_IDENTIFIER 368 305 #define GLOBAL 369 306 #define LOCAL 370 307 #define VERSIONK 371 308 #define INPUT_VERSION_SCRIPT 372 309 #define KEEP 373 310 #define ONLY_IF_RO 374 311 #define ONLY_IF_RW 375 312 #define SPECIAL 376 313 #define EXCLUDE_FILE 377 314 #define CONSTANT 378 315 #define INPUT_DYNAMIC_LIST 379 316 317 318 319 320 /* Copy the first part of user declarations. */ 321 #line 24 "ldgram.y" 322 323 /* 324 325 */ 326 327 #define DONTDECLARE_MALLOC 328 329 #include "sysdep.h" 330 #include "bfd.h" 331 #include "bfdlink.h" 332 #include "ld.h" 333 #include "ldexp.h" 334 #include "ldver.h" 335 #include "ldlang.h" 336 #include "ldfile.h" 337 #include "ldemul.h" 338 #include "ldmisc.h" 339 #include "ldmain.h" 340 #include "mri.h" 341 #include "ldctor.h" 342 #include "ldlex.h" 343 344 #ifndef YYDEBUG 345 #define YYDEBUG 1 346 #endif 347 348 static enum section_type sectype; 349 static lang_memory_region_type *region; 350 351 bfd_boolean ldgram_had_keep = FALSE; 352 char *ldgram_vers_current_lang = NULL; 353 354 #define ERROR_NAME_MAX 20 355 static char *error_names[ERROR_NAME_MAX]; 356 static int error_index; 357 #define PUSH_ERROR(x) if (error_index < ERROR_NAME_MAX) error_names[error_index] = x; error_index++; 358 #define POP_ERROR() error_index--; 359 360 361 /* Enabling traces. */ 362 #ifndef YYDEBUG 363 # define YYDEBUG 0 364 #endif 365 366 /* Enabling verbose error messages. */ 367 #ifdef YYERROR_VERBOSE 368 # undef YYERROR_VERBOSE 369 # define YYERROR_VERBOSE 1 370 #else 371 # define YYERROR_VERBOSE 0 372 #endif 373 374 /* Enabling the token table. */ 375 #ifndef YYTOKEN_TABLE 376 # define YYTOKEN_TABLE 0 377 #endif 378 379 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 380 typedef union YYSTYPE 381 #line 62 "ldgram.y" 382 { 383 bfd_vma integer; 384 struct big_int 385 { 386 bfd_vma integer; 387 char *str; 388 } bigint; 389 fill_type *fill; 390 char *name; 391 const char *cname; 392 struct wildcard_spec wildcard; 393 struct wildcard_list *wildcard_list; 394 struct name_list *name_list; 395 int token; 396 union etree_union *etree; 397 struct phdr_info 398 { 399 bfd_boolean filehdr; 400 bfd_boolean phdrs; 401 union etree_union *at; 402 union etree_union *flags; 403 } phdr; 404 struct lang_nocrossref *nocrossref; 405 struct lang_output_section_phdr_list *section_phdr; 406 struct bfd_elf_version_deps *deflist; 407 struct bfd_elf_version_expr *versyms; 408 struct bfd_elf_version_tree *versnode; 409 } 410 /* Line 193 of yacc.c. */ 411 #line 412 "ldgram.c" 412 YYSTYPE; 413 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 414 # define YYSTYPE_IS_DECLARED 1 415 # define YYSTYPE_IS_TRIVIAL 1 416 #endif 417 418 419 420 /* Copy the second part of user declarations. */ 421 422 423 /* Line 216 of yacc.c. */ 424 #line 425 "ldgram.c" 425 426 #ifdef short 427 # undef short 428 #endif 429 430 #ifdef YYTYPE_UINT8 431 typedef YYTYPE_UINT8 yytype_uint8; 432 #else 433 typedef unsigned char yytype_uint8; 434 #endif 435 436 #ifdef YYTYPE_INT8 437 typedef YYTYPE_INT8 yytype_int8; 438 #elif (defined __STDC__ || defined __C99__FUNC__ \ 439 || defined __cplusplus || defined _MSC_VER) 440 typedef signed char yytype_int8; 441 #else 442 typedef short int yytype_int8; 443 #endif 444 445 #ifdef YYTYPE_UINT16 446 typedef YYTYPE_UINT16 yytype_uint16; 447 #else 448 typedef unsigned short int yytype_uint16; 449 #endif 450 451 #ifdef YYTYPE_INT16 452 typedef YYTYPE_INT16 yytype_int16; 453 #else 454 typedef short int yytype_int16; 455 #endif 456 457 #ifndef YYSIZE_T 458 # ifdef __SIZE_TYPE__ 459 # define YYSIZE_T __SIZE_TYPE__ 460 # elif defined size_t 461 # define YYSIZE_T size_t 462 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 463 || defined __cplusplus || defined _MSC_VER) 464 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 465 # define YYSIZE_T size_t 466 # else 467 # define YYSIZE_T unsigned int 468 # endif 469 #endif 470 471 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 472 473 #ifndef YY_ 474 # if defined YYENABLE_NLS && YYENABLE_NLS 475 # if ENABLE_NLS 476 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 477 # define YY_(msgid) dgettext ("bison-runtime", msgid) 478 # endif 479 # endif 480 # ifndef YY_ 481 # define YY_(msgid) msgid 482 # endif 483 #endif 484 485 /* Suppress unused-variable warnings by "using" E. */ 486 #if ! defined lint || defined __GNUC__ 487 # define YYUSE(e) ((void) (e)) 488 #else 489 # define YYUSE(e) /* empty */ 490 #endif 491 492 /* Identity function, used to suppress warnings about constant conditions. */ 493 #ifndef lint 494 # define YYID(n) (n) 495 #else 496 #if (defined __STDC__ || defined __C99__FUNC__ \ 497 || defined __cplusplus || defined _MSC_VER) 498 static int 499 YYID (int i) 500 #else 501 static int 502 YYID (i) 503 int i; 504 #endif 505 { 506 return i; 507 } 508 #endif 509 510 #if ! defined yyoverflow || YYERROR_VERBOSE 511 512 /* The parser invokes alloca or malloc; define the necessary symbols. */ 513 514 # ifdef YYSTACK_USE_ALLOCA 515 # if YYSTACK_USE_ALLOCA 516 # ifdef __GNUC__ 517 # define YYSTACK_ALLOC __builtin_alloca 518 # elif defined __BUILTIN_VA_ARG_INCR 519 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 520 # elif defined _AIX 521 # define YYSTACK_ALLOC __alloca 522 # elif defined _MSC_VER 523 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 524 # define alloca _alloca 525 # else 526 # define YYSTACK_ALLOC alloca 527 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 528 || defined __cplusplus || defined _MSC_VER) 529 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 530 # ifndef _STDLIB_H 531 # define _STDLIB_H 1 532 # endif 533 # endif 534 # endif 535 # endif 536 # endif 537 538 # ifdef YYSTACK_ALLOC 539 /* Pacify GCC's `empty if-body' warning. */ 540 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 541 # ifndef YYSTACK_ALLOC_MAXIMUM 542 /* The OS might guarantee only one guard page at the bottom of the stack, 543 and a page size can be as small as 4096 bytes. So we cannot safely 544 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 545 to allow for a few compiler-allocated temporary stack slots. */ 546 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 547 # endif 548 # else 549 # define YYSTACK_ALLOC YYMALLOC 550 # define YYSTACK_FREE YYFREE 551 # ifndef YYSTACK_ALLOC_MAXIMUM 552 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 553 # endif 554 # if (defined __cplusplus && ! defined _STDLIB_H \ 555 && ! ((defined YYMALLOC || defined malloc) \ 556 && (defined YYFREE || defined free))) 557 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 558 # ifndef _STDLIB_H 559 # define _STDLIB_H 1 560 # endif 561 # endif 562 # ifndef YYMALLOC 563 # define YYMALLOC malloc 564 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 565 || defined __cplusplus || defined _MSC_VER) 566 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 567 # endif 568 # endif 569 # ifndef YYFREE 570 # define YYFREE free 571 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 572 || defined __cplusplus || defined _MSC_VER) 573 void free (void *); /* INFRINGES ON USER NAME SPACE */ 574 # endif 575 # endif 576 # endif 577 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 578 579 580 #if (! defined yyoverflow \ 581 && (! defined __cplusplus \ 582 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 583 584 /* A type that is properly aligned for any stack member. */ 585 union yyalloc 586 { 587 yytype_int16 yyss; 588 YYSTYPE yyvs; 589 }; 590 591 /* The size of the maximum gap between one aligned stack and the next. */ 592 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 593 594 /* The size of an array large to enough to hold all stacks, each with 595 N elements. */ 596 # define YYSTACK_BYTES(N) \ 597 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 598 + YYSTACK_GAP_MAXIMUM) 599 600 /* Copy COUNT objects from FROM to TO. The source and destination do 601 not overlap. */ 602 # ifndef YYCOPY 603 # if defined __GNUC__ && 1 < __GNUC__ 604 # define YYCOPY(To, From, Count) \ 605 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 606 # else 607 # define YYCOPY(To, From, Count) \ 608 do \ 609 { \ 610 YYSIZE_T yyi; \ 611 for (yyi = 0; yyi < (Count); yyi++) \ 612 (To)[yyi] = (From)[yyi]; \ 613 } \ 614 while (YYID (0)) 615 # endif 616 # endif 617 618 /* Relocate STACK from its old location to the new one. The 619 local variables YYSIZE and YYSTACKSIZE give the old and new number of 620 elements in the stack, and YYPTR gives the new location of the 621 stack. Advance YYPTR to a properly aligned location for the next 622 stack. */ 623 # define YYSTACK_RELOCATE(Stack) \ 624 do \ 625 { \ 626 YYSIZE_T yynewbytes; \ 627 YYCOPY (&yyptr->Stack, Stack, yysize); \ 628 Stack = &yyptr->Stack; \ 629 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 630 yyptr += yynewbytes / sizeof (*yyptr); \ 631 } \ 632 while (YYID (0)) 633 634 #endif 635 636 /* YYFINAL -- State number of the termination state. */ 637 #define YYFINAL 17 638 /* YYLAST -- Last index in YYTABLE. */ 639 #define YYLAST 1922 640 641 /* YYNTOKENS -- Number of terminals. */ 642 #define YYNTOKENS 148 643 /* YYNNTS -- Number of nonterminals. */ 644 #define YYNNTS 126 645 /* YYNRULES -- Number of rules. */ 646 #define YYNRULES 357 647 /* YYNRULES -- Number of states. */ 648 #define YYNSTATES 767 649 650 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 651 #define YYUNDEFTOK 2 652 #define YYMAXUTOK 379 653 654 #define YYTRANSLATE(YYX) \ 655 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 656 657 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 658 static const yytype_uint8 yytranslate[] = 659 { 660 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 661 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 662 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 663 2, 2, 2, 146, 2, 2, 2, 34, 21, 2, 664 37, 143, 32, 30, 141, 31, 2, 33, 2, 2, 665 2, 2, 2, 2, 2, 2, 2, 2, 16, 142, 666 24, 6, 25, 15, 2, 2, 2, 2, 2, 2, 667 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 668 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 669 2, 144, 2, 145, 20, 2, 2, 2, 2, 2, 670 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 671 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 672 2, 2, 2, 56, 19, 57, 147, 2, 2, 2, 673 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 674 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 675 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 676 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 677 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 678 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 679 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 680 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 681 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 682 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 683 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 684 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 685 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 686 5, 7, 8, 9, 10, 11, 12, 13, 14, 17, 687 18, 22, 23, 26, 27, 28, 29, 35, 36, 38, 688 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 689 49, 50, 51, 52, 53, 54, 55, 58, 59, 60, 690 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 691 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 692 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 693 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 694 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 695 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 696 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 697 131, 132, 133, 134, 135, 136, 137, 138, 139, 140 698 }; 699 700 #if YYDEBUG 701 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 702 YYRHS. */ 703 static const yytype_uint16 yyprhs[] = 704 { 705 0, 0, 3, 6, 9, 12, 15, 18, 20, 21, 706 26, 27, 30, 34, 35, 38, 43, 45, 47, 50, 707 52, 57, 62, 66, 69, 74, 78, 83, 88, 93, 708 98, 103, 106, 109, 112, 117, 122, 125, 128, 131, 709 134, 135, 141, 144, 145, 149, 152, 153, 155, 159, 710 161, 165, 166, 168, 172, 173, 176, 178, 181, 185, 711 186, 189, 192, 193, 195, 197, 199, 201, 203, 205, 712 207, 209, 211, 213, 218, 223, 228, 233, 242, 247, 713 249, 251, 256, 257, 263, 268, 269, 275, 280, 285, 714 289, 293, 300, 305, 307, 311, 314, 316, 320, 323, 715 324, 330, 331, 339, 340, 347, 352, 355, 358, 359, 716 364, 367, 368, 376, 378, 380, 382, 384, 390, 395, 717 400, 408, 416, 424, 432, 441, 444, 446, 450, 452, 718 454, 458, 463, 465, 466, 472, 475, 477, 479, 481, 719 486, 488, 493, 498, 499, 508, 509, 515, 518, 520, 720 521, 523, 525, 527, 529, 531, 533, 535, 538, 539, 721 541, 543, 545, 547, 549, 551, 553, 555, 557, 559, 722 563, 567, 574, 581, 583, 584, 589, 591, 592, 596, 723 598, 599, 607, 608, 614, 618, 622, 623, 627, 629, 724 632, 634, 637, 642, 647, 651, 655, 657, 662, 666, 725 667, 669, 671, 672, 675, 679, 680, 683, 686, 690, 726 695, 698, 701, 704, 708, 712, 716, 720, 724, 728, 727 732, 736, 740, 744, 748, 752, 756, 760, 764, 768, 728 774, 778, 782, 787, 789, 791, 796, 801, 806, 811, 729 816, 821, 826, 833, 840, 847, 852, 859, 864, 866, 730 873, 880, 887, 892, 897, 901, 902, 907, 908, 913, 731 914, 919, 920, 922, 924, 926, 927, 928, 929, 930, 732 931, 932, 952, 953, 954, 955, 956, 957, 976, 977, 733 978, 986, 987, 993, 995, 997, 999, 1001, 1003, 1007, 734 1008, 1011, 1015, 1018, 1025, 1036, 1039, 1041, 1042, 1044, 735 1047, 1048, 1049, 1053, 1054, 1055, 1056, 1057, 1069, 1074, 736 1075, 1078, 1079, 1080, 1087, 1089, 1090, 1094, 1100, 1101, 737 1105, 1106, 1109, 1111, 1114, 1119, 1122, 1123, 1126, 1127, 738 1133, 1135, 1138, 1143, 1149, 1156, 1158, 1161, 1162, 1165, 739 1170, 1175, 1184, 1186, 1188, 1192, 1196, 1197, 1207, 1208, 740 1216, 1218, 1222, 1224, 1228, 1230, 1234, 1235 741 }; 742 743 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 744 static const yytype_int16 yyrhs[] = 745 { 746 149, 0, -1, 122, 165, -1, 123, 153, -1, 133, 747 262, -1, 140, 257, -1, 124, 151, -1, 4, -1, 748 -1, 152, 4, 6, 218, -1, -1, 154, 155, -1, 749 155, 156, 110, -1, -1, 105, 218, -1, 105, 218, 750 141, 218, -1, 4, -1, 106, -1, 112, 158, -1, 751 111, -1, 116, 4, 6, 218, -1, 116, 4, 141, 752 218, -1, 116, 4, 218, -1, 115, 4, -1, 107, 753 4, 141, 218, -1, 107, 4, 218, -1, 107, 4, 754 6, 218, -1, 38, 4, 6, 218, -1, 38, 4, 755 141, 218, -1, 99, 4, 6, 218, -1, 99, 4, 756 141, 218, -1, 108, 160, -1, 109, 159, -1, 113, 757 4, -1, 119, 4, 141, 4, -1, 119, 4, 141, 758 3, -1, 118, 218, -1, 120, 3, -1, 125, 161, 759 -1, 126, 162, -1, -1, 64, 150, 157, 155, 36, 760 -1, 127, 4, -1, -1, 158, 141, 4, -1, 158, 761 4, -1, -1, 4, -1, 159, 141, 4, -1, 4, 762 -1, 160, 141, 4, -1, -1, 4, -1, 161, 141, 763 4, -1, -1, 163, 164, -1, 4, -1, 164, 4, 764 -1, 164, 141, 4, -1, -1, 166, 167, -1, 167, 765 168, -1, -1, 198, -1, 175, -1, 249, -1, 209, 766 -1, 210, -1, 212, -1, 214, -1, 177, -1, 264, 767 -1, 142, -1, 74, 37, 4, 143, -1, 75, 37, 768 150, 143, -1, 97, 37, 150, 143, -1, 59, 37, 769 4, 143, -1, 59, 37, 4, 141, 4, 141, 4, 770 143, -1, 61, 37, 4, 143, -1, 60, -1, 62, 771 -1, 95, 37, 171, 143, -1, -1, 96, 169, 37, 772 171, 143, -1, 76, 37, 150, 143, -1, -1, 64, 773 150, 170, 167, 36, -1, 90, 37, 215, 143, -1, 774 126, 37, 162, 143, -1, 48, 49, 4, -1, 48, 775 50, 4, -1, 66, 37, 4, 141, 4, 143, -1, 776 67, 37, 4, 143, -1, 4, -1, 171, 141, 4, 777 -1, 171, 4, -1, 5, -1, 171, 141, 5, -1, 778 171, 5, -1, -1, 104, 37, 172, 171, 143, -1, 779 -1, 171, 141, 104, 37, 173, 171, 143, -1, -1, 780 171, 104, 37, 174, 171, 143, -1, 46, 56, 176, 781 57, -1, 176, 224, -1, 176, 177, -1, -1, 77, 782 37, 4, 143, -1, 196, 195, -1, -1, 114, 178, 783 37, 218, 141, 4, 143, -1, 4, -1, 32, -1, 784 15, -1, 179, -1, 138, 37, 181, 143, 179, -1, 785 54, 37, 179, 143, -1, 55, 37, 179, 143, -1, 786 54, 37, 55, 37, 179, 143, 143, -1, 54, 37, 787 54, 37, 179, 143, 143, -1, 55, 37, 54, 37, 788 179, 143, 143, -1, 55, 37, 55, 37, 179, 143, 789 143, -1, 54, 37, 138, 37, 181, 143, 179, 143, 790 -1, 181, 179, -1, 179, -1, 182, 197, 180, -1, 791 180, -1, 4, -1, 144, 182, 145, -1, 180, 37, 792 182, 143, -1, 183, -1, -1, 134, 37, 185, 183, 793 143, -1, 196, 195, -1, 94, -1, 142, -1, 98, 794 -1, 54, 37, 98, 143, -1, 184, -1, 191, 37, 795 216, 143, -1, 92, 37, 192, 143, -1, -1, 114, 796 187, 37, 218, 141, 4, 143, 195, -1, -1, 64, 797 150, 188, 190, 36, -1, 189, 186, -1, 186, -1, 798 -1, 189, -1, 41, -1, 42, -1, 43, -1, 44, 799 -1, 45, -1, 216, -1, 6, 192, -1, -1, 14, 800 -1, 13, -1, 12, -1, 11, -1, 10, -1, 9, 801 -1, 8, -1, 7, -1, 142, -1, 141, -1, 4, 802 6, 216, -1, 4, 194, 216, -1, 102, 37, 4, 803 6, 216, 143, -1, 103, 37, 4, 6, 216, 143, 804 -1, 141, -1, -1, 65, 56, 199, 57, -1, 200, 805 -1, -1, 200, 197, 201, -1, 201, -1, -1, 4, 806 202, 206, 16, 204, 197, 205, -1, -1, 64, 150, 807 203, 199, 36, -1, 91, 6, 216, -1, 93, 6, 808 216, -1, -1, 37, 207, 143, -1, 208, -1, 207, 809 208, -1, 4, -1, 146, 4, -1, 85, 37, 150, 810 143, -1, 86, 37, 211, 143, -1, 86, 37, 143, 811 -1, 211, 197, 150, -1, 150, -1, 87, 37, 213, 812 143, -1, 213, 197, 150, -1, -1, 88, -1, 89, 813 -1, -1, 4, 215, -1, 4, 141, 215, -1, -1, 814 217, 218, -1, 31, 218, -1, 37, 218, 143, -1, 815 78, 37, 218, 143, -1, 146, 218, -1, 30, 218, 816 -1, 147, 218, -1, 218, 32, 218, -1, 218, 33, 817 218, -1, 218, 34, 218, -1, 218, 30, 218, -1, 818 218, 31, 218, -1, 218, 29, 218, -1, 218, 28, 819 218, -1, 218, 23, 218, -1, 218, 22, 218, -1, 820 218, 27, 218, -1, 218, 26, 218, -1, 218, 24, 821 218, -1, 218, 25, 218, -1, 218, 21, 218, -1, 822 218, 20, 218, -1, 218, 19, 218, -1, 218, 15, 823 218, 16, 218, -1, 218, 18, 218, -1, 218, 17, 824 218, -1, 73, 37, 4, 143, -1, 3, -1, 58, 825 -1, 80, 37, 4, 143, -1, 79, 37, 4, 143, 826 -1, 81, 37, 4, 143, -1, 82, 37, 4, 143, 827 -1, 139, 37, 4, 143, -1, 108, 37, 218, 143, 828 -1, 38, 37, 218, 143, -1, 38, 37, 218, 141, 829 218, 143, -1, 51, 37, 218, 141, 218, 143, -1, 830 52, 37, 218, 141, 218, 143, -1, 53, 37, 218, 831 143, -1, 63, 37, 4, 141, 218, 143, -1, 39, 832 37, 218, 143, -1, 4, -1, 83, 37, 218, 141, 833 218, 143, -1, 84, 37, 218, 141, 218, 143, -1, 834 114, 37, 218, 141, 4, 143, -1, 91, 37, 4, 835 143, -1, 93, 37, 4, 143, -1, 100, 25, 4, 836 -1, -1, 100, 37, 218, 143, -1, -1, 38, 37, 837 218, 143, -1, -1, 101, 37, 218, 143, -1, -1, 838 135, -1, 136, -1, 137, -1, -1, -1, -1, -1, 839 -1, -1, 4, 225, 240, 220, 221, 222, 226, 223, 840 56, 227, 190, 57, 228, 243, 219, 244, 193, 229, 841 197, -1, -1, -1, -1, -1, -1, 72, 230, 241, 842 242, 220, 222, 231, 56, 232, 245, 57, 233, 243, 843 219, 244, 193, 234, 197, -1, -1, -1, 96, 235, 844 240, 236, 56, 176, 57, -1, -1, 64, 150, 237, 845 176, 36, -1, 68, -1, 69, -1, 70, -1, 71, 846 -1, 72, -1, 37, 238, 143, -1, -1, 37, 143, 847 -1, 218, 239, 16, -1, 239, 16, -1, 40, 37, 848 218, 143, 239, 16, -1, 40, 37, 218, 143, 39, 849 37, 218, 143, 239, 16, -1, 218, 16, -1, 16, 850 -1, -1, 90, -1, 25, 4, -1, -1, -1, 244, 851 16, 4, -1, -1, -1, -1, -1, 245, 4, 246, 852 56, 190, 57, 247, 244, 193, 248, 197, -1, 47, 853 56, 250, 57, -1, -1, 250, 251, -1, -1, -1, 854 4, 252, 254, 255, 253, 142, -1, 218, -1, -1, 855 4, 256, 255, -1, 100, 37, 218, 143, 255, -1, 856 -1, 37, 218, 143, -1, -1, 258, 259, -1, 260, 857 -1, 259, 260, -1, 56, 261, 57, 142, -1, 270, 858 142, -1, -1, 263, 266, -1, -1, 265, 132, 56, 859 266, 57, -1, 267, -1, 266, 267, -1, 56, 269, 860 57, 142, -1, 128, 56, 269, 57, 142, -1, 128, 861 56, 269, 57, 268, 142, -1, 128, -1, 268, 128, 862 -1, -1, 270, 142, -1, 130, 16, 270, 142, -1, 863 131, 16, 270, 142, -1, 130, 16, 270, 142, 131, 864 16, 270, 142, -1, 129, -1, 4, -1, 270, 142, 865 129, -1, 270, 142, 4, -1, -1, 270, 142, 126, 866 4, 56, 271, 270, 273, 57, -1, -1, 126, 4, 867 56, 272, 270, 273, 57, -1, 130, -1, 270, 142, 868 130, -1, 131, -1, 270, 142, 131, -1, 126, -1, 869 270, 142, 126, -1, -1, 142, -1 870 }; 871 872 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 873 static const yytype_uint16 yyrline[] = 874 { 875 0, 163, 163, 164, 165, 166, 167, 171, 175, 175, 876 185, 185, 198, 199, 203, 204, 205, 208, 211, 212, 877 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 878 233, 235, 236, 237, 239, 241, 243, 245, 247, 248, 879 250, 249, 253, 255, 259, 260, 261, 265, 267, 271, 880 273, 278, 279, 280, 285, 285, 290, 292, 294, 299, 881 299, 305, 306, 311, 312, 313, 314, 315, 316, 317, 882 318, 319, 320, 321, 323, 325, 327, 330, 332, 334, 883 336, 338, 340, 339, 343, 346, 345, 349, 353, 354, 884 356, 358, 360, 365, 368, 371, 374, 377, 380, 384, 885 383, 388, 387, 392, 391, 398, 402, 403, 404, 408, 886 410, 411, 411, 419, 423, 427, 434, 440, 446, 452, 887 458, 464, 470, 476, 482, 491, 500, 511, 520, 531, 888 539, 543, 550, 552, 551, 558, 559, 563, 564, 569, 889 574, 575, 580, 584, 584, 588, 587, 594, 595, 598, 890 600, 604, 606, 608, 610, 612, 617, 624, 626, 630, 891 632, 634, 636, 638, 640, 642, 644, 649, 649, 654, 892 658, 666, 670, 678, 678, 682, 685, 685, 688, 689, 893 694, 693, 699, 698, 705, 713, 721, 722, 726, 727, 894 731, 733, 738, 743, 744, 749, 751, 757, 759, 761, 895 765, 767, 773, 776, 785, 796, 796, 802, 804, 806, 896 808, 810, 812, 815, 817, 819, 821, 823, 825, 827, 897 829, 831, 833, 835, 837, 839, 841, 843, 845, 847, 898 849, 851, 853, 855, 857, 860, 862, 864, 866, 868, 899 870, 872, 874, 876, 878, 880, 882, 891, 893, 895, 900 897, 899, 901, 903, 909, 910, 914, 915, 919, 920, 901 924, 925, 929, 930, 931, 932, 935, 939, 942, 948, 902 950, 935, 957, 959, 961, 966, 968, 956, 978, 980, 903 978, 986, 985, 992, 993, 994, 995, 996, 1000, 1001, 904 1002, 1006, 1007, 1012, 1013, 1018, 1019, 1024, 1025, 1030, 905 1032, 1037, 1040, 1053, 1057, 1062, 1064, 1055, 1072, 1075, 906 1077, 1081, 1082, 1081, 1091, 1136, 1139, 1151, 1160, 1163, 907 1170, 1170, 1182, 1183, 1187, 1191, 1200, 1200, 1214, 1214, 908 1224, 1225, 1229, 1233, 1237, 1244, 1248, 1256, 1259, 1263, 909 1267, 1271, 1278, 1282, 1286, 1290, 1295, 1294, 1308, 1307, 910 1317, 1321, 1325, 1329, 1333, 1337, 1343, 1345 911 }; 912 #endif 913 914 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 915 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 916 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 917 static const char *const yytname[] = 918 { 919 "$end", "error", "$undefined", "INT", "NAME", "LNAME", "'='", "OREQ", 920 "ANDEQ", "RSHIFTEQ", "LSHIFTEQ", "DIVEQ", "MULTEQ", "MINUSEQ", "PLUSEQ", 921 "'?'", "':'", "OROR", "ANDAND", "'|'", "'^'", "'&'", "NE", "EQ", "'<'", 922 "'>'", "GE", "LE", "RSHIFT", "LSHIFT", "'+'", "'-'", "'*'", "'/'", "'%'", 923 "UNARY", "END", "'('", "ALIGN_K", "BLOCK", "BIND", "QUAD", "SQUAD", 924 "LONG", "SHORT", "BYTE", "SECTIONS", "PHDRS", "INSERT_K", "AFTER", 925 "BEFORE", "DATA_SEGMENT_ALIGN", "DATA_SEGMENT_RELRO_END", 926 "DATA_SEGMENT_END", "SORT_BY_NAME", "SORT_BY_ALIGNMENT", "'{'", "'}'", 927 "SIZEOF_HEADERS", "OUTPUT_FORMAT", "FORCE_COMMON_ALLOCATION", 928 "OUTPUT_ARCH", "INHIBIT_COMMON_ALLOCATION", "SEGMENT_START", "INCLUDE", 929 "MEMORY", "REGION_ALIAS", "LD_FEATURE", "NOLOAD", "DSECT", "COPY", 930 "INFO", "OVERLAY", "DEFINED", "TARGET_K", "SEARCH_DIR", "MAP", "ENTRY", 931 "NEXT", "SIZEOF", "ALIGNOF", "ADDR", "LOADADDR", "MAX_K", "MIN_K", 932 "STARTUP", "HLL", "SYSLIB", "FLOAT", "NOFLOAT", "NOCROSSREFS", "ORIGIN", 933 "FILL", "LENGTH", "CREATE_OBJECT_SYMBOLS", "INPUT", "GROUP", "OUTPUT", 934 "CONSTRUCTORS", "ALIGNMOD", "AT", "SUBALIGN", "PROVIDE", 935 "PROVIDE_HIDDEN", "AS_NEEDED", "CHIP", "LIST", "SECT", "ABSOLUTE", 936 "LOAD", "NEWLINE", "ENDWORD", "ORDER", "NAMEWORD", "ASSERT_K", "FORMAT", 937 "PUBLIC", "DEFSYMEND", "BASE", "ALIAS", "TRUNCATE", "REL", 938 "INPUT_SCRIPT", "INPUT_MRI_SCRIPT", "INPUT_DEFSYM", "CASE", "EXTERN", 939 "START", "VERS_TAG", "VERS_IDENTIFIER", "GLOBAL", "LOCAL", "VERSIONK", 940 "INPUT_VERSION_SCRIPT", "KEEP", "ONLY_IF_RO", "ONLY_IF_RW", "SPECIAL", 941 "EXCLUDE_FILE", "CONSTANT", "INPUT_DYNAMIC_LIST", "','", "';'", "')'", 942 "'['", "']'", "'!'", "'~'", "$accept", "file", "filename", "defsym_expr", 943 "@1", "mri_script_file", "@2", "mri_script_lines", "mri_script_command", 944 "@3", "ordernamelist", "mri_load_name_list", "mri_abs_name_list", 945 "casesymlist", "extern_name_list", "@4", "extern_name_list_body", 946 "script_file", "@5", "ifile_list", "ifile_p1", "@6", "@7", "input_list", 947 "@8", "@9", "@10", "sections", "sec_or_group_p1", "statement_anywhere", 948 "@11", "wildcard_name", "wildcard_spec", "exclude_name_list", 949 "file_NAME_list", "input_section_spec_no_keep", "input_section_spec", 950 "@12", "statement", "@13", "@14", "statement_list", "statement_list_opt", 951 "length", "fill_exp", "fill_opt", "assign_op", "end", "assignment", 952 "opt_comma", "memory", "memory_spec_list_opt", "memory_spec_list", 953 "memory_spec", "@15", "@16", "origin_spec", "length_spec", 954 "attributes_opt", "attributes_list", "attributes_string", "startup", 955 "high_level_library", "high_level_library_NAME_list", 956 "low_level_library", "low_level_library_NAME_list", 957 "floating_point_support", "nocrossref_list", "mustbe_exp", "@17", "exp", 958 "memspec_at_opt", "opt_at", "opt_align", "opt_subalign", 959 "sect_constraint", "section", "@18", "@19", "@20", "@21", "@22", "@23", 960 "@24", "@25", "@26", "@27", "@28", "@29", "@30", "type", "atype", 961 "opt_exp_with_type", "opt_exp_without_type", "opt_nocrossrefs", 962 "memspec_opt", "phdr_opt", "overlay_section", "@31", "@32", "@33", 963 "phdrs", "phdr_list", "phdr", "@34", "@35", "phdr_type", 964 "phdr_qualifiers", "phdr_val", "dynamic_list_file", "@36", 965 "dynamic_list_nodes", "dynamic_list_node", "dynamic_list_tag", 966 "version_script_file", "@37", "version", "@38", "vers_nodes", 967 "vers_node", "verdep", "vers_tag", "vers_defns", "@39", "@40", 968 "opt_semicolon", 0 969 }; 970 #endif 971 972 # ifdef YYPRINT 973 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 974 token YYLEX-NUM. */ 975 static const yytype_uint16 yytoknum[] = 976 { 977 0, 256, 257, 258, 259, 260, 61, 261, 262, 263, 978 264, 265, 266, 267, 268, 63, 58, 269, 270, 124, 979 94, 38, 271, 272, 60, 62, 273, 274, 275, 276, 980 43, 45, 42, 47, 37, 277, 278, 40, 279, 280, 981 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 982 291, 292, 293, 294, 295, 296, 123, 125, 297, 298, 983 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 984 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 985 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 986 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 987 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 988 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 989 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 990 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 991 379, 44, 59, 41, 91, 93, 33, 126 992 }; 993 # endif 994 995 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 996 static const yytype_uint16 yyr1[] = 997 { 998 0, 148, 149, 149, 149, 149, 149, 150, 152, 151, 999 154, 153, 155, 155, 156, 156, 156, 156, 156, 156, 1000 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 1001 156, 156, 156, 156, 156, 156, 156, 156, 156, 156, 1002 157, 156, 156, 156, 158, 158, 158, 159, 159, 160, 1003 160, 161, 161, 161, 163, 162, 164, 164, 164, 166, 1004 165, 167, 167, 168, 168, 168, 168, 168, 168, 168, 1005 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 1006 168, 168, 169, 168, 168, 170, 168, 168, 168, 168, 1007 168, 168, 168, 171, 171, 171, 171, 171, 171, 172, 1008 171, 173, 171, 174, 171, 175, 176, 176, 176, 177, 1009 177, 178, 177, 179, 179, 179, 180, 180, 180, 180, 1010 180, 180, 180, 180, 180, 181, 181, 182, 182, 183, 1011 183, 183, 184, 185, 184, 186, 186, 186, 186, 186, 1012 186, 186, 186, 187, 186, 188, 186, 189, 189, 190, 1013 190, 191, 191, 191, 191, 191, 192, 193, 193, 194, 1014 194, 194, 194, 194, 194, 194, 194, 195, 195, 196, 1015 196, 196, 196, 197, 197, 198, 199, 199, 200, 200, 1016 202, 201, 203, 201, 204, 205, 206, 206, 207, 207, 1017 208, 208, 209, 210, 210, 211, 211, 212, 213, 213, 1018 214, 214, 215, 215, 215, 217, 216, 218, 218, 218, 1019 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 1020 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 1021 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 1022 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 1023 218, 218, 218, 218, 219, 219, 220, 220, 221, 221, 1024 222, 222, 223, 223, 223, 223, 225, 226, 227, 228, 1025 229, 224, 230, 231, 232, 233, 234, 224, 235, 236, 1026 224, 237, 224, 238, 238, 238, 238, 238, 239, 239, 1027 239, 240, 240, 240, 240, 241, 241, 242, 242, 243, 1028 243, 244, 244, 245, 246, 247, 248, 245, 249, 250, 1029 250, 252, 253, 251, 254, 255, 255, 255, 256, 256, 1030 258, 257, 259, 259, 260, 261, 263, 262, 265, 264, 1031 266, 266, 267, 267, 267, 268, 268, 269, 269, 269, 1032 269, 269, 270, 270, 270, 270, 271, 270, 272, 270, 1033 270, 270, 270, 270, 270, 270, 273, 273 1034 }; 1035 1036 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 1037 static const yytype_uint8 yyr2[] = 1038 { 1039 0, 2, 2, 2, 2, 2, 2, 1, 0, 4, 1040 0, 2, 3, 0, 2, 4, 1, 1, 2, 1, 1041 4, 4, 3, 2, 4, 3, 4, 4, 4, 4, 1042 4, 2, 2, 2, 4, 4, 2, 2, 2, 2, 1043 0, 5, 2, 0, 3, 2, 0, 1, 3, 1, 1044 3, 0, 1, 3, 0, 2, 1, 2, 3, 0, 1045 2, 2, 0, 1, 1, 1, 1, 1, 1, 1, 1046 1, 1, 1, 4, 4, 4, 4, 8, 4, 1, 1047 1, 4, 0, 5, 4, 0, 5, 4, 4, 3, 1048 3, 6, 4, 1, 3, 2, 1, 3, 2, 0, 1049 5, 0, 7, 0, 6, 4, 2, 2, 0, 4, 1050 2, 0, 7, 1, 1, 1, 1, 5, 4, 4, 1051 7, 7, 7, 7, 8, 2, 1, 3, 1, 1, 1052 3, 4, 1, 0, 5, 2, 1, 1, 1, 4, 1053 1, 4, 4, 0, 8, 0, 5, 2, 1, 0, 1054 1, 1, 1, 1, 1, 1, 1, 2, 0, 1, 1055 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1056 3, 6, 6, 1, 0, 4, 1, 0, 3, 1, 1057 0, 7, 0, 5, 3, 3, 0, 3, 1, 2, 1058 1, 2, 4, 4, 3, 3, 1, 4, 3, 0, 1059 1, 1, 0, 2, 3, 0, 2, 2, 3, 4, 1060 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 1061 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 1062 3, 3, 4, 1, 1, 4, 4, 4, 4, 4, 1063 4, 4, 6, 6, 6, 4, 6, 4, 1, 6, 1064 6, 6, 4, 4, 3, 0, 4, 0, 4, 0, 1065 4, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1066 0, 19, 0, 0, 0, 0, 0, 18, 0, 0, 1067 7, 0, 5, 1, 1, 1, 1, 1, 3, 0, 1068 2, 3, 2, 6, 10, 2, 1, 0, 1, 2, 1069 0, 0, 3, 0, 0, 0, 0, 11, 4, 0, 1070 2, 0, 0, 6, 1, 0, 3, 5, 0, 3, 1071 0, 2, 1, 2, 4, 2, 0, 2, 0, 5, 1072 1, 2, 4, 5, 6, 1, 2, 0, 2, 4, 1073 4, 8, 1, 1, 3, 3, 0, 9, 0, 7, 1074 1, 3, 1, 3, 1, 3, 0, 1 1075 }; 1076 1077 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 1078 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 1079 means the default is an error. */ 1080 static const yytype_uint16 yydefact[] = 1081 { 1082 0, 59, 10, 8, 326, 320, 0, 2, 62, 3, 1083 13, 6, 0, 4, 0, 5, 0, 1, 60, 11, 1084 0, 337, 0, 327, 330, 0, 321, 322, 0, 0, 1085 0, 0, 0, 79, 0, 80, 0, 0, 0, 0, 1086 0, 0, 0, 0, 0, 0, 0, 200, 201, 0, 1087 0, 82, 0, 0, 0, 111, 0, 72, 61, 64, 1088 70, 0, 63, 66, 67, 68, 69, 65, 71, 0, 1089 16, 0, 0, 0, 0, 17, 0, 0, 0, 19, 1090 46, 0, 0, 0, 0, 0, 0, 51, 54, 0, 1091 0, 0, 343, 354, 342, 350, 352, 0, 0, 337, 1092 331, 350, 352, 0, 0, 323, 205, 166, 165, 164, 1093 163, 162, 161, 160, 159, 205, 108, 309, 0, 0, 1094 0, 0, 7, 85, 177, 0, 0, 0, 0, 0, 1095 0, 0, 0, 199, 202, 0, 0, 0, 0, 0, 1096 0, 54, 168, 167, 110, 0, 0, 40, 0, 233, 1097 248, 0, 0, 0, 0, 0, 0, 0, 0, 234, 1098 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1099 0, 0, 0, 0, 0, 0, 14, 0, 49, 31, 1100 47, 32, 18, 33, 23, 0, 36, 0, 37, 52, 1101 38, 39, 0, 42, 12, 9, 0, 0, 0, 0, 1102 338, 0, 0, 325, 169, 0, 170, 0, 0, 89, 1103 90, 0, 0, 62, 180, 0, 0, 174, 179, 0, 1104 0, 0, 0, 0, 0, 0, 194, 196, 174, 174, 1105 202, 0, 93, 96, 0, 0, 0, 0, 0, 0, 1106 0, 0, 0, 0, 0, 13, 0, 0, 211, 207, 1107 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1108 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1109 210, 212, 0, 0, 0, 0, 0, 0, 0, 0, 1110 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1111 0, 0, 0, 0, 25, 0, 0, 45, 0, 0, 1112 0, 22, 0, 0, 56, 55, 348, 0, 0, 332, 1113 345, 355, 344, 351, 353, 0, 324, 206, 266, 105, 1114 0, 272, 278, 107, 106, 311, 308, 310, 0, 76, 1115 78, 328, 186, 182, 175, 173, 0, 0, 92, 73, 1116 74, 84, 109, 192, 193, 0, 197, 0, 202, 203, 1117 87, 99, 95, 98, 0, 0, 81, 0, 75, 205, 1118 205, 0, 88, 0, 27, 28, 43, 29, 30, 208, 1119 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1120 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1121 231, 230, 228, 227, 226, 221, 220, 224, 225, 223, 1122 222, 219, 218, 216, 217, 213, 214, 215, 15, 26, 1123 24, 50, 48, 44, 20, 21, 35, 34, 53, 57, 1124 0, 0, 339, 340, 0, 335, 333, 0, 289, 281, 1125 0, 289, 0, 0, 86, 0, 0, 177, 178, 0, 1126 195, 198, 204, 0, 103, 94, 97, 0, 83, 0, 1127 0, 0, 329, 41, 0, 241, 247, 0, 0, 245, 1128 0, 232, 209, 236, 235, 237, 238, 0, 0, 252, 1129 253, 240, 0, 239, 0, 58, 356, 353, 346, 336, 1130 334, 0, 0, 289, 0, 257, 108, 296, 0, 297, 1131 279, 314, 315, 0, 190, 0, 0, 188, 0, 0, 1132 91, 0, 0, 101, 171, 172, 0, 0, 0, 0, 1133 0, 0, 0, 0, 229, 357, 0, 0, 0, 283, 1134 284, 285, 286, 287, 290, 0, 0, 0, 0, 292, 1135 0, 259, 0, 295, 298, 257, 0, 318, 0, 312, 1136 0, 191, 187, 189, 0, 174, 183, 100, 0, 0, 1137 112, 242, 243, 244, 246, 249, 250, 251, 349, 0, 1138 356, 288, 0, 291, 0, 0, 261, 282, 261, 108, 1139 0, 315, 0, 0, 77, 205, 0, 104, 0, 341, 1140 0, 289, 0, 0, 0, 267, 273, 0, 0, 316, 1141 0, 313, 184, 0, 181, 102, 347, 0, 0, 256, 1142 0, 0, 265, 0, 280, 319, 315, 205, 0, 293, 1143 258, 0, 262, 263, 264, 0, 274, 317, 185, 0, 1144 260, 268, 303, 289, 149, 0, 0, 129, 115, 114, 1145 151, 152, 153, 154, 155, 0, 0, 0, 0, 136, 1146 138, 143, 0, 0, 137, 0, 116, 0, 132, 140, 1147 148, 150, 0, 0, 0, 304, 275, 294, 0, 0, 1148 145, 205, 0, 133, 0, 113, 0, 128, 174, 0, 1149 147, 269, 205, 135, 0, 300, 0, 0, 0, 0, 1150 0, 0, 0, 0, 149, 0, 156, 0, 0, 126, 1151 0, 0, 130, 0, 174, 300, 0, 149, 0, 255, 1152 0, 0, 139, 0, 118, 0, 0, 119, 0, 142, 1153 0, 113, 0, 0, 125, 127, 131, 255, 141, 0, 1154 299, 0, 301, 0, 0, 0, 0, 0, 146, 0, 1155 134, 117, 301, 305, 0, 158, 0, 0, 0, 0, 1156 0, 0, 158, 301, 254, 205, 0, 276, 121, 120, 1157 0, 122, 123, 0, 270, 158, 157, 302, 174, 124, 1158 144, 174, 306, 277, 271, 174, 307 1159 }; 1160 1161 /* YYDEFGOTO[NTERM-NUM]. */ 1162 static const yytype_int16 yydefgoto[] = 1163 { 1164 -1, 6, 123, 11, 12, 9, 10, 19, 90, 245, 1165 182, 181, 179, 190, 191, 192, 305, 7, 8, 18, 1166 58, 136, 213, 235, 443, 549, 502, 59, 207, 323, 1167 140, 646, 647, 690, 668, 648, 649, 688, 650, 662, 1168 684, 651, 652, 653, 685, 747, 115, 144, 61, 693, 1169 62, 216, 217, 218, 332, 437, 545, 594, 436, 496, 1170 497, 63, 64, 228, 65, 229, 66, 231, 686, 205, 1171 250, 722, 531, 566, 585, 615, 324, 428, 602, 624, 1172 695, 761, 430, 603, 622, 675, 758, 431, 536, 486, 1173 525, 484, 485, 489, 535, 699, 735, 625, 674, 743, 1174 765, 67, 208, 327, 432, 573, 492, 539, 571, 15, 1175 16, 26, 27, 103, 13, 14, 68, 69, 23, 24, 1176 427, 97, 98, 518, 421, 516 1177 }; 1178 1179 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1180 STATE-NUM. */ 1181 #define YYPACT_NINF -658 1182 static const yytype_int16 yypact[] = 1183 { 1184 130, -658, -658, -658, -658, -658, 42, -658, -658, -658, 1185 -658, -658, 61, -658, -23, -658, 12, -658, 886, 1644, 1186 82, 66, 38, -23, -658, 98, 12, -658, 529, 54, 1187 67, 91, 89, -658, 119, -658, 217, 174, 207, 214, 1188 220, 223, 227, 257, 258, 266, 267, -658, -658, 268, 1189 293, -658, 295, 296, 297, -658, 298, -658, -658, -658, 1190 -658, 9, -658, -658, -658, -658, -658, -658, -658, 151, 1191 -658, 316, 217, 333, 716, -658, 334, 335, 336, -658, 1192 -658, 337, 339, 341, 716, 343, 299, 344, -658, 345, 1193 240, 716, -658, 348, -658, 346, 349, 302, 213, 66, 1194 -658, -658, -658, 303, 221, -658, -658, -658, -658, -658, 1195 -658, -658, -658, -658, -658, -658, -658, -658, 360, 365, 1196 366, 368, -658, -658, 31, 369, 372, 373, 217, 217, 1197 378, 217, 28, -658, 383, 129, 351, 217, 385, 386, 1198 358, -658, -658, -658, -658, 340, 47, -658, 50, -658, 1199 -658, 716, 716, 716, 361, 362, 364, 370, 371, -658, 1200 379, 380, 381, 384, 388, 392, 393, 394, 395, 399, 1201 400, 402, 403, 404, 716, 716, 1435, 375, -658, 256, 1202 -658, 269, 23, -658, -658, 525, 1843, 274, -658, -658, 1203 279, -658, 418, -658, -658, 1843, 367, 98, 98, 300, 1204 110, 387, 304, 110, -658, 716, -658, 289, 55, -658, 1205 -658, -5, 292, -658, -658, 217, 390, -2, -658, 310, 1206 317, 320, 321, 322, 324, 326, -658, -658, 19, 94, 1207 27, 329, -658, -658, 408, 16, 129, 330, 468, 470, 1208 716, 338, -23, 716, 716, -658, 716, 716, -658, -658, 1209 895, 716, 716, 716, 716, 716, 473, 474, 716, 475, 1210 476, 478, 480, 716, 716, 481, 482, 716, 716, 483, 1211 -658, -658, 716, 716, 716, 716, 716, 716, 716, 716, 1212 716, 716, 716, 716, 716, 716, 716, 716, 716, 716, 1213 716, 716, 716, 716, 1843, 484, 487, -658, 488, 716, 1214 716, 1843, 265, 489, -658, 46, -658, 353, 355, -658, 1215 -658, 495, -658, -658, -658, -56, -658, 1843, 529, -658, 1216 217, -658, -658, -658, -658, -658, -658, -658, 498, -658, 1217 -658, 955, 467, -658, -658, -658, 31, 503, -658, -658, 1218 -658, -658, -658, -658, -658, 217, -658, 217, 383, -658, 1219 -658, -658, -658, -658, 471, 138, -658, 20, -658, -658, 1220 -658, 1462, -658, 25, 1843, 1843, 1667, 1843, 1843, -658, 1221 849, 1081, 1482, 1502, 1101, 374, 376, 1121, 377, 382, 1222 389, 405, 1522, 1560, 406, 407, 1141, 1587, 409, 1803, 1223 1860, 1540, 1875, 1061, 1888, 1046, 1046, 294, 294, 294, 1224 294, 283, 283, 239, 239, -658, -658, -658, 1843, 1843, 1225 1843, -658, -658, -658, 1843, 1843, -658, -658, -658, -658, 1226 506, 98, 117, 110, 455, -658, -658, -55, 597, -658, 1227 679, 597, 716, 412, -658, 3, 497, 31, -658, 411, 1228 -658, -658, -658, 129, -658, -658, -658, 486, -658, 414, 1229 415, 513, -658, -658, 716, -658, -658, 716, 716, -658, 1230 716, -658, -658, -658, -658, -658, -658, 716, 716, -658, 1231 -658, -658, 514, -658, 716, -658, 391, 508, -658, -658, 1232 -658, 228, 493, 1780, 510, 445, -658, -658, 1823, 456, 1233 -658, 1843, 18, 555, -658, 556, 2, -658, 479, 531, 1234 -658, 24, 129, -658, -658, -658, 422, 1161, 1181, 1208, 1235 1228, 1248, 1268, 426, 1843, 110, 504, 98, 98, -658, 1236 -658, -658, -658, -658, -658, 428, 716, -24, 557, -658, 1237 535, 536, 398, -658, -658, 445, 519, 542, 543, -658, 1238 438, -658, -658, -658, 576, 443, -658, -658, 33, 129, 1239 -658, -658, -658, -658, -658, -658, -658, -658, -658, 444, 1240 391, -658, 1288, -658, 716, 548, 501, -658, 501, -658, 1241 716, 18, 716, 457, -658, -658, 494, -658, 79, 110, 1242 553, 238, 1308, 716, 574, -658, -658, 347, 1335, -658, 1243 1355, -658, -658, 606, -658, -658, -658, 577, 599, -658, 1244 1375, 716, 152, 561, -658, -658, 18, -658, 716, -658, 1245 -658, 1395, -658, -658, -658, 563, -658, -658, -658, 1415, 1246 -658, -658, -658, 584, 797, 60, 607, 583, -658, -658, 1247 -658, -658, -658, -658, -658, 585, 587, 217, 588, -658, 1248 -658, -658, 589, 592, -658, 100, -658, 593, -658, -658, 1249 -658, 797, 575, 594, 9, -658, -658, -658, 37, 75, 1250 -658, -658, 601, -658, 246, -658, 603, -658, -52, 100, 1251 -658, -658, -658, -658, 586, 616, 608, 609, 500, 610, 1252 509, 614, 617, 515, 797, 516, -658, 716, 8, -658, 1253 4, 230, -658, 100, 149, 616, 518, 797, 640, 562, 1254 246, 246, -658, 246, -658, 246, 246, -658, 620, -658, 1255 1607, 520, 522, 246, -658, -658, -658, 562, -658, 596, 1256 -658, 632, -658, 524, 526, 39, 530, 541, -658, 664, 1257 -658, -658, -658, -658, 670, 90, 544, 546, 246, 549, 1258 550, 551, 90, -658, -658, -658, 681, -658, -658, -658, 1259 554, -658, -658, 9, -658, 90, -658, -658, 443, -658, 1260 -658, 443, -658, -658, -658, 443, -658 1261 }; 1262 1263 /* YYPGOTO[NTERM-NUM]. */ 1264 static const yytype_int16 yypgoto[] = 1265 { 1266 -658, -658, -71, -658, -658, -658, -658, 441, -658, -658, 1267 -658, -658, -658, -658, 558, -658, -658, -658, -658, 485, 1268 -658, -658, -658, -220, -658, -658, -658, -658, -456, -13, 1269 -658, 986, -594, -7, 22, 13, -658, -658, 49, -658, 1270 -658, -658, -617, -658, -43, -657, -658, -628, -575, -214, 1271 -658, 270, -658, 397, -658, -658, -658, -658, -658, -658, 1272 208, -658, -658, -658, -658, -658, -658, -221, -104, -658, 1273 -74, -14, 171, -658, 140, -658, -658, -658, -658, -658, 1274 -658, -658, -658, -658, -658, -658, -658, -658, -658, -658, 1275 -658, -465, 281, -658, -658, 26, -635, -658, -658, -658, 1276 -658, -658, -658, -658, -658, -658, -658, -532, -658, -658, 1277 -658, -658, 687, -658, -658, -658, -658, -658, 472, -19, 1278 -658, 623, -12, -658, -658, 155 1279 }; 1280 1281 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 1282 positive, shift that token. If negative, reduce the rule which 1283 number is the opposite. If zero, do what YYDEFACT says. 1284 If YYTABLE_NINF, syntax error. */ 1285 #define YYTABLE_NINF -329 1286 static const yytype_int16 yytable[] = 1287 { 1288 176, 147, 204, 336, 100, 60, 494, 494, 665, 349, 1289 186, 206, 711, 104, 345, 347, 357, 195, 528, 628, 1290 352, 353, 537, 628, 352, 353, 673, 297, 352, 353, 1291 532, 230, 122, 21, -176, 214, 629, 352, 353, 589, 1292 629, 665, 17, 665, 519, 520, 521, 522, 523, 654, 1293 419, 667, 628, 243, 628, -176, 246, 222, 223, 325, 1294 225, 227, 666, 636, 655, 20, 237, 708, 25, 629, 1295 92, 629, 425, 479, 617, 667, 654, 248, 249, 665, 1296 719, 21, 452, 352, 353, 754, 426, 480, 91, 335, 1297 628, 676, 677, 692, 99, 215, 745, 742, 762, 715, 1298 270, 271, 92, 294, 665, 22, 746, 629, 755, 654, 1299 116, 301, 326, 587, 310, 628, 598, 656, 538, 524, 1300 354, 310, 654, 117, 354, 760, 120, 442, 354, 681, 1301 682, 317, 629, 232, 233, 678, 328, 354, 329, 335, 1302 118, 119, 445, 446, 333, 542, 643, 713, 495, 495, 1303 142, 143, 645, 22, 666, 636, 121, 355, 626, 356, 1304 335, 355, 344, 448, 298, 355, 361, 547, 348, 364, 1305 365, 226, 367, 368, 355, 679, 577, 370, 371, 372, 1306 373, 374, 738, 354, 377, 307, 308, 420, 244, 382, 1307 383, 247, 93, 386, 387, 94, 95, 96, 389, 390, 1308 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 1309 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 1310 355, 122, 595, 501, 93, 414, 415, 94, 101, 102, 1311 124, 149, 150, 234, 665, 335, 311, 346, 643, 312, 1312 313, 314, 447, 311, 125, 628, 312, 313, 477, 429, 1313 665, 126, 1, 2, 3, 449, 450, 127, 151, 152, 1314 128, 628, 629, 4, 129, 153, 154, 155, 416, 417, 1315 5, 288, 289, 290, 440, 527, 441, 597, 629, 156, 1316 157, 158, 548, 145, 676, 677, 159, 612, 613, 614, 1317 335, 160, 716, 318, 130, 131, 519, 520, 521, 522, 1318 523, 161, 188, 132, 133, 134, 162, 163, 164, 165, 1319 166, 167, 168, 286, 287, 288, 289, 290, 60, 169, 1320 146, 170, 284, 285, 286, 287, 288, 289, 290, 578, 1321 135, 576, 137, 138, 139, 141, 171, 148, 177, 178, 1322 180, 183, 172, 184, 100, 185, 319, 187, 189, 193, 1323 194, 318, 196, 320, 483, 200, 488, 483, 491, 199, 1324 202, 321, 197, 203, 209, 198, 43, 173, 679, 210, 1325 211, 524, 212, 219, 174, 175, 220, 221, 149, 150, 1326 507, 292, 224, 508, 509, 322, 510, 230, 236, 238, 1327 239, 53, 54, 511, 512, 240, 242, 295, 251, 252, 1328 514, 253, 318, 55, 604, 151, 152, 254, 255, 476, 1329 296, 320, 153, 154, 155, 302, 256, 257, 258, 321, 1330 303, 259, 304, 306, 43, 260, 156, 157, 158, 261, 1331 262, 263, 264, 159, 567, 330, 265, 266, 160, 267, 1332 268, 269, 309, 322, 315, 351, 316, 334, 161, 53, 1333 54, 337, 562, 162, 163, 164, 165, 166, 167, 168, 1334 338, 55, 320, 339, 340, 341, 169, 342, 170, 343, 1335 321, 592, 350, 358, 359, 43, 360, 375, 376, 378, 1336 379, 362, 380, 171, 381, 384, 385, 388, 411, 172, 1337 582, 412, 413, 418, 322, 422, 588, 423, 590, 424, 1338 53, 54, 433, 618, 435, 559, 560, 439, 444, 600, 1339 475, 478, 55, 498, 173, 460, 293, 506, 513, 461, 1340 463, 174, 175, 503, 517, 464, 529, 611, 149, 150, 1341 526, 299, 465, 515, 619, 106, 107, 108, 109, 110, 1342 111, 112, 113, 114, 763, 530, 534, 764, 466, 469, 1343 470, 766, 473, 493, 500, 151, 152, 504, 505, 540, 1344 541, 558, 153, 154, 155, 550, 660, 546, 696, 557, 1345 544, 561, 564, 563, 565, 569, 156, 157, 158, 570, 1346 572, 574, 575, 159, 335, 583, 579, 593, 160, 106, 1347 107, 108, 109, 110, 111, 112, 113, 114, 161, 591, 1348 149, 150, 584, 162, 163, 164, 165, 166, 167, 168, 1349 596, 601, 607, 710, 608, 609, 169, 616, 170, 621, 1350 -113, 527, 658, 657, 659, 661, 663, 151, 152, 664, 1351 669, 672, 671, 171, 481, 154, 155, 482, 687, 172, 1352 691, 698, 697, 702, 720, 700, 701, 703, 156, 157, 1353 158, 705, 704, 733, 706, 159, 728, 734, 707, 709, 1354 160, 718, 721, -129, 173, 730, 300, 736, 741, 737, 1355 161, 174, 175, 739, 744, 162, 163, 164, 165, 166, 1356 167, 168, 149, 150, 740, 757, 366, 748, 169, 749, 1357 170, 694, 751, 752, 753, 487, 725, 759, 331, 241, 1358 670, 712, 756, 732, 543, 171, 568, 499, 586, 151, 1359 152, 172, 490, 105, 363, 580, 153, 154, 155, 149, 1360 150, 717, 201, 0, 0, 0, 0, 0, 0, 0, 1361 156, 157, 158, 438, 0, 0, 173, 159, 0, 0, 1362 0, 0, 160, 174, 175, 0, 151, 152, 0, 0, 1363 0, 0, 161, 153, 154, 155, 0, 162, 163, 164, 1364 165, 166, 167, 168, 0, 0, 0, 156, 157, 158, 1365 169, 0, 170, 0, 159, 0, 0, 0, 0, 160, 1366 0, 0, 0, 0, 0, 0, 0, 171, 0, 161, 1367 0, 0, 0, 172, 162, 163, 164, 165, 166, 167, 1368 168, 627, 0, 0, 0, 0, 0, 169, 0, 170, 1369 0, 0, 628, 0, 0, 0, 0, 0, 173, 0, 1370 0, 0, 0, 0, 171, 174, 175, 0, 0, 629, 1371 172, 0, 0, 0, 0, 0, 0, 0, 630, 631, 1372 632, 633, 634, 0, 0, 0, 0, 0, 0, 0, 1373 0, 635, 636, 0, 0, 173, 0, 0, 0, 0, 1374 0, 637, 174, 175, 272, 0, 273, 274, 275, 276, 1375 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 1376 287, 288, 289, 290, 0, 0, 0, 0, 0, 638, 1377 28, 639, 0, 0, 0, 640, 0, 0, 0, 53, 1378 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1379 272, 641, 273, 274, 275, 276, 277, 278, 279, 280, 1380 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 1381 0, 642, 29, 30, 31, 643, 0, 0, 0, 644, 1382 0, 645, 0, 0, 0, 32, 33, 34, 35, 0, 1383 36, 37, 38, 39, 0, 0, 0, 0, 0, 28, 1384 40, 41, 42, 43, 0, 0, 0, 0, 0, 0, 1385 0, 44, 45, 46, 47, 48, 49, 0, 0, 0, 1386 0, 50, 51, 52, 0, 0, 0, 0, 53, 54, 1387 454, 434, 455, 0, 0, 0, 0, 0, 0, 0, 1388 55, 29, 30, 31, 0, 0, 0, 0, 0, 0, 1389 0, 0, 56, 0, 32, 33, 34, 35, -328, 36, 1390 37, 38, 39, 0, 0, 0, 0, 0, 57, 40, 1391 41, 42, 43, 0, 0, 0, 0, 0, 369, 0, 1392 44, 45, 46, 47, 48, 49, 0, 0, 0, 0, 1393 50, 51, 52, 0, 0, 0, 0, 53, 54, 0, 1394 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 1395 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 1396 290, 56, 277, 278, 279, 280, 281, 282, 283, 284, 1397 285, 286, 287, 288, 289, 290, 272, 57, 273, 274, 1398 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1399 285, 286, 287, 288, 289, 290, 272, 0, 273, 274, 1400 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1401 285, 286, 287, 288, 289, 290, 272, 0, 273, 274, 1402 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1403 285, 286, 287, 288, 289, 290, 272, 0, 273, 274, 1404 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1405 285, 286, 287, 288, 289, 290, 272, 0, 273, 274, 1406 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1407 285, 286, 287, 288, 289, 290, 272, 0, 273, 274, 1408 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 1409 285, 286, 287, 288, 289, 290, 0, 0, 0, 0, 1410 0, 0, 0, 272, 456, 273, 274, 275, 276, 277, 1411 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 1412 288, 289, 290, 272, 459, 273, 274, 275, 276, 277, 1413 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 1414 288, 289, 290, 272, 462, 273, 274, 275, 276, 277, 1415 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 1416 288, 289, 290, 272, 471, 273, 274, 275, 276, 277, 1417 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 1418 288, 289, 290, 272, 551, 273, 274, 275, 276, 277, 1419 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 1420 288, 289, 290, 272, 552, 273, 274, 275, 276, 277, 1421 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 1422 288, 289, 290, 0, 0, 0, 0, 0, 0, 0, 1423 272, 553, 273, 274, 275, 276, 277, 278, 279, 280, 1424 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 1425 272, 554, 273, 274, 275, 276, 277, 278, 279, 280, 1426 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 1427 272, 555, 273, 274, 275, 276, 277, 278, 279, 280, 1428 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 1429 272, 556, 273, 274, 275, 276, 277, 278, 279, 280, 1430 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 1431 272, 581, 273, 274, 275, 276, 277, 278, 279, 280, 1432 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 1433 272, 599, 273, 274, 275, 276, 277, 278, 279, 280, 1434 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 1435 0, 0, 0, 0, 0, 0, 0, 272, 605, 273, 1436 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 1437 284, 285, 286, 287, 288, 289, 290, 272, 606, 273, 1438 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 1439 284, 285, 286, 287, 288, 289, 290, 272, 610, 273, 1440 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 1441 284, 285, 286, 287, 288, 289, 290, 272, 620, 273, 1442 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 1443 284, 285, 286, 287, 288, 289, 290, 0, 623, 275, 1444 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 1445 286, 287, 288, 289, 290, 272, 291, 273, 274, 275, 1446 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 1447 286, 287, 288, 289, 290, 0, 0, 0, 0, 0, 1448 0, 0, 272, 451, 273, 274, 275, 276, 277, 278, 1449 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 1450 289, 290, 272, 457, 273, 274, 275, 276, 277, 278, 1451 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 1452 289, 290, 0, 458, 680, 683, 0, 0, 70, 0, 1453 689, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1454 0, 0, 0, 467, 0, 0, 0, 0, 0, 0, 1455 0, 70, 0, 0, 0, 0, 714, 680, 0, 0, 1456 0, 0, 71, 0, 0, 0, 723, 724, 0, 689, 1457 0, 726, 727, 0, 0, 0, 0, 0, 0, 731, 1458 0, 468, 0, 453, 0, 71, 0, 0, 72, 0, 1459 0, 714, 0, 0, 0, 0, 0, 0, 0, 0, 1460 0, 0, 0, 0, 750, 0, 0, 0, 472, 0, 1461 0, 72, 0, 0, 0, 0, 0, 0, 0, 0, 1462 0, 0, 0, 73, 0, 0, 0, 0, 729, 74, 1463 75, 76, 77, 78, -43, 79, 80, 81, 0, 82, 1464 83, 0, 84, 85, 86, 0, 73, 0, 0, 87, 1465 88, 89, 74, 75, 76, 77, 78, 0, 79, 80, 1466 81, 0, 82, 83, 0, 84, 85, 86, 0, 0, 1467 0, 0, 87, 88, 89, 272, 0, 273, 274, 275, 1468 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 1469 286, 287, 288, 289, 290, 0, 0, 527, 272, 474, 1470 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 1471 283, 284, 285, 286, 287, 288, 289, 290, 272, 533, 1472 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 1473 283, 284, 285, 286, 287, 288, 289, 290, 272, 0, 1474 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 1475 283, 284, 285, 286, 287, 288, 289, 290, 274, 275, 1476 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 1477 286, 287, 288, 289, 290, 276, 277, 278, 279, 280, 1478 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 1479 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 1480 288, 289, 290 1481 }; 1482 1483 static const yytype_int16 yycheck[] = 1484 { 1485 74, 72, 106, 217, 23, 18, 4, 4, 4, 230, 1486 84, 115, 4, 25, 228, 229, 236, 91, 483, 15, 1487 4, 5, 4, 15, 4, 5, 654, 4, 4, 5, 1488 486, 4, 4, 56, 36, 4, 32, 4, 5, 571, 1489 32, 4, 0, 4, 68, 69, 70, 71, 72, 624, 1490 4, 645, 15, 6, 15, 57, 6, 128, 129, 4, 1491 131, 132, 54, 55, 4, 4, 137, 684, 56, 32, 1492 4, 32, 128, 128, 606, 669, 651, 151, 152, 4, 1493 697, 56, 57, 4, 5, 742, 142, 142, 6, 141, 1494 15, 54, 55, 145, 56, 64, 6, 732, 755, 693, 1495 174, 175, 4, 177, 4, 128, 16, 32, 743, 684, 1496 56, 185, 57, 569, 4, 15, 581, 57, 100, 143, 1497 104, 4, 697, 56, 104, 753, 37, 348, 104, 54, 1498 55, 205, 32, 4, 5, 98, 141, 104, 143, 141, 1499 49, 50, 4, 5, 215, 143, 138, 143, 146, 146, 1500 141, 142, 144, 128, 54, 55, 37, 141, 623, 143, 1501 141, 141, 143, 143, 141, 141, 240, 143, 141, 243, 1502 244, 143, 246, 247, 141, 138, 143, 251, 252, 253, 1503 254, 255, 143, 104, 258, 197, 198, 141, 141, 263, 1504 264, 141, 126, 267, 268, 129, 130, 131, 272, 273, 1505 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 1506 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 1507 141, 4, 143, 443, 126, 299, 300, 129, 130, 131, 1508 56, 3, 4, 104, 4, 141, 126, 143, 138, 129, 1509 130, 131, 104, 126, 37, 15, 129, 130, 131, 320, 1510 4, 37, 122, 123, 124, 359, 360, 37, 30, 31, 1511 37, 15, 32, 133, 37, 37, 38, 39, 3, 4, 1512 140, 32, 33, 34, 345, 37, 347, 39, 32, 51, 1513 52, 53, 502, 132, 54, 55, 58, 135, 136, 137, 1514 141, 63, 143, 4, 37, 37, 68, 69, 70, 71, 1515 72, 73, 3, 37, 37, 37, 78, 79, 80, 81, 1516 82, 83, 84, 30, 31, 32, 33, 34, 331, 91, 1517 4, 93, 28, 29, 30, 31, 32, 33, 34, 549, 1518 37, 545, 37, 37, 37, 37, 108, 4, 4, 4, 1519 4, 4, 114, 4, 363, 4, 57, 4, 4, 4, 1520 110, 4, 4, 64, 428, 142, 430, 431, 432, 57, 1521 57, 72, 16, 142, 4, 16, 77, 139, 138, 4, 1522 4, 143, 4, 4, 146, 147, 4, 4, 3, 4, 1523 454, 6, 4, 457, 458, 96, 460, 4, 37, 4, 1524 4, 102, 103, 467, 468, 37, 56, 141, 37, 37, 1525 474, 37, 4, 114, 57, 30, 31, 37, 37, 421, 1526 141, 64, 37, 38, 39, 141, 37, 37, 37, 72, 1527 141, 37, 4, 56, 77, 37, 51, 52, 53, 37, 1528 37, 37, 37, 58, 36, 143, 37, 37, 63, 37, 1529 37, 37, 142, 96, 57, 37, 142, 57, 73, 102, 1530 103, 141, 526, 78, 79, 80, 81, 82, 83, 84, 1531 143, 114, 64, 143, 143, 143, 91, 143, 93, 143, 1532 72, 575, 143, 143, 6, 77, 6, 4, 4, 4, 1533 4, 143, 4, 108, 4, 4, 4, 4, 4, 114, 1534 564, 4, 4, 4, 96, 142, 570, 142, 572, 4, 1535 102, 103, 4, 607, 37, 517, 518, 4, 37, 583, 1536 4, 56, 114, 16, 139, 141, 141, 4, 4, 143, 1537 143, 146, 147, 37, 16, 143, 16, 601, 3, 4, 1538 37, 6, 143, 142, 608, 6, 7, 8, 9, 10, 1539 11, 12, 13, 14, 758, 100, 90, 761, 143, 143, 1540 143, 765, 143, 141, 143, 30, 31, 143, 143, 4, 1541 4, 57, 37, 38, 39, 143, 637, 36, 672, 143, 1542 91, 143, 37, 16, 38, 56, 51, 52, 53, 37, 1543 37, 143, 6, 58, 141, 37, 142, 93, 63, 6, 1544 7, 8, 9, 10, 11, 12, 13, 14, 73, 142, 1545 3, 4, 101, 78, 79, 80, 81, 82, 83, 84, 1546 57, 37, 6, 687, 37, 16, 91, 56, 93, 56, 1547 37, 37, 37, 16, 37, 37, 37, 30, 31, 37, 1548 37, 37, 57, 108, 37, 38, 39, 40, 37, 114, 1549 37, 25, 56, 143, 4, 37, 37, 37, 51, 52, 1550 53, 37, 143, 57, 37, 58, 36, 25, 143, 143, 1551 63, 143, 100, 143, 139, 143, 141, 143, 4, 143, 1552 73, 146, 147, 143, 4, 78, 79, 80, 81, 82, 1553 83, 84, 3, 4, 143, 4, 245, 143, 91, 143, 1554 93, 669, 143, 143, 143, 16, 703, 143, 213, 141, 1555 651, 688, 745, 717, 496, 108, 535, 437, 568, 30, 1556 31, 114, 431, 26, 242, 560, 37, 38, 39, 3, 1557 4, 695, 99, -1, -1, -1, -1, -1, -1, -1, 1558 51, 52, 53, 336, -1, -1, 139, 58, -1, -1, 1559 -1, -1, 63, 146, 147, -1, 30, 31, -1, -1, 1560 -1, -1, 73, 37, 38, 39, -1, 78, 79, 80, 1561 81, 82, 83, 84, -1, -1, -1, 51, 52, 53, 1562 91, -1, 93, -1, 58, -1, -1, -1, -1, 63, 1563 -1, -1, -1, -1, -1, -1, -1, 108, -1, 73, 1564 -1, -1, -1, 114, 78, 79, 80, 81, 82, 83, 1565 84, 4, -1, -1, -1, -1, -1, 91, -1, 93, 1566 -1, -1, 15, -1, -1, -1, -1, -1, 139, -1, 1567 -1, -1, -1, -1, 108, 146, 147, -1, -1, 32, 1568 114, -1, -1, -1, -1, -1, -1, -1, 41, 42, 1569 43, 44, 45, -1, -1, -1, -1, -1, -1, -1, 1570 -1, 54, 55, -1, -1, 139, -1, -1, -1, -1, 1571 -1, 64, 146, 147, 15, -1, 17, 18, 19, 20, 1572 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 1573 31, 32, 33, 34, -1, -1, -1, -1, -1, 92, 1574 4, 94, -1, -1, -1, 98, -1, -1, -1, 102, 1575 103, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1576 15, 114, 17, 18, 19, 20, 21, 22, 23, 24, 1577 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1578 -1, 134, 46, 47, 48, 138, -1, -1, -1, 142, 1579 -1, 144, -1, -1, -1, 59, 60, 61, 62, -1, 1580 64, 65, 66, 67, -1, -1, -1, -1, -1, 4, 1581 74, 75, 76, 77, -1, -1, -1, -1, -1, -1, 1582 -1, 85, 86, 87, 88, 89, 90, -1, -1, -1, 1583 -1, 95, 96, 97, -1, -1, -1, -1, 102, 103, 1584 141, 36, 143, -1, -1, -1, -1, -1, -1, -1, 1585 114, 46, 47, 48, -1, -1, -1, -1, -1, -1, 1586 -1, -1, 126, -1, 59, 60, 61, 62, 132, 64, 1587 65, 66, 67, -1, -1, -1, -1, -1, 142, 74, 1588 75, 76, 77, -1, -1, -1, -1, -1, 143, -1, 1589 85, 86, 87, 88, 89, 90, -1, -1, -1, -1, 1590 95, 96, 97, -1, -1, -1, -1, 102, 103, -1, 1591 -1, -1, -1, -1, -1, -1, -1, -1, -1, 114, 1592 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 1593 34, 126, 21, 22, 23, 24, 25, 26, 27, 28, 1594 29, 30, 31, 32, 33, 34, 15, 142, 17, 18, 1595 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1596 29, 30, 31, 32, 33, 34, 15, -1, 17, 18, 1597 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1598 29, 30, 31, 32, 33, 34, 15, -1, 17, 18, 1599 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1600 29, 30, 31, 32, 33, 34, 15, -1, 17, 18, 1601 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1602 29, 30, 31, 32, 33, 34, 15, -1, 17, 18, 1603 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1604 29, 30, 31, 32, 33, 34, 15, -1, 17, 18, 1605 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1606 29, 30, 31, 32, 33, 34, -1, -1, -1, -1, 1607 -1, -1, -1, 15, 143, 17, 18, 19, 20, 21, 1608 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1609 32, 33, 34, 15, 143, 17, 18, 19, 20, 21, 1610 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1611 32, 33, 34, 15, 143, 17, 18, 19, 20, 21, 1612 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1613 32, 33, 34, 15, 143, 17, 18, 19, 20, 21, 1614 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1615 32, 33, 34, 15, 143, 17, 18, 19, 20, 21, 1616 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1617 32, 33, 34, 15, 143, 17, 18, 19, 20, 21, 1618 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1619 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, 1620 15, 143, 17, 18, 19, 20, 21, 22, 23, 24, 1621 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1622 15, 143, 17, 18, 19, 20, 21, 22, 23, 24, 1623 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1624 15, 143, 17, 18, 19, 20, 21, 22, 23, 24, 1625 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1626 15, 143, 17, 18, 19, 20, 21, 22, 23, 24, 1627 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1628 15, 143, 17, 18, 19, 20, 21, 22, 23, 24, 1629 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1630 15, 143, 17, 18, 19, 20, 21, 22, 23, 24, 1631 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1632 -1, -1, -1, -1, -1, -1, -1, 15, 143, 17, 1633 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 1634 28, 29, 30, 31, 32, 33, 34, 15, 143, 17, 1635 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 1636 28, 29, 30, 31, 32, 33, 34, 15, 143, 17, 1637 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 1638 28, 29, 30, 31, 32, 33, 34, 15, 143, 17, 1639 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 1640 28, 29, 30, 31, 32, 33, 34, -1, 143, 19, 1641 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 1642 30, 31, 32, 33, 34, 15, 141, 17, 18, 19, 1643 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 1644 30, 31, 32, 33, 34, -1, -1, -1, -1, -1, 1645 -1, -1, 15, 141, 17, 18, 19, 20, 21, 22, 1646 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 1647 33, 34, 15, 141, 17, 18, 19, 20, 21, 22, 1648 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 1649 33, 34, -1, 141, 658, 659, -1, -1, 4, -1, 1650 664, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1651 -1, -1, -1, 141, -1, -1, -1, -1, -1, -1, 1652 -1, 4, -1, -1, -1, -1, 690, 691, -1, -1, 1653 -1, -1, 38, -1, -1, -1, 700, 701, -1, 703, 1654 -1, 705, 706, -1, -1, -1, -1, -1, -1, 713, 1655 -1, 141, -1, 36, -1, 38, -1, -1, 64, -1, 1656 -1, 725, -1, -1, -1, -1, -1, -1, -1, -1, 1657 -1, -1, -1, -1, 738, -1, -1, -1, 141, -1, 1658 -1, 64, -1, -1, -1, -1, -1, -1, -1, -1, 1659 -1, -1, -1, 99, -1, -1, -1, -1, 141, 105, 1660 106, 107, 108, 109, 110, 111, 112, 113, -1, 115, 1661 116, -1, 118, 119, 120, -1, 99, -1, -1, 125, 1662 126, 127, 105, 106, 107, 108, 109, -1, 111, 112, 1663 113, -1, 115, 116, -1, 118, 119, 120, -1, -1, 1664 -1, -1, 125, 126, 127, 15, -1, 17, 18, 19, 1665 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 1666 30, 31, 32, 33, 34, -1, -1, 37, 15, 16, 1667 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1668 27, 28, 29, 30, 31, 32, 33, 34, 15, 16, 1669 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1670 27, 28, 29, 30, 31, 32, 33, 34, 15, -1, 1671 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1672 27, 28, 29, 30, 31, 32, 33, 34, 18, 19, 1673 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 1674 30, 31, 32, 33, 34, 20, 21, 22, 23, 24, 1675 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1676 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1677 32, 33, 34 1678 }; 1679 1680 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1681 symbol of state STATE-NUM. */ 1682 static const yytype_uint16 yystos[] = 1683 { 1684 0, 122, 123, 124, 133, 140, 149, 165, 166, 153, 1685 154, 151, 152, 262, 263, 257, 258, 0, 167, 155, 1686 4, 56, 128, 266, 267, 56, 259, 260, 4, 46, 1687 47, 48, 59, 60, 61, 62, 64, 65, 66, 67, 1688 74, 75, 76, 77, 85, 86, 87, 88, 89, 90, 1689 95, 96, 97, 102, 103, 114, 126, 142, 168, 175, 1690 177, 196, 198, 209, 210, 212, 214, 249, 264, 265, 1691 4, 38, 64, 99, 105, 106, 107, 108, 109, 111, 1692 112, 113, 115, 116, 118, 119, 120, 125, 126, 127, 1693 156, 6, 4, 126, 129, 130, 131, 269, 270, 56, 1694 267, 130, 131, 261, 270, 260, 6, 7, 8, 9, 1695 10, 11, 12, 13, 14, 194, 56, 56, 49, 50, 1696 37, 37, 4, 150, 56, 37, 37, 37, 37, 37, 1697 37, 37, 37, 37, 37, 37, 169, 37, 37, 37, 1698 178, 37, 141, 142, 195, 132, 4, 150, 4, 3, 1699 4, 30, 31, 37, 38, 39, 51, 52, 53, 58, 1700 63, 73, 78, 79, 80, 81, 82, 83, 84, 91, 1701 93, 108, 114, 139, 146, 147, 218, 4, 4, 160, 1702 4, 159, 158, 4, 4, 4, 218, 4, 3, 4, 1703 161, 162, 163, 4, 110, 218, 4, 16, 16, 57, 1704 142, 269, 57, 142, 216, 217, 216, 176, 250, 4, 1705 4, 4, 4, 170, 4, 64, 199, 200, 201, 4, 1706 4, 4, 150, 150, 4, 150, 143, 150, 211, 213, 1707 4, 215, 4, 5, 104, 171, 37, 150, 4, 4, 1708 37, 162, 56, 6, 141, 157, 6, 141, 218, 218, 1709 218, 37, 37, 37, 37, 37, 37, 37, 37, 37, 1710 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 1711 218, 218, 15, 17, 18, 19, 20, 21, 22, 23, 1712 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 1713 34, 141, 6, 141, 218, 141, 141, 4, 141, 6, 1714 141, 218, 141, 141, 4, 164, 56, 270, 270, 142, 1715 4, 126, 129, 130, 131, 57, 142, 218, 4, 57, 1716 64, 72, 96, 177, 224, 4, 57, 251, 141, 143, 1717 143, 167, 202, 150, 57, 141, 197, 141, 143, 143, 1718 143, 143, 143, 143, 143, 197, 143, 197, 141, 215, 1719 143, 37, 4, 5, 104, 141, 143, 171, 143, 6, 1720 6, 218, 143, 266, 218, 218, 155, 218, 218, 143, 1721 218, 218, 218, 218, 218, 4, 4, 218, 4, 4, 1722 4, 4, 218, 218, 4, 4, 218, 218, 4, 218, 1723 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 1724 218, 218, 218, 218, 218, 218, 218, 218, 218, 218, 1725 218, 4, 4, 4, 218, 218, 3, 4, 4, 4, 1726 141, 272, 142, 142, 4, 128, 142, 268, 225, 150, 1727 230, 235, 252, 4, 36, 37, 206, 203, 201, 4, 1728 150, 150, 215, 172, 37, 4, 5, 104, 143, 216, 1729 216, 141, 57, 36, 141, 143, 143, 141, 141, 143, 1730 141, 143, 143, 143, 143, 143, 143, 141, 141, 143, 1731 143, 143, 141, 143, 16, 4, 270, 131, 56, 128, 1732 142, 37, 40, 218, 239, 240, 237, 16, 218, 241, 1733 240, 218, 254, 141, 4, 146, 207, 208, 16, 199, 1734 143, 171, 174, 37, 143, 143, 4, 218, 218, 218, 1735 218, 218, 218, 4, 218, 142, 273, 16, 271, 68, 1736 69, 70, 71, 72, 143, 238, 37, 37, 239, 16, 1737 100, 220, 176, 16, 90, 242, 236, 4, 100, 255, 1738 4, 4, 143, 208, 91, 204, 36, 143, 171, 173, 1739 143, 143, 143, 143, 143, 143, 143, 143, 57, 270, 1740 270, 143, 218, 16, 37, 38, 221, 36, 220, 56, 1741 37, 256, 37, 253, 143, 6, 197, 143, 171, 142, 1742 273, 143, 218, 37, 101, 222, 222, 176, 218, 255, 1743 218, 142, 216, 93, 205, 143, 57, 39, 239, 143, 1744 218, 37, 226, 231, 57, 143, 143, 6, 37, 16, 1745 143, 218, 135, 136, 137, 223, 56, 255, 216, 218, 1746 143, 56, 232, 143, 227, 245, 239, 4, 15, 32, 1747 41, 42, 43, 44, 45, 54, 55, 64, 92, 94, 1748 98, 114, 134, 138, 142, 144, 179, 180, 183, 184, 1749 186, 189, 190, 191, 196, 4, 57, 16, 37, 37, 1750 150, 37, 187, 37, 37, 4, 54, 180, 182, 37, 1751 186, 57, 37, 195, 246, 233, 54, 55, 98, 138, 1752 179, 54, 55, 179, 188, 192, 216, 37, 185, 179, 1753 181, 37, 145, 197, 182, 228, 216, 56, 25, 243, 1754 37, 37, 143, 37, 143, 37, 37, 143, 190, 143, 1755 218, 4, 183, 143, 179, 180, 143, 243, 143, 190, 1756 4, 100, 219, 179, 179, 181, 179, 179, 36, 141, 1757 143, 179, 219, 57, 25, 244, 143, 143, 143, 143, 1758 143, 4, 244, 247, 4, 6, 16, 193, 143, 143, 1759 179, 143, 143, 143, 193, 244, 192, 4, 234, 143, 1760 195, 229, 193, 197, 197, 248, 197 1761 }; 1762 1763 #define yyerrok (yyerrstatus = 0) 1764 #define yyclearin (yychar = YYEMPTY) 1765 #define YYEMPTY (-2) 1766 #define YYEOF 0 1767 1768 #define YYACCEPT goto yyacceptlab 1769 #define YYABORT goto yyabortlab 1770 #define YYERROR goto yyerrorlab 1771 1772 1773 /* Like YYERROR except do call yyerror. This remains here temporarily 1774 to ease the transition to the new meaning of YYERROR, for GCC. 1775 Once GCC version 2 has supplanted version 1, this can go. */ 1776 1777 #define YYFAIL goto yyerrlab 1778 1779 #define YYRECOVERING() (!!yyerrstatus) 1780 1781 #define YYBACKUP(Token, Value) \ 1782 do \ 1783 if (yychar == YYEMPTY && yylen == 1) \ 1784 { \ 1785 yychar = (Token); \ 1786 yylval = (Value); \ 1787 yytoken = YYTRANSLATE (yychar); \ 1788 YYPOPSTACK (1); \ 1789 goto yybackup; \ 1790 } \ 1791 else \ 1792 { \ 1793 yyerror (YY_("syntax error: cannot back up")); \ 1794 YYERROR; \ 1795 } \ 1796 while (YYID (0)) 1797 1798 1799 #define YYTERROR 1 1800 #define YYERRCODE 256 1801 1802 1803 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1804 If N is 0, then set CURRENT to the empty location which ends 1805 the previous symbol: RHS[0] (always defined). */ 1806 1807 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1808 #ifndef YYLLOC_DEFAULT 1809 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1810 do \ 1811 if (YYID (N)) \ 1812 { \ 1813 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1814 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1815 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1816 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1817 } \ 1818 else \ 1819 { \ 1820 (Current).first_line = (Current).last_line = \ 1821 YYRHSLOC (Rhs, 0).last_line; \ 1822 (Current).first_column = (Current).last_column = \ 1823 YYRHSLOC (Rhs, 0).last_column; \ 1824 } \ 1825 while (YYID (0)) 1826 #endif 1827 1828 1829 /* YY_LOCATION_PRINT -- Print the location on the stream. 1830 This macro was not mandated originally: define only if we know 1831 we won't break user code: when these are the locations we know. */ 1832 1833 #ifndef YY_LOCATION_PRINT 1834 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 1835 # define YY_LOCATION_PRINT(File, Loc) \ 1836 fprintf (File, "%d.%d-%d.%d", \ 1837 (Loc).first_line, (Loc).first_column, \ 1838 (Loc).last_line, (Loc).last_column) 1839 # else 1840 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1841 # endif 1842 #endif 1843 1844 1845 /* YYLEX -- calling `yylex' with the right arguments. */ 1846 1847 #ifdef YYLEX_PARAM 1848 # define YYLEX yylex (YYLEX_PARAM) 1849 #else 1850 # define YYLEX yylex () 1851 #endif 1852 1853 /* Enable debugging if requested. */ 1854 #if YYDEBUG 1855 1856 # ifndef YYFPRINTF 1857 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1858 # define YYFPRINTF fprintf 1859 # endif 1860 1861 # define YYDPRINTF(Args) \ 1862 do { \ 1863 if (yydebug) \ 1864 YYFPRINTF Args; \ 1865 } while (YYID (0)) 1866 1867 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1868 do { \ 1869 if (yydebug) \ 1870 { \ 1871 YYFPRINTF (stderr, "%s ", Title); \ 1872 yy_symbol_print (stderr, \ 1873 Type, Value); \ 1874 YYFPRINTF (stderr, "\n"); \ 1875 } \ 1876 } while (YYID (0)) 1877 1878 1879 /*--------------------------------. 1880 | Print this symbol on YYOUTPUT. | 1881 `--------------------------------*/ 1882 1883 /*ARGSUSED*/ 1884 #if (defined __STDC__ || defined __C99__FUNC__ \ 1885 || defined __cplusplus || defined _MSC_VER) 1886 static void 1887 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1888 #else 1889 static void 1890 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 1891 FILE *yyoutput; 1892 int yytype; 1893 YYSTYPE const * const yyvaluep; 1894 #endif 1895 { 1896 if (!yyvaluep) 1897 return; 1898 # ifdef YYPRINT 1899 if (yytype < YYNTOKENS) 1900 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1901 # else 1902 YYUSE (yyoutput); 1903 # endif 1904 switch (yytype) 1905 { 1906 default: 1907 break; 1908 } 1909 } 1910 1911 1912 /*--------------------------------. 1913 | Print this symbol on YYOUTPUT. | 1914 `--------------------------------*/ 1915 1916 #if (defined __STDC__ || defined __C99__FUNC__ \ 1917 || defined __cplusplus || defined _MSC_VER) 1918 static void 1919 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 1920 #else 1921 static void 1922 yy_symbol_print (yyoutput, yytype, yyvaluep) 1923 FILE *yyoutput; 1924 int yytype; 1925 YYSTYPE const * const yyvaluep; 1926 #endif 1927 { 1928 if (yytype < YYNTOKENS) 1929 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1930 else 1931 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1932 1933 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 1934 YYFPRINTF (yyoutput, ")"); 1935 } 1936 1937 /*------------------------------------------------------------------. 1938 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1939 | TOP (included). | 1940 `------------------------------------------------------------------*/ 1941 1942 #if (defined __STDC__ || defined __C99__FUNC__ \ 1943 || defined __cplusplus || defined _MSC_VER) 1944 static void 1945 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 1946 #else 1947 static void 1948 yy_stack_print (bottom, top) 1949 yytype_int16 *bottom; 1950 yytype_int16 *top; 1951 #endif 1952 { 1953 YYFPRINTF (stderr, "Stack now"); 1954 for (; bottom <= top; ++bottom) 1955 YYFPRINTF (stderr, " %d", *bottom); 1956 YYFPRINTF (stderr, "\n"); 1957 } 1958 1959 # define YY_STACK_PRINT(Bottom, Top) \ 1960 do { \ 1961 if (yydebug) \ 1962 yy_stack_print ((Bottom), (Top)); \ 1963 } while (YYID (0)) 1964 1965 1966 /*------------------------------------------------. 1967 | Report that the YYRULE is going to be reduced. | 1968 `------------------------------------------------*/ 1969 1970 #if (defined __STDC__ || defined __C99__FUNC__ \ 1971 || defined __cplusplus || defined _MSC_VER) 1972 static void 1973 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1974 #else 1975 static void 1976 yy_reduce_print (yyvsp, yyrule) 1977 YYSTYPE *yyvsp; 1978 int yyrule; 1979 #endif 1980 { 1981 int yynrhs = yyr2[yyrule]; 1982 int yyi; 1983 unsigned long int yylno = yyrline[yyrule]; 1984 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1985 yyrule - 1, yylno); 1986 /* The symbols being reduced. */ 1987 for (yyi = 0; yyi < yynrhs; yyi++) 1988 { 1989 fprintf (stderr, " $%d = ", yyi + 1); 1990 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1991 &(yyvsp[(yyi + 1) - (yynrhs)]) 1992 ); 1993 fprintf (stderr, "\n"); 1994 } 1995 } 1996 1997 # define YY_REDUCE_PRINT(Rule) \ 1998 do { \ 1999 if (yydebug) \ 2000 yy_reduce_print (yyvsp, Rule); \ 2001 } while (YYID (0)) 2002 2003 /* Nonzero means print parse trace. It is left uninitialized so that 2004 multiple parsers can coexist. */ 2005 int yydebug; 2006 #else /* !YYDEBUG */ 2007 # define YYDPRINTF(Args) 2008 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 2009 # define YY_STACK_PRINT(Bottom, Top) 2010 # define YY_REDUCE_PRINT(Rule) 2011 #endif /* !YYDEBUG */ 2012 2013 2014 /* YYINITDEPTH -- initial size of the parser's stacks. */ 2015 #ifndef YYINITDEPTH 2016 # define YYINITDEPTH 200 2017 #endif 2018 2019 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 2020 if the built-in stack extension method is used). 2021 2022 Do not make this value too large; the results are undefined if 2023 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 2024 evaluated with infinite-precision integer arithmetic. */ 2025 2026 #ifndef YYMAXDEPTH 2027 # define YYMAXDEPTH 10000 2028 #endif 2029 2030 2031 2033 #if YYERROR_VERBOSE 2034 2035 # ifndef yystrlen 2036 # if defined __GLIBC__ && defined _STRING_H 2037 # define yystrlen strlen 2038 # else 2039 /* Return the length of YYSTR. */ 2040 #if (defined __STDC__ || defined __C99__FUNC__ \ 2041 || defined __cplusplus || defined _MSC_VER) 2042 static YYSIZE_T 2043 yystrlen (const char *yystr) 2044 #else 2045 static YYSIZE_T 2046 yystrlen (yystr) 2047 const char *yystr; 2048 #endif 2049 { 2050 YYSIZE_T yylen; 2051 for (yylen = 0; yystr[yylen]; yylen++) 2052 continue; 2053 return yylen; 2054 } 2055 # endif 2056 # endif 2057 2058 # ifndef yystpcpy 2059 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 2060 # define yystpcpy stpcpy 2061 # else 2062 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 2063 YYDEST. */ 2064 #if (defined __STDC__ || defined __C99__FUNC__ \ 2065 || defined __cplusplus || defined _MSC_VER) 2066 static char * 2067 yystpcpy (char *yydest, const char *yysrc) 2068 #else 2069 static char * 2070 yystpcpy (yydest, yysrc) 2071 char *yydest; 2072 const char *yysrc; 2073 #endif 2074 { 2075 char *yyd = yydest; 2076 const char *yys = yysrc; 2077 2078 while ((*yyd++ = *yys++) != '\0') 2079 continue; 2080 2081 return yyd - 1; 2082 } 2083 # endif 2084 # endif 2085 2086 # ifndef yytnamerr 2087 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 2088 quotes and backslashes, so that it's suitable for yyerror. The 2089 heuristic is that double-quoting is unnecessary unless the string 2090 contains an apostrophe, a comma, or backslash (other than 2091 backslash-backslash). YYSTR is taken from yytname. If YYRES is 2092 null, do not copy; instead, return the length of what the result 2093 would have been. */ 2094 static YYSIZE_T 2095 yytnamerr (char *yyres, const char *yystr) 2096 { 2097 if (*yystr == '"') 2098 { 2099 YYSIZE_T yyn = 0; 2100 char const *yyp = yystr; 2101 2102 for (;;) 2103 switch (*++yyp) 2104 { 2105 case '\'': 2106 case ',': 2107 goto do_not_strip_quotes; 2108 2109 case '\\': 2110 if (*++yyp != '\\') 2111 goto do_not_strip_quotes; 2112 /* Fall through. */ 2113 default: 2114 if (yyres) 2115 yyres[yyn] = *yyp; 2116 yyn++; 2117 break; 2118 2119 case '"': 2120 if (yyres) 2121 yyres[yyn] = '\0'; 2122 return yyn; 2123 } 2124 do_not_strip_quotes: ; 2125 } 2126 2127 if (! yyres) 2128 return yystrlen (yystr); 2129 2130 return yystpcpy (yyres, yystr) - yyres; 2131 } 2132 # endif 2133 2134 /* Copy into YYRESULT an error message about the unexpected token 2135 YYCHAR while in state YYSTATE. Return the number of bytes copied, 2136 including the terminating null byte. If YYRESULT is null, do not 2137 copy anything; just return the number of bytes that would be 2138 copied. As a special case, return 0 if an ordinary "syntax error" 2139 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 2140 size calculation. */ 2141 static YYSIZE_T 2142 yysyntax_error (char *yyresult, int yystate, int yychar) 2143 { 2144 int yyn = yypact[yystate]; 2145 2146 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 2147 return 0; 2148 else 2149 { 2150 int yytype = YYTRANSLATE (yychar); 2151 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 2152 YYSIZE_T yysize = yysize0; 2153 YYSIZE_T yysize1; 2154 int yysize_overflow = 0; 2155 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 2156 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 2157 int yyx; 2158 2159 # if 0 2160 /* This is so xgettext sees the translatable formats that are 2161 constructed on the fly. */ 2162 YY_("syntax error, unexpected %s"); 2163 YY_("syntax error, unexpected %s, expecting %s"); 2164 YY_("syntax error, unexpected %s, expecting %s or %s"); 2165 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 2166 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 2167 # endif 2168 char *yyfmt; 2169 char const *yyf; 2170 static char const yyunexpected[] = "syntax error, unexpected %s"; 2171 static char const yyexpecting[] = ", expecting %s"; 2172 static char const yyor[] = " or %s"; 2173 char yyformat[sizeof yyunexpected 2174 + sizeof yyexpecting - 1 2175 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 2176 * (sizeof yyor - 1))]; 2177 char const *yyprefix = yyexpecting; 2178 2179 /* Start YYX at -YYN if negative to avoid negative indexes in 2180 YYCHECK. */ 2181 int yyxbegin = yyn < 0 ? -yyn : 0; 2182 2183 /* Stay within bounds of both yycheck and yytname. */ 2184 int yychecklim = YYLAST - yyn + 1; 2185 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 2186 int yycount = 1; 2187 2188 yyarg[0] = yytname[yytype]; 2189 yyfmt = yystpcpy (yyformat, yyunexpected); 2190 2191 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2192 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 2193 { 2194 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 2195 { 2196 yycount = 1; 2197 yysize = yysize0; 2198 yyformat[sizeof yyunexpected - 1] = '\0'; 2199 break; 2200 } 2201 yyarg[yycount++] = yytname[yyx]; 2202 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 2203 yysize_overflow |= (yysize1 < yysize); 2204 yysize = yysize1; 2205 yyfmt = yystpcpy (yyfmt, yyprefix); 2206 yyprefix = yyor; 2207 } 2208 2209 yyf = YY_(yyformat); 2210 yysize1 = yysize + yystrlen (yyf); 2211 yysize_overflow |= (yysize1 < yysize); 2212 yysize = yysize1; 2213 2214 if (yysize_overflow) 2215 return YYSIZE_MAXIMUM; 2216 2217 if (yyresult) 2218 { 2219 /* Avoid sprintf, as that infringes on the user's name space. 2220 Don't have undefined behavior even if the translation 2221 produced a string with the wrong number of "%s"s. */ 2222 char *yyp = yyresult; 2223 int yyi = 0; 2224 while ((*yyp = *yyf) != '\0') 2225 { 2226 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 2227 { 2228 yyp += yytnamerr (yyp, yyarg[yyi++]); 2229 yyf += 2; 2230 } 2231 else 2232 { 2233 yyp++; 2234 yyf++; 2235 } 2236 } 2237 } 2238 return yysize; 2239 } 2240 } 2241 #endif /* YYERROR_VERBOSE */ 2242 2243 2245 /*-----------------------------------------------. 2246 | Release the memory associated to this symbol. | 2247 `-----------------------------------------------*/ 2248 2249 /*ARGSUSED*/ 2250 #if (defined __STDC__ || defined __C99__FUNC__ \ 2251 || defined __cplusplus || defined _MSC_VER) 2252 static void 2253 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 2254 #else 2255 static void 2256 yydestruct (yymsg, yytype, yyvaluep) 2257 const char *yymsg; 2258 int yytype; 2259 YYSTYPE *yyvaluep; 2260 #endif 2261 { 2262 YYUSE (yyvaluep); 2263 2264 if (!yymsg) 2265 yymsg = "Deleting"; 2266 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 2267 2268 switch (yytype) 2269 { 2270 2271 default: 2272 break; 2273 } 2274 } 2275 2276 2278 /* Prevent warnings from -Wmissing-prototypes. */ 2279 2280 #ifdef YYPARSE_PARAM 2281 #if defined __STDC__ || defined __cplusplus 2282 int yyparse (void *YYPARSE_PARAM); 2283 #else 2284 int yyparse (); 2285 #endif 2286 #else /* ! YYPARSE_PARAM */ 2287 #if defined __STDC__ || defined __cplusplus 2288 int yyparse (void); 2289 #else 2290 int yyparse (); 2291 #endif 2292 #endif /* ! YYPARSE_PARAM */ 2293 2294 2295 2296 /* The look-ahead symbol. */ 2297 int yychar; 2298 2299 /* The semantic value of the look-ahead symbol. */ 2300 YYSTYPE yylval; 2301 2302 /* Number of syntax errors so far. */ 2303 int yynerrs; 2304 2305 2306 2307 /*----------. 2308 | yyparse. | 2309 `----------*/ 2310 2311 #ifdef YYPARSE_PARAM 2312 #if (defined __STDC__ || defined __C99__FUNC__ \ 2313 || defined __cplusplus || defined _MSC_VER) 2314 int 2315 yyparse (void *YYPARSE_PARAM) 2316 #else 2317 int 2318 yyparse (YYPARSE_PARAM) 2319 void *YYPARSE_PARAM; 2320 #endif 2321 #else /* ! YYPARSE_PARAM */ 2322 #if (defined __STDC__ || defined __C99__FUNC__ \ 2323 || defined __cplusplus || defined _MSC_VER) 2324 int 2325 yyparse (void) 2326 #else 2327 int 2328 yyparse () 2329 2330 #endif 2331 #endif 2332 { 2333 2334 int yystate; 2335 int yyn; 2336 int yyresult; 2337 /* Number of tokens to shift before error messages enabled. */ 2338 int yyerrstatus; 2339 /* Look-ahead token as an internal (translated) token number. */ 2340 int yytoken = 0; 2341 #if YYERROR_VERBOSE 2342 /* Buffer for error messages, and its allocated size. */ 2343 char yymsgbuf[128]; 2344 char *yymsg = yymsgbuf; 2345 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 2346 #endif 2347 2348 /* Three stacks and their tools: 2349 `yyss': related to states, 2350 `yyvs': related to semantic values, 2351 `yyls': related to locations. 2352 2353 Refer to the stacks thru separate pointers, to allow yyoverflow 2354 to reallocate them elsewhere. */ 2355 2356 /* The state stack. */ 2357 yytype_int16 yyssa[YYINITDEPTH]; 2358 yytype_int16 *yyss = yyssa; 2359 yytype_int16 *yyssp; 2360 2361 /* The semantic value stack. */ 2362 YYSTYPE yyvsa[YYINITDEPTH]; 2363 YYSTYPE *yyvs = yyvsa; 2364 YYSTYPE *yyvsp; 2365 2366 2367 2368 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 2369 2370 YYSIZE_T yystacksize = YYINITDEPTH; 2371 2372 /* The variables used to return semantic value and location from the 2373 action routines. */ 2374 YYSTYPE yyval; 2375 2376 2377 /* The number of symbols on the RHS of the reduced rule. 2378 Keep to zero when no symbol should be popped. */ 2379 int yylen = 0; 2380 2381 YYDPRINTF ((stderr, "Starting parse\n")); 2382 2383 yystate = 0; 2384 yyerrstatus = 0; 2385 yynerrs = 0; 2386 yychar = YYEMPTY; /* Cause a token to be read. */ 2387 2388 /* Initialize stack pointers. 2389 Waste one element of value and location stack 2390 so that they stay on the same level as the state stack. 2391 The wasted elements are never initialized. */ 2392 2393 yyssp = yyss; 2394 yyvsp = yyvs; 2395 2396 goto yysetstate; 2397 2398 /*------------------------------------------------------------. 2399 | yynewstate -- Push a new state, which is found in yystate. | 2400 `------------------------------------------------------------*/ 2401 yynewstate: 2402 /* In all cases, when you get here, the value and location stacks 2403 have just been pushed. So pushing a state here evens the stacks. */ 2404 yyssp++; 2405 2406 yysetstate: 2407 *yyssp = yystate; 2408 2409 if (yyss + yystacksize - 1 <= yyssp) 2410 { 2411 /* Get the current used size of the three stacks, in elements. */ 2412 YYSIZE_T yysize = yyssp - yyss + 1; 2413 2414 #ifdef yyoverflow 2415 { 2416 /* Give user a chance to reallocate the stack. Use copies of 2417 these so that the &'s don't force the real ones into 2418 memory. */ 2419 YYSTYPE *yyvs1 = yyvs; 2420 yytype_int16 *yyss1 = yyss; 2421 2422 2423 /* Each stack pointer address is followed by the size of the 2424 data in use in that stack, in bytes. This used to be a 2425 conditional around just the two extra args, but that might 2426 be undefined if yyoverflow is a macro. */ 2427 yyoverflow (YY_("memory exhausted"), 2428 &yyss1, yysize * sizeof (*yyssp), 2429 &yyvs1, yysize * sizeof (*yyvsp), 2430 2431 &yystacksize); 2432 2433 yyss = yyss1; 2434 yyvs = yyvs1; 2435 } 2436 #else /* no yyoverflow */ 2437 # ifndef YYSTACK_RELOCATE 2438 goto yyexhaustedlab; 2439 # else 2440 /* Extend the stack our own way. */ 2441 if (YYMAXDEPTH <= yystacksize) 2442 goto yyexhaustedlab; 2443 yystacksize *= 2; 2444 if (YYMAXDEPTH < yystacksize) 2445 yystacksize = YYMAXDEPTH; 2446 2447 { 2448 yytype_int16 *yyss1 = yyss; 2449 union yyalloc *yyptr = 2450 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 2451 if (! yyptr) 2452 goto yyexhaustedlab; 2453 YYSTACK_RELOCATE (yyss); 2454 YYSTACK_RELOCATE (yyvs); 2455 2456 # undef YYSTACK_RELOCATE 2457 if (yyss1 != yyssa) 2458 YYSTACK_FREE (yyss1); 2459 } 2460 # endif 2461 #endif /* no yyoverflow */ 2462 2463 yyssp = yyss + yysize - 1; 2464 yyvsp = yyvs + yysize - 1; 2465 2466 2467 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 2468 (unsigned long int) yystacksize)); 2469 2470 if (yyss + yystacksize - 1 <= yyssp) 2471 YYABORT; 2472 } 2473 2474 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2475 2476 goto yybackup; 2477 2478 /*-----------. 2479 | yybackup. | 2480 `-----------*/ 2481 yybackup: 2482 2483 /* Do appropriate processing given the current state. Read a 2484 look-ahead token if we need one and don't already have one. */ 2485 2486 /* First try to decide what to do without reference to look-ahead token. */ 2487 yyn = yypact[yystate]; 2488 if (yyn == YYPACT_NINF) 2489 goto yydefault; 2490 2491 /* Not known => get a look-ahead token if don't already have one. */ 2492 2493 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 2494 if (yychar == YYEMPTY) 2495 { 2496 YYDPRINTF ((stderr, "Reading a token: ")); 2497 yychar = YYLEX; 2498 } 2499 2500 if (yychar <= YYEOF) 2501 { 2502 yychar = yytoken = YYEOF; 2503 YYDPRINTF ((stderr, "Now at end of input.\n")); 2504 } 2505 else 2506 { 2507 yytoken = YYTRANSLATE (yychar); 2508 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2509 } 2510 2511 /* If the proper action on seeing token YYTOKEN is to reduce or to 2512 detect an error, take that action. */ 2513 yyn += yytoken; 2514 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 2515 goto yydefault; 2516 yyn = yytable[yyn]; 2517 if (yyn <= 0) 2518 { 2519 if (yyn == 0 || yyn == YYTABLE_NINF) 2520 goto yyerrlab; 2521 yyn = -yyn; 2522 goto yyreduce; 2523 } 2524 2525 if (yyn == YYFINAL) 2526 YYACCEPT; 2527 2528 /* Count tokens shifted since error; after three, turn off error 2529 status. */ 2530 if (yyerrstatus) 2531 yyerrstatus--; 2532 2533 /* Shift the look-ahead token. */ 2534 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2535 2536 /* Discard the shifted token unless it is eof. */ 2537 if (yychar != YYEOF) 2538 yychar = YYEMPTY; 2539 2540 yystate = yyn; 2541 *++yyvsp = yylval; 2542 2543 goto yynewstate; 2544 2545 2546 /*-----------------------------------------------------------. 2547 | yydefault -- do the default action for the current state. | 2548 `-----------------------------------------------------------*/ 2549 yydefault: 2550 yyn = yydefact[yystate]; 2551 if (yyn == 0) 2552 goto yyerrlab; 2553 goto yyreduce; 2554 2555 2556 /*-----------------------------. 2557 | yyreduce -- Do a reduction. | 2558 `-----------------------------*/ 2559 yyreduce: 2560 /* yyn is the number of a rule to reduce with. */ 2561 yylen = yyr2[yyn]; 2562 2563 /* If YYLEN is nonzero, implement the default value of the action: 2564 `$$ = $1'. 2565 2566 Otherwise, the following line sets YYVAL to garbage. 2567 This behavior is undocumented and Bison 2568 users should not rely upon it. Assigning to YYVAL 2569 unconditionally makes the parser a bit smaller, and it avoids a 2570 GCC warning that YYVAL may be used uninitialized. */ 2571 yyval = yyvsp[1-yylen]; 2572 2573 2574 YY_REDUCE_PRINT (yyn); 2575 switch (yyn) 2576 { 2577 case 8: 2578 #line 175 "ldgram.y" 2579 { ldlex_defsym(); } 2580 break; 2581 2582 case 9: 2583 #line 177 "ldgram.y" 2584 { 2585 ldlex_popstate(); 2586 lang_add_assignment (exp_defsym ((yyvsp[(2) - (4)].name), (yyvsp[(4) - (4)].etree))); 2587 } 2588 break; 2589 2590 case 10: 2591 #line 185 "ldgram.y" 2592 { 2593 ldlex_mri_script (); 2594 PUSH_ERROR (_("MRI style script")); 2595 } 2596 break; 2597 2598 case 11: 2599 #line 190 "ldgram.y" 2600 { 2601 ldlex_popstate (); 2602 mri_draw_tree (); 2603 POP_ERROR (); 2604 } 2605 break; 2606 2607 case 16: 2608 #line 205 "ldgram.y" 2609 { 2610 einfo(_("%P%F: unrecognised keyword in MRI style script '%s'\n"),(yyvsp[(1) - (1)].name)); 2611 } 2612 break; 2613 2614 case 17: 2615 #line 208 "ldgram.y" 2616 { 2617 config.map_filename = "-"; 2618 } 2619 break; 2620 2621 case 20: 2622 #line 214 "ldgram.y" 2623 { mri_public((yyvsp[(2) - (4)].name), (yyvsp[(4) - (4)].etree)); } 2624 break; 2625 2626 case 21: 2627 #line 216 "ldgram.y" 2628 { mri_public((yyvsp[(2) - (4)].name), (yyvsp[(4) - (4)].etree)); } 2629 break; 2630 2631 case 22: 2632 #line 218 "ldgram.y" 2633 { mri_public((yyvsp[(2) - (3)].name), (yyvsp[(3) - (3)].etree)); } 2634 break; 2635 2636 case 23: 2637 #line 220 "ldgram.y" 2638 { mri_format((yyvsp[(2) - (2)].name)); } 2639 break; 2640 2641 case 24: 2642 #line 222 "ldgram.y" 2643 { mri_output_section((yyvsp[(2) - (4)].name), (yyvsp[(4) - (4)].etree));} 2644 break; 2645 2646 case 25: 2647 #line 224 "ldgram.y" 2648 { mri_output_section((yyvsp[(2) - (3)].name), (yyvsp[(3) - (3)].etree));} 2649 break; 2650 2651 case 26: 2652 #line 226 "ldgram.y" 2653 { mri_output_section((yyvsp[(2) - (4)].name), (yyvsp[(4) - (4)].etree));} 2654 break; 2655 2656 case 27: 2657 #line 228 "ldgram.y" 2658 { mri_align((yyvsp[(2) - (4)].name),(yyvsp[(4) - (4)].etree)); } 2659 break; 2660 2661 case 28: 2662 #line 230 "ldgram.y" 2663 { mri_align((yyvsp[(2) - (4)].name),(yyvsp[(4) - (4)].etree)); } 2664 break; 2665 2666 case 29: 2667 #line 232 "ldgram.y" 2668 { mri_alignmod((yyvsp[(2) - (4)].name),(yyvsp[(4) - (4)].etree)); } 2669 break; 2670 2671 case 30: 2672 #line 234 "ldgram.y" 2673 { mri_alignmod((yyvsp[(2) - (4)].name),(yyvsp[(4) - (4)].etree)); } 2674 break; 2675 2676 case 33: 2677 #line 238 "ldgram.y" 2678 { mri_name((yyvsp[(2) - (2)].name)); } 2679 break; 2680 2681 case 34: 2682 #line 240 "ldgram.y" 2683 { mri_alias((yyvsp[(2) - (4)].name),(yyvsp[(4) - (4)].name),0);} 2684 break; 2685 2686 case 35: 2687 #line 242 "ldgram.y" 2688 { mri_alias ((yyvsp[(2) - (4)].name), 0, (int) (yyvsp[(4) - (4)].bigint).integer); } 2689 break; 2690 2691 case 36: 2692 #line 244 "ldgram.y" 2693 { mri_base((yyvsp[(2) - (2)].etree)); } 2694 break; 2695 2696 case 37: 2697 #line 246 "ldgram.y" 2698 { mri_truncate ((unsigned int) (yyvsp[(2) - (2)].bigint).integer); } 2699 break; 2700 2701 case 40: 2702 #line 250 "ldgram.y" 2703 { ldlex_script (); ldfile_open_command_file((yyvsp[(2) - (2)].name)); } 2704 break; 2705 2706 case 41: 2707 #line 252 "ldgram.y" 2708 { ldlex_popstate (); } 2709 break; 2710 2711 case 42: 2712 #line 254 "ldgram.y" 2713 { lang_add_entry ((yyvsp[(2) - (2)].name), FALSE); } 2714 break; 2715 2716 case 44: 2717 #line 259 "ldgram.y" 2718 { mri_order((yyvsp[(3) - (3)].name)); } 2719 break; 2720 2721 case 45: 2722 #line 260 "ldgram.y" 2723 { mri_order((yyvsp[(2) - (2)].name)); } 2724 break; 2725 2726 case 47: 2727 #line 266 "ldgram.y" 2728 { mri_load((yyvsp[(1) - (1)].name)); } 2729 break; 2730 2731 case 48: 2732 #line 267 "ldgram.y" 2733 { mri_load((yyvsp[(3) - (3)].name)); } 2734 break; 2735 2736 case 49: 2737 #line 272 "ldgram.y" 2738 { mri_only_load((yyvsp[(1) - (1)].name)); } 2739 break; 2740 2741 case 50: 2742 #line 274 "ldgram.y" 2743 { mri_only_load((yyvsp[(3) - (3)].name)); } 2744 break; 2745 2746 case 51: 2747 #line 278 "ldgram.y" 2748 { (yyval.name) = NULL; } 2749 break; 2750 2751 case 54: 2752 #line 285 "ldgram.y" 2753 { ldlex_expression (); } 2754 break; 2755 2756 case 55: 2757 #line 287 "ldgram.y" 2758 { ldlex_popstate (); } 2759 break; 2760 2761 case 56: 2762 #line 291 "ldgram.y" 2763 { ldlang_add_undef ((yyvsp[(1) - (1)].name), FALSE); } 2764 break; 2765 2766 case 57: 2767 #line 293 "ldgram.y" 2768 { ldlang_add_undef ((yyvsp[(2) - (2)].name), FALSE); } 2769 break; 2770 2771 case 58: 2772 #line 295 "ldgram.y" 2773 { ldlang_add_undef ((yyvsp[(3) - (3)].name), FALSE); } 2774 break; 2775 2776 case 59: 2777 #line 299 "ldgram.y" 2778 { ldlex_both(); } 2779 break; 2780 2781 case 60: 2782 #line 301 "ldgram.y" 2783 { ldlex_popstate(); } 2784 break; 2785 2786 case 73: 2787 #line 322 "ldgram.y" 2788 { lang_add_target((yyvsp[(3) - (4)].name)); } 2789 break; 2790 2791 case 74: 2792 #line 324 "ldgram.y" 2793 { ldfile_add_library_path ((yyvsp[(3) - (4)].name), FALSE); } 2794 break; 2795 2796 case 75: 2797 #line 326 "ldgram.y" 2798 { lang_add_output((yyvsp[(3) - (4)].name), 1); } 2799 break; 2800 2801 case 76: 2802 #line 328 "ldgram.y" 2803 { lang_add_output_format ((yyvsp[(3) - (4)].name), (char *) NULL, 2804 (char *) NULL, 1); } 2805 break; 2806 2807 case 77: 2808 #line 331 "ldgram.y" 2809 { lang_add_output_format ((yyvsp[(3) - (8)].name), (yyvsp[(5) - (8)].name), (yyvsp[(7) - (8)].name), 1); } 2810 break; 2811 2812 case 78: 2813 #line 333 "ldgram.y" 2814 { ldfile_set_output_arch ((yyvsp[(3) - (4)].name), bfd_arch_unknown); } 2815 break; 2816 2817 case 79: 2818 #line 335 "ldgram.y" 2819 { command_line.force_common_definition = TRUE ; } 2820 break; 2821 2822 case 80: 2823 #line 337 "ldgram.y" 2824 { command_line.inhibit_common_definition = TRUE ; } 2825 break; 2826 2827 case 82: 2828 #line 340 "ldgram.y" 2829 { lang_enter_group (); } 2830 break; 2831 2832 case 83: 2833 #line 342 "ldgram.y" 2834 { lang_leave_group (); } 2835 break; 2836 2837 case 84: 2838 #line 344 "ldgram.y" 2839 { lang_add_map((yyvsp[(3) - (4)].name)); } 2840 break; 2841 2842 case 85: 2843 #line 346 "ldgram.y" 2844 { ldlex_script (); ldfile_open_command_file((yyvsp[(2) - (2)].name)); } 2845 break; 2846 2847 case 86: 2848 #line 348 "ldgram.y" 2849 { ldlex_popstate (); } 2850 break; 2851 2852 case 87: 2853 #line 350 "ldgram.y" 2854 { 2855 lang_add_nocrossref ((yyvsp[(3) - (4)].nocrossref)); 2856 } 2857 break; 2858 2859 case 89: 2860 #line 355 "ldgram.y" 2861 { lang_add_insert ((yyvsp[(3) - (3)].name), 0); } 2862 break; 2863 2864 case 90: 2865 #line 357 "ldgram.y" 2866 { lang_add_insert ((yyvsp[(3) - (3)].name), 1); } 2867 break; 2868 2869 case 91: 2870 #line 359 "ldgram.y" 2871 { lang_memory_region_alias ((yyvsp[(3) - (6)].name), (yyvsp[(5) - (6)].name)); } 2872 break; 2873 2874 case 92: 2875 #line 361 "ldgram.y" 2876 { lang_ld_feature ((yyvsp[(3) - (4)].name)); } 2877 break; 2878 2879 case 93: 2880 #line 366 "ldgram.y" 2881 { lang_add_input_file((yyvsp[(1) - (1)].name),lang_input_file_is_search_file_enum, 2882 (char *)NULL); } 2883 break; 2884 2885 case 94: 2886 #line 369 "ldgram.y" 2887 { lang_add_input_file((yyvsp[(3) - (3)].name),lang_input_file_is_search_file_enum, 2888 (char *)NULL); } 2889 break; 2890 2891 case 95: 2892 #line 372 "ldgram.y" 2893 { lang_add_input_file((yyvsp[(2) - (2)].name),lang_input_file_is_search_file_enum, 2894 (char *)NULL); } 2895 break; 2896 2897 case 96: 2898 #line 375 "ldgram.y" 2899 { lang_add_input_file((yyvsp[(1) - (1)].name),lang_input_file_is_l_enum, 2900 (char *)NULL); } 2901 break; 2902 2903 case 97: 2904 #line 378 "ldgram.y" 2905 { lang_add_input_file((yyvsp[(3) - (3)].name),lang_input_file_is_l_enum, 2906 (char *)NULL); } 2907 break; 2908 2909 case 98: 2910 #line 381 "ldgram.y" 2911 { lang_add_input_file((yyvsp[(2) - (2)].name),lang_input_file_is_l_enum, 2912 (char *)NULL); } 2913 break; 2914 2915 case 99: 2916 #line 384 "ldgram.y" 2917 { (yyval.integer) = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; } 2918 break; 2919 2920 case 100: 2921 #line 386 "ldgram.y" 2922 { add_DT_NEEDED_for_regular = (yyvsp[(3) - (5)].integer); } 2923 break; 2924 2925 case 101: 2926 #line 388 "ldgram.y" 2927 { (yyval.integer) = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; } 2928 break; 2929 2930 case 102: 2931 #line 390 "ldgram.y" 2932 { add_DT_NEEDED_for_regular = (yyvsp[(5) - (7)].integer); } 2933 break; 2934 2935 case 103: 2936 #line 392 "ldgram.y" 2937 { (yyval.integer) = add_DT_NEEDED_for_regular; add_DT_NEEDED_for_regular = TRUE; } 2938 break; 2939 2940 case 104: 2941 #line 394 "ldgram.y" 2942 { add_DT_NEEDED_for_regular = (yyvsp[(4) - (6)].integer); } 2943 break; 2944 2945 case 109: 2946 #line 409 "ldgram.y" 2947 { lang_add_entry ((yyvsp[(3) - (4)].name), FALSE); } 2948 break; 2949 2950 case 111: 2951 #line 411 "ldgram.y" 2952 {ldlex_expression ();} 2953 break; 2954 2955 case 112: 2956 #line 412 "ldgram.y" 2957 { ldlex_popstate (); 2958 lang_add_assignment (exp_assert ((yyvsp[(4) - (7)].etree), (yyvsp[(6) - (7)].name))); } 2959 break; 2960 2961 case 113: 2962 #line 420 "ldgram.y" 2963 { 2964 (yyval.cname) = (yyvsp[(1) - (1)].name); 2965 } 2966 break; 2967 2968 case 114: 2969 #line 424 "ldgram.y" 2970 { 2971 (yyval.cname) = "*"; 2972 } 2973 break; 2974 2975 case 115: 2976 #line 428 "ldgram.y" 2977 { 2978 (yyval.cname) = "?"; 2979 } 2980 break; 2981 2982 case 116: 2983 #line 435 "ldgram.y" 2984 { 2985 (yyval.wildcard).name = (yyvsp[(1) - (1)].cname); 2986 (yyval.wildcard).sorted = none; 2987 (yyval.wildcard).exclude_name_list = NULL; 2988 } 2989 break; 2990 2991 case 117: 2992 #line 441 "ldgram.y" 2993 { 2994 (yyval.wildcard).name = (yyvsp[(5) - (5)].cname); 2995 (yyval.wildcard).sorted = none; 2996 (yyval.wildcard).exclude_name_list = (yyvsp[(3) - (5)].name_list); 2997 } 2998 break; 2999 3000 case 118: 3001 #line 447 "ldgram.y" 3002 { 3003 (yyval.wildcard).name = (yyvsp[(3) - (4)].cname); 3004 (yyval.wildcard).sorted = by_name; 3005 (yyval.wildcard).exclude_name_list = NULL; 3006 } 3007 break; 3008 3009 case 119: 3010 #line 453 "ldgram.y" 3011 { 3012 (yyval.wildcard).name = (yyvsp[(3) - (4)].cname); 3013 (yyval.wildcard).sorted = by_alignment; 3014 (yyval.wildcard).exclude_name_list = NULL; 3015 } 3016 break; 3017 3018 case 120: 3019 #line 459 "ldgram.y" 3020 { 3021 (yyval.wildcard).name = (yyvsp[(5) - (7)].cname); 3022 (yyval.wildcard).sorted = by_name_alignment; 3023 (yyval.wildcard).exclude_name_list = NULL; 3024 } 3025 break; 3026 3027 case 121: 3028 #line 465 "ldgram.y" 3029 { 3030 (yyval.wildcard).name = (yyvsp[(5) - (7)].cname); 3031 (yyval.wildcard).sorted = by_name; 3032 (yyval.wildcard).exclude_name_list = NULL; 3033 } 3034 break; 3035 3036 case 122: 3037 #line 471 "ldgram.y" 3038 { 3039 (yyval.wildcard).name = (yyvsp[(5) - (7)].cname); 3040 (yyval.wildcard).sorted = by_alignment_name; 3041 (yyval.wildcard).exclude_name_list = NULL; 3042 } 3043 break; 3044 3045 case 123: 3046 #line 477 "ldgram.y" 3047 { 3048 (yyval.wildcard).name = (yyvsp[(5) - (7)].cname); 3049 (yyval.wildcard).sorted = by_alignment; 3050 (yyval.wildcard).exclude_name_list = NULL; 3051 } 3052 break; 3053 3054 case 124: 3055 #line 483 "ldgram.y" 3056 { 3057 (yyval.wildcard).name = (yyvsp[(7) - (8)].cname); 3058 (yyval.wildcard).sorted = by_name; 3059 (yyval.wildcard).exclude_name_list = (yyvsp[(5) - (8)].name_list); 3060 } 3061 break; 3062 3063 case 125: 3064 #line 492 "ldgram.y" 3065 { 3066 struct name_list *tmp; 3067 tmp = (struct name_list *) xmalloc (sizeof *tmp); 3068 tmp->name = (yyvsp[(2) - (2)].cname); 3069 tmp->next = (yyvsp[(1) - (2)].name_list); 3070 (yyval.name_list) = tmp; 3071 } 3072 break; 3073 3074 case 126: 3075 #line 501 "ldgram.y" 3076 { 3077 struct name_list *tmp; 3078 tmp = (struct name_list *) xmalloc (sizeof *tmp); 3079 tmp->name = (yyvsp[(1) - (1)].cname); 3080 tmp->next = NULL; 3081 (yyval.name_list) = tmp; 3082 } 3083 break; 3084 3085 case 127: 3086 #line 512 "ldgram.y" 3087 { 3088 struct wildcard_list *tmp; 3089 tmp = (struct wildcard_list *) xmalloc (sizeof *tmp); 3090 tmp->next = (yyvsp[(1) - (3)].wildcard_list); 3091 tmp->spec = (yyvsp[(3) - (3)].wildcard); 3092 (yyval.wildcard_list) = tmp; 3093 } 3094 break; 3095 3096 case 128: 3097 #line 521 "ldgram.y" 3098 { 3099 struct wildcard_list *tmp; 3100 tmp = (struct wildcard_list *) xmalloc (sizeof *tmp); 3101 tmp->next = NULL; 3102 tmp->spec = (yyvsp[(1) - (1)].wildcard); 3103 (yyval.wildcard_list) = tmp; 3104 } 3105 break; 3106 3107 case 129: 3108 #line 532 "ldgram.y" 3109 { 3110 struct wildcard_spec tmp; 3111 tmp.name = (yyvsp[(1) - (1)].name); 3112 tmp.exclude_name_list = NULL; 3113 tmp.sorted = none; 3114 lang_add_wild (&tmp, NULL, ldgram_had_keep); 3115 } 3116 break; 3117 3118 case 130: 3119 #line 540 "ldgram.y" 3120 { 3121 lang_add_wild (NULL, (yyvsp[(2) - (3)].wildcard_list), ldgram_had_keep); 3122 } 3123 break; 3124 3125 case 131: 3126 #line 544 "ldgram.y" 3127 { 3128 lang_add_wild (&(yyvsp[(1) - (4)].wildcard), (yyvsp[(3) - (4)].wildcard_list), ldgram_had_keep); 3129 } 3130 break; 3131 3132 case 133: 3133 #line 552 "ldgram.y" 3134 { ldgram_had_keep = TRUE; } 3135 break; 3136 3137 case 134: 3138 #line 554 "ldgram.y" 3139 { ldgram_had_keep = FALSE; } 3140 break; 3141 3142 case 136: 3143 #line 560 "ldgram.y" 3144 { 3145 lang_add_attribute(lang_object_symbols_statement_enum); 3146 } 3147 break; 3148 3149 case 138: 3150 #line 565 "ldgram.y" 3151 { 3152 3153 lang_add_attribute(lang_constructors_statement_enum); 3154 } 3155 break; 3156 3157 case 139: 3158 #line 570 "ldgram.y" 3159 { 3160 constructors_sorted = TRUE; 3161 lang_add_attribute (lang_constructors_statement_enum); 3162 } 3163 break; 3164 3165 case 141: 3166 #line 576 "ldgram.y" 3167 { 3168 lang_add_data ((int) (yyvsp[(1) - (4)].integer), (yyvsp[(3) - (4)].etree)); 3169 } 3170 break; 3171 3172 case 142: 3173 #line 581 "ldgram.y" 3174 { 3175 lang_add_fill ((yyvsp[(3) - (4)].fill)); 3176 } 3177 break; 3178 3179 case 143: 3180 #line 584 "ldgram.y" 3181 {ldlex_expression ();} 3182 break; 3183 3184 case 144: 3185 #line 585 "ldgram.y" 3186 { ldlex_popstate (); 3187 lang_add_assignment (exp_assert ((yyvsp[(4) - (8)].etree), (yyvsp[(6) - (8)].name))); } 3188 break; 3189 3190 case 145: 3191 #line 588 "ldgram.y" 3192 { ldlex_script (); ldfile_open_command_file((yyvsp[(2) - (2)].name)); } 3193 break; 3194 3195 case 146: 3196 #line 590 "ldgram.y" 3197 { ldlex_popstate (); } 3198 break; 3199 3200 case 151: 3201 #line 605 "ldgram.y" 3202 { (yyval.integer) = (yyvsp[(1) - (1)].token); } 3203 break; 3204 3205 case 152: 3206 #line 607 "ldgram.y" 3207 { (yyval.integer) = (yyvsp[(1) - (1)].token); } 3208 break; 3209 3210 case 153: 3211 #line 609 "ldgram.y" 3212 { (yyval.integer) = (yyvsp[(1) - (1)].token); } 3213 break; 3214 3215 case 154: 3216 #line 611 "ldgram.y" 3217 { (yyval.integer) = (yyvsp[(1) - (1)].token); } 3218 break; 3219 3220 case 155: 3221 #line 613 "ldgram.y" 3222 { (yyval.integer) = (yyvsp[(1) - (1)].token); } 3223 break; 3224 3225 case 156: 3226 #line 618 "ldgram.y" 3227 { 3228 (yyval.fill) = exp_get_fill ((yyvsp[(1) - (1)].etree), 0, "fill value"); 3229 } 3230 break; 3231 3232 case 157: 3233 #line 625 "ldgram.y" 3234 { (yyval.fill) = (yyvsp[(2) - (2)].fill); } 3235 break; 3236 3237 case 158: 3238 #line 626 "ldgram.y" 3239 { (yyval.fill) = (fill_type *) 0; } 3240 break; 3241 3242 case 159: 3243 #line 631 "ldgram.y" 3244 { (yyval.token) = '+'; } 3245 break; 3246 3247 case 160: 3248 #line 633 "ldgram.y" 3249 { (yyval.token) = '-'; } 3250 break; 3251 3252 case 161: 3253 #line 635 "ldgram.y" 3254 { (yyval.token) = '*'; } 3255 break; 3256 3257 case 162: 3258 #line 637 "ldgram.y" 3259 { (yyval.token) = '/'; } 3260 break; 3261 3262 case 163: 3263 #line 639 "ldgram.y" 3264 { (yyval.token) = LSHIFT; } 3265 break; 3266 3267 case 164: 3268 #line 641 "ldgram.y" 3269 { (yyval.token) = RSHIFT; } 3270 break; 3271 3272 case 165: 3273 #line 643 "ldgram.y" 3274 { (yyval.token) = '&'; } 3275 break; 3276 3277 case 166: 3278 #line 645 "ldgram.y" 3279 { (yyval.token) = '|'; } 3280 break; 3281 3282 case 169: 3283 #line 655 "ldgram.y" 3284 { 3285 lang_add_assignment (exp_assign ((yyvsp[(1) - (3)].name), (yyvsp[(3) - (3)].etree))); 3286 } 3287 break; 3288 3289 case 170: 3290 #line 659 "ldgram.y" 3291 { 3292 lang_add_assignment (exp_assign ((yyvsp[(1) - (3)].name), 3293 exp_binop ((yyvsp[(2) - (3)].token), 3294 exp_nameop (NAME, 3295 (yyvsp[(1) - (3)].name)), 3296 (yyvsp[(3) - (3)].etree)))); 3297 } 3298 break; 3299 3300 case 171: 3301 #line 667 "ldgram.y" 3302 { 3303 lang_add_assignment (exp_provide ((yyvsp[(3) - (6)].name), (yyvsp[(5) - (6)].etree), FALSE)); 3304 } 3305 break; 3306 3307 case 172: 3308 #line 671 "ldgram.y" 3309 { 3310 lang_add_assignment (exp_provide ((yyvsp[(3) - (6)].name), (yyvsp[(5) - (6)].etree), TRUE)); 3311 } 3312 break; 3313 3314 case 180: 3315 #line 694 "ldgram.y" 3316 { region = lang_memory_region_lookup ((yyvsp[(1) - (1)].name), TRUE); } 3317 break; 3318 3319 case 181: 3320 #line 697 "ldgram.y" 3321 {} 3322 break; 3323 3324 case 182: 3325 #line 699 "ldgram.y" 3326 { ldlex_script (); ldfile_open_command_file((yyvsp[(2) - (2)].name)); } 3327 break; 3328 3329 case 183: 3330 #line 701 "ldgram.y" 3331 { ldlex_popstate (); } 3332 break; 3333 3334 case 184: 3335 #line 706 "ldgram.y" 3336 { 3337 region->origin = exp_get_vma ((yyvsp[(3) - (3)].etree), 0, "origin"); 3338 region->current = region->origin; 3339 } 3340 break; 3341 3342 case 185: 3343 #line 714 "ldgram.y" 3344 { 3345 region->length = exp_get_vma ((yyvsp[(3) - (3)].etree), -1, "length"); 3346 } 3347 break; 3348 3349 case 186: 3350 #line 721 "ldgram.y" 3351 { /* dummy action to avoid bison 1.25 error message */ } 3352 break; 3353 3354 case 190: 3355 #line 732 "ldgram.y" 3356 { lang_set_flags (region, (yyvsp[(1) - (1)].name), 0); } 3357 break; 3358 3359 case 191: 3360 #line 734 "ldgram.y" 3361 { lang_set_flags (region, (yyvsp[(2) - (2)].name), 1); } 3362 break; 3363 3364 case 192: 3365 #line 739 "ldgram.y" 3366 { lang_startup((yyvsp[(3) - (4)].name)); } 3367 break; 3368 3369 case 194: 3370 #line 745 "ldgram.y" 3371 { ldemul_hll((char *)NULL); } 3372 break; 3373 3374 case 195: 3375 #line 750 "ldgram.y" 3376 { ldemul_hll((yyvsp[(3) - (3)].name)); } 3377 break; 3378 3379 case 196: 3380 #line 752 "ldgram.y" 3381 { ldemul_hll((yyvsp[(1) - (1)].name)); } 3382 break; 3383 3384 case 198: 3385 #line 760 "ldgram.y" 3386 { ldemul_syslib((yyvsp[(3) - (3)].name)); } 3387 break; 3388 3389 case 200: 3390 #line 766 "ldgram.y" 3391 { lang_float(TRUE); } 3392 break; 3393 3394 case 201: 3395 #line 768 "ldgram.y" 3396 { lang_float(FALSE); } 3397 break; 3398 3399 case 202: 3400 #line 773 "ldgram.y" 3401 { 3402 (yyval.nocrossref) = NULL; 3403 } 3404 break; 3405 3406 case 203: 3407 #line 777 "ldgram.y" 3408 { 3409 struct lang_nocrossref *n; 3410 3411 n = (struct lang_nocrossref *) xmalloc (sizeof *n); 3412 n->name = (yyvsp[(1) - (2)].name); 3413 n->next = (yyvsp[(2) - (2)].nocrossref); 3414 (yyval.nocrossref) = n; 3415 } 3416 break; 3417 3418 case 204: 3419 #line 786 "ldgram.y" 3420 { 3421 struct lang_nocrossref *n; 3422 3423 n = (struct lang_nocrossref *) xmalloc (sizeof *n); 3424 n->name = (yyvsp[(1) - (3)].name); 3425 n->next = (yyvsp[(3) - (3)].nocrossref); 3426 (yyval.nocrossref) = n; 3427 } 3428 break; 3429 3430 case 205: 3431 #line 796 "ldgram.y" 3432 { ldlex_expression (); } 3433 break; 3434 3435 case 206: 3436 #line 798 "ldgram.y" 3437 { ldlex_popstate (); (yyval.etree)=(yyvsp[(2) - (2)].etree);} 3438 break; 3439 3440 case 207: 3441 #line 803 "ldgram.y" 3442 { (yyval.etree) = exp_unop ('-', (yyvsp[(2) - (2)].etree)); } 3443 break; 3444 3445 case 208: 3446 #line 805 "ldgram.y" 3447 { (yyval.etree) = (yyvsp[(2) - (3)].etree); } 3448 break; 3449 3450 case 209: 3451 #line 807 "ldgram.y" 3452 { (yyval.etree) = exp_unop ((int) (yyvsp[(1) - (4)].integer),(yyvsp[(3) - (4)].etree)); } 3453 break; 3454 3455 case 210: 3456 #line 809 "ldgram.y" 3457 { (yyval.etree) = exp_unop ('!', (yyvsp[(2) - (2)].etree)); } 3458 break; 3459 3460 case 211: 3461 #line 811 "ldgram.y" 3462 { (yyval.etree) = (yyvsp[(2) - (2)].etree); } 3463 break; 3464 3465 case 212: 3466 #line 813 "ldgram.y" 3467 { (yyval.etree) = exp_unop ('~', (yyvsp[(2) - (2)].etree));} 3468 break; 3469 3470 case 213: 3471 #line 816 "ldgram.y" 3472 { (yyval.etree) = exp_binop ('*', (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3473 break; 3474 3475 case 214: 3476 #line 818 "ldgram.y" 3477 { (yyval.etree) = exp_binop ('/', (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3478 break; 3479 3480 case 215: 3481 #line 820 "ldgram.y" 3482 { (yyval.etree) = exp_binop ('%', (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3483 break; 3484 3485 case 216: 3486 #line 822 "ldgram.y" 3487 { (yyval.etree) = exp_binop ('+', (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3488 break; 3489 3490 case 217: 3491 #line 824 "ldgram.y" 3492 { (yyval.etree) = exp_binop ('-' , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3493 break; 3494 3495 case 218: 3496 #line 826 "ldgram.y" 3497 { (yyval.etree) = exp_binop (LSHIFT , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3498 break; 3499 3500 case 219: 3501 #line 828 "ldgram.y" 3502 { (yyval.etree) = exp_binop (RSHIFT , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3503 break; 3504 3505 case 220: 3506 #line 830 "ldgram.y" 3507 { (yyval.etree) = exp_binop (EQ , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3508 break; 3509 3510 case 221: 3511 #line 832 "ldgram.y" 3512 { (yyval.etree) = exp_binop (NE , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3513 break; 3514 3515 case 222: 3516 #line 834 "ldgram.y" 3517 { (yyval.etree) = exp_binop (LE , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3518 break; 3519 3520 case 223: 3521 #line 836 "ldgram.y" 3522 { (yyval.etree) = exp_binop (GE , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3523 break; 3524 3525 case 224: 3526 #line 838 "ldgram.y" 3527 { (yyval.etree) = exp_binop ('<' , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3528 break; 3529 3530 case 225: 3531 #line 840 "ldgram.y" 3532 { (yyval.etree) = exp_binop ('>' , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3533 break; 3534 3535 case 226: 3536 #line 842 "ldgram.y" 3537 { (yyval.etree) = exp_binop ('&' , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3538 break; 3539 3540 case 227: 3541 #line 844 "ldgram.y" 3542 { (yyval.etree) = exp_binop ('^' , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3543 break; 3544 3545 case 228: 3546 #line 846 "ldgram.y" 3547 { (yyval.etree) = exp_binop ('|' , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3548 break; 3549 3550 case 229: 3551 #line 848 "ldgram.y" 3552 { (yyval.etree) = exp_trinop ('?' , (yyvsp[(1) - (5)].etree), (yyvsp[(3) - (5)].etree), (yyvsp[(5) - (5)].etree)); } 3553 break; 3554 3555 case 230: 3556 #line 850 "ldgram.y" 3557 { (yyval.etree) = exp_binop (ANDAND , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3558 break; 3559 3560 case 231: 3561 #line 852 "ldgram.y" 3562 { (yyval.etree) = exp_binop (OROR , (yyvsp[(1) - (3)].etree), (yyvsp[(3) - (3)].etree)); } 3563 break; 3564 3565 case 232: 3566 #line 854 "ldgram.y" 3567 { (yyval.etree) = exp_nameop (DEFINED, (yyvsp[(3) - (4)].name)); } 3568 break; 3569 3570 case 233: 3571 #line 856 "ldgram.y" 3572 { (yyval.etree) = exp_bigintop ((yyvsp[(1) - (1)].bigint).integer, (yyvsp[(1) - (1)].bigint).str); } 3573 break; 3574 3575 case 234: 3576 #line 858 "ldgram.y" 3577 { (yyval.etree) = exp_nameop (SIZEOF_HEADERS,0); } 3578 break; 3579 3580 case 235: 3581 #line 861 "ldgram.y" 3582 { (yyval.etree) = exp_nameop (ALIGNOF,(yyvsp[(3) - (4)].name)); } 3583 break; 3584 3585 case 236: 3586 #line 863 "ldgram.y" 3587 { (yyval.etree) = exp_nameop (SIZEOF,(yyvsp[(3) - (4)].name)); } 3588 break; 3589 3590 case 237: 3591 #line 865 "ldgram.y" 3592 { (yyval.etree) = exp_nameop (ADDR,(yyvsp[(3) - (4)].name)); } 3593 break; 3594 3595 case 238: 3596 #line 867 "ldgram.y" 3597 { (yyval.etree) = exp_nameop (LOADADDR,(yyvsp[(3) - (4)].name)); } 3598 break; 3599 3600 case 239: 3601 #line 869 "ldgram.y" 3602 { (yyval.etree) = exp_nameop (CONSTANT,(yyvsp[(3) - (4)].name)); } 3603 break; 3604 3605 case 240: 3606 #line 871 "ldgram.y" 3607 { (yyval.etree) = exp_unop (ABSOLUTE, (yyvsp[(3) - (4)].etree)); } 3608 break; 3609 3610 case 241: 3611 #line 873 "ldgram.y" 3612 { (yyval.etree) = exp_unop (ALIGN_K,(yyvsp[(3) - (4)].etree)); } 3613 break; 3614 3615 case 242: 3616 #line 875 "ldgram.y" 3617 { (yyval.etree) = exp_binop (ALIGN_K,(yyvsp[(3) - (6)].etree),(yyvsp[(5) - (6)].etree)); } 3618 break; 3619 3620 case 243: 3621 #line 877 "ldgram.y" 3622 { (yyval.etree) = exp_binop (DATA_SEGMENT_ALIGN, (yyvsp[(3) - (6)].etree), (yyvsp[(5) - (6)].etree)); } 3623 break; 3624 3625 case 244: 3626 #line 879 "ldgram.y" 3627 { (yyval.etree) = exp_binop (DATA_SEGMENT_RELRO_END, (yyvsp[(5) - (6)].etree), (yyvsp[(3) - (6)].etree)); } 3628 break; 3629 3630 case 245: 3631 #line 881 "ldgram.y" 3632 { (yyval.etree) = exp_unop (DATA_SEGMENT_END, (yyvsp[(3) - (4)].etree)); } 3633 break; 3634 3635 case 246: 3636 #line 883 "ldgram.y" 3637 { /* The operands to the expression node are 3638 placed in the opposite order from the way 3639 in which they appear in the script as 3640 that allows us to reuse more code in 3641 fold_binary. */ 3642 (yyval.etree) = exp_binop (SEGMENT_START, 3643 (yyvsp[(5) - (6)].etree), 3644 exp_nameop (NAME, (yyvsp[(3) - (6)].name))); } 3645 break; 3646 3647 case 247: 3648 #line 892 "ldgram.y" 3649 { (yyval.etree) = exp_unop (ALIGN_K,(yyvsp[(3) - (4)].etree)); } 3650 break; 3651 3652 case 248: 3653 #line 894 "ldgram.y" 3654 { (yyval.etree) = exp_nameop (NAME,(yyvsp[(1) - (1)].name)); } 3655 break; 3656 3657 case 249: 3658 #line 896 "ldgram.y" 3659 { (yyval.etree) = exp_binop (MAX_K, (yyvsp[(3) - (6)].etree), (yyvsp[(5) - (6)].etree) ); } 3660 break; 3661 3662 case 250: 3663 #line 898 "ldgram.y" 3664 { (yyval.etree) = exp_binop (MIN_K, (yyvsp[(3) - (6)].etree), (yyvsp[(5) - (6)].etree) ); } 3665 break; 3666 3667 case 251: 3668 #line 900 "ldgram.y" 3669 { (yyval.etree) = exp_assert ((yyvsp[(3) - (6)].etree), (yyvsp[(5) - (6)].name)); } 3670 break; 3671 3672 case 252: 3673 #line 902 "ldgram.y" 3674 { (yyval.etree) = exp_nameop (ORIGIN, (yyvsp[(3) - (4)].name)); } 3675 break; 3676 3677 case 253: 3678 #line 904 "ldgram.y" 3679 { (yyval.etree) = exp_nameop (LENGTH, (yyvsp[(3) - (4)].name)); } 3680 break; 3681 3682 case 254: 3683 #line 909 "ldgram.y" 3684 { (yyval.name) = (yyvsp[(3) - (3)].name); } 3685 break; 3686 3687 case 255: 3688 #line 910 "ldgram.y" 3689 { (yyval.name) = 0; } 3690 break; 3691 3692 case 256: 3693 #line 914 "ldgram.y" 3694 { (yyval.etree) = (yyvsp[(3) - (4)].etree); } 3695 break; 3696 3697 case 257: 3698 #line 915 "ldgram.y" 3699 { (yyval.etree) = 0; } 3700 break; 3701 3702 case 258: 3703 #line 919 "ldgram.y" 3704 { (yyval.etree) = (yyvsp[(3) - (4)].etree); } 3705 break; 3706 3707 case 259: 3708 #line 920 "ldgram.y" 3709 { (yyval.etree) = 0; } 3710 break; 3711 3712 case 260: 3713 #line 924 "ldgram.y" 3714 { (yyval.etree) = (yyvsp[(3) - (4)].etree); } 3715 break; 3716 3717 case 261: 3718 #line 925 "ldgram.y" 3719 { (yyval.etree) = 0; } 3720 break; 3721 3722 case 262: 3723 #line 929 "ldgram.y" 3724 { (yyval.token) = ONLY_IF_RO; } 3725 break; 3726 3727 case 263: 3728 #line 930 "ldgram.y" 3729 { (yyval.token) = ONLY_IF_RW; } 3730 break; 3731 3732 case 264: 3733 #line 931 "ldgram.y" 3734 { (yyval.token) = SPECIAL; } 3735 break; 3736 3737 case 265: 3738 #line 932 "ldgram.y" 3739 { (yyval.token) = 0; } 3740 break; 3741 3742 case 266: 3743 #line 935 "ldgram.y" 3744 { ldlex_expression(); } 3745 break; 3746 3747 case 267: 3748 #line 939 "ldgram.y" 3749 { ldlex_popstate (); ldlex_script (); } 3750 break; 3751 3752 case 268: 3753 #line 942 "ldgram.y" 3754 { 3755 lang_enter_output_section_statement((yyvsp[(1) - (9)].name), (yyvsp[(3) - (9)].etree), 3756 sectype, 3757 (yyvsp[(5) - (9)].etree), (yyvsp[(6) - (9)].etree), (yyvsp[(4) - (9)].etree), (yyvsp[(8) - (9)].token)); 3758 } 3759 break; 3760 3761 case 269: 3762 #line 948 "ldgram.y" 3763 { ldlex_popstate (); ldlex_expression (); } 3764 break; 3765 3766 case 270: 3767 #line 950 "ldgram.y" 3768 { 3769 ldlex_popstate (); 3770 lang_leave_output_section_statement ((yyvsp[(17) - (17)].fill), (yyvsp[(14) - (17)].name), (yyvsp[(16) - (17)].section_phdr), (yyvsp[(15) - (17)].name)); 3771 } 3772 break; 3773 3774 case 271: 3775 #line 955 "ldgram.y" 3776 {} 3777 break; 3778 3779 case 272: 3780 #line 957 "ldgram.y" 3781 { ldlex_expression (); } 3782 break; 3783 3784 case 273: 3785 #line 959 "ldgram.y" 3786 { ldlex_popstate (); ldlex_script (); } 3787 break; 3788 3789 case 274: 3790 #line 961 "ldgram.y" 3791 { 3792 lang_enter_overlay ((yyvsp[(3) - (8)].etree), (yyvsp[(6) - (8)].etree)); 3793 } 3794 break; 3795 3796 case 275: 3797 #line 966 "ldgram.y" 3798 { ldlex_popstate (); ldlex_expression (); } 3799 break; 3800 3801 case 276: 3802 #line 968 "ldgram.y" 3803 { 3804 ldlex_popstate (); 3805 lang_leave_overlay ((yyvsp[(5) - (16)].etree), (int) (yyvsp[(4) - (16)].integer), 3806 (yyvsp[(16) - (16)].fill), (yyvsp[(13) - (16)].name), (yyvsp[(15) - (16)].section_phdr), (yyvsp[(14) - (16)].name)); 3807 } 3808 break; 3809 3810 case 278: 3811 #line 978 "ldgram.y" 3812 { ldlex_expression (); } 3813 break; 3814 3815 case 279: 3816 #line 980 "ldgram.y" 3817 { 3818 ldlex_popstate (); 3819 lang_add_assignment (exp_assign (".", (yyvsp[(3) - (3)].etree))); 3820 } 3821 break; 3822 3823 case 281: 3824 #line 986 "ldgram.y" 3825 { ldlex_script (); ldfile_open_command_file((yyvsp[(2) - (2)].name)); } 3826 break; 3827 3828 case 282: 3829 #line 988 "ldgram.y" 3830 { ldlex_popstate (); } 3831 break; 3832 3833 case 283: 3834 #line 992 "ldgram.y" 3835 { sectype = noload_section; } 3836 break; 3837 3838 case 284: 3839 #line 993 "ldgram.y" 3840 { sectype = noalloc_section; } 3841 break; 3842 3843 case 285: 3844 #line 994 "ldgram.y" 3845 { sectype = noalloc_section; } 3846 break; 3847 3848 case 286: 3849 #line 995 "ldgram.y" 3850 { sectype = noalloc_section; } 3851 break; 3852 3853 case 287: 3854 #line 996 "ldgram.y" 3855 { sectype = noalloc_section; } 3856 break; 3857 3858 case 289: 3859 #line 1001 "ldgram.y" 3860 { sectype = normal_section; } 3861 break; 3862 3863 case 290: 3864 #line 1002 "ldgram.y" 3865 { sectype = normal_section; } 3866 break; 3867 3868 case 291: 3869 #line 1006 "ldgram.y" 3870 { (yyval.etree) = (yyvsp[(1) - (3)].etree); } 3871 break; 3872 3873 case 292: 3874 #line 1007 "ldgram.y" 3875 { (yyval.etree) = (etree_type *)NULL; } 3876 break; 3877 3878 case 293: 3879 #line 1012 "ldgram.y" 3880 { (yyval.etree) = (yyvsp[(3) - (6)].etree); } 3881 break; 3882 3883 case 294: 3884 #line 1014 "ldgram.y" 3885 { (yyval.etree) = (yyvsp[(3) - (10)].etree); } 3886 break; 3887 3888 case 295: 3889 #line 1018 "ldgram.y" 3890 { (yyval.etree) = (yyvsp[(1) - (2)].etree); } 3891 break; 3892 3893 case 296: 3894 #line 1019 "ldgram.y" 3895 { (yyval.etree) = (etree_type *) NULL; } 3896 break; 3897 3898 case 297: 3899 #line 1024 "ldgram.y" 3900 { (yyval.integer) = 0; } 3901 break; 3902 3903 case 298: 3904 #line 1026 "ldgram.y" 3905 { (yyval.integer) = 1; } 3906 break; 3907 3908 case 299: 3909 #line 1031 "ldgram.y" 3910 { (yyval.name) = (yyvsp[(2) - (2)].name); } 3911 break; 3912 3913 case 300: 3914 #line 1032 "ldgram.y" 3915 { (yyval.name) = DEFAULT_MEMORY_REGION; } 3916 break; 3917 3918 case 301: 3919 #line 1037 "ldgram.y" 3920 { 3921 (yyval.section_phdr) = NULL; 3922 } 3923 break; 3924 3925 case 302: 3926 #line 1041 "ldgram.y" 3927 { 3928 struct lang_output_section_phdr_list *n; 3929 3930 n = ((struct lang_output_section_phdr_list *) 3931 xmalloc (sizeof *n)); 3932 n->name = (yyvsp[(3) - (3)].name); 3933 n->used = FALSE; 3934 n->next = (yyvsp[(1) - (3)].section_phdr); 3935 (yyval.section_phdr) = n; 3936 } 3937 break; 3938 3939 case 304: 3940 #line 1057 "ldgram.y" 3941 { 3942 ldlex_script (); 3943 lang_enter_overlay_section ((yyvsp[(2) - (2)].name)); 3944 } 3945 break; 3946 3947 case 305: 3948 #line 1062 "ldgram.y" 3949 { ldlex_popstate (); ldlex_expression (); } 3950 break; 3951 3952 case 306: 3953 #line 1064 "ldgram.y" 3954 { 3955 ldlex_popstate (); 3956 lang_leave_overlay_section ((yyvsp[(9) - (9)].fill), (yyvsp[(8) - (9)].section_phdr)); 3957 } 3958 break; 3959 3960 case 311: 3961 #line 1081 "ldgram.y" 3962 { ldlex_expression (); } 3963 break; 3964 3965 case 312: 3966 #line 1082 "ldgram.y" 3967 { ldlex_popstate (); } 3968 break; 3969 3970 case 313: 3971 #line 1084 "ldgram.y" 3972 { 3973 lang_new_phdr ((yyvsp[(1) - (6)].name), (yyvsp[(3) - (6)].etree), (yyvsp[(4) - (6)].phdr).filehdr, (yyvsp[(4) - (6)].phdr).phdrs, (yyvsp[(4) - (6)].phdr).at, 3974 (yyvsp[(4) - (6)].phdr).flags); 3975 } 3976 break; 3977 3978 case 314: 3979 #line 1092 "ldgram.y" 3980 { 3981 (yyval.etree) = (yyvsp[(1) - (1)].etree); 3982 3983 if ((yyvsp[(1) - (1)].etree)->type.node_class == etree_name 3984 && (yyvsp[(1) - (1)].etree)->type.node_code == NAME) 3985 { 3986 const char *s; 3987 unsigned int i; 3988 static const char * const phdr_types[] = 3989 { 3990 "PT_NULL", "PT_LOAD", "PT_DYNAMIC", 3991 "PT_INTERP", "PT_NOTE", "PT_SHLIB", 3992 "PT_PHDR", "PT_TLS" 3993 }; 3994 3995 s = (yyvsp[(1) - (1)].etree)->name.name; 3996 for (i = 0; 3997 i < sizeof phdr_types / sizeof phdr_types[0]; 3998 i++) 3999 if (strcmp (s, phdr_types[i]) == 0) 4000 { 4001 (yyval.etree) = exp_intop (i); 4002 break; 4003 } 4004 if (i == sizeof phdr_types / sizeof phdr_types[0]) 4005 { 4006 if (strcmp (s, "PT_GNU_EH_FRAME") == 0) 4007 (yyval.etree) = exp_intop (0x6474e550); 4008 else if (strcmp (s, "PT_GNU_STACK") == 0) 4009 (yyval.etree) = exp_intop (0x6474e551); 4010 else 4011 { 4012 einfo (_("\ 4013 %X%P:%S: unknown phdr type `%s' (try integer literal)\n"), 4014 s); 4015 (yyval.etree) = exp_intop (0); 4016 } 4017 } 4018 } 4019 } 4020 break; 4021 4022 case 315: 4023 #line 1136 "ldgram.y" 4024 { 4025 memset (&(yyval.phdr), 0, sizeof (struct phdr_info)); 4026 } 4027 break; 4028 4029 case 316: 4030 #line 1140 "ldgram.y" 4031 { 4032 (yyval.phdr) = (yyvsp[(3) - (3)].phdr); 4033 if (strcmp ((yyvsp[(1) - (3)].name), "FILEHDR") == 0 && (yyvsp[(2) - (3)].etree) == NULL) 4034 (yyval.phdr).filehdr = TRUE; 4035 else if (strcmp ((yyvsp[(1) - (3)].name), "PHDRS") == 0 && (yyvsp[(2) - (3)].etree) == NULL) 4036 (yyval.phdr).phdrs = TRUE; 4037 else if (strcmp ((yyvsp[(1) - (3)].name), "FLAGS") == 0 && (yyvsp[(2) - (3)].etree) != NULL) 4038 (yyval.phdr).flags = (yyvsp[(2) - (3)].etree); 4039 else 4040 einfo (_("%X%P:%S: PHDRS syntax error at `%s'\n"), (yyvsp[(1) - (3)].name)); 4041 } 4042 break; 4043 4044 case 317: 4045 #line 1152 "ldgram.y" 4046 { 4047 (yyval.phdr) = (yyvsp[(5) - (5)].phdr); 4048 (yyval.phdr).at = (yyvsp[(3) - (5)].etree); 4049 } 4050 break; 4051 4052 case 318: 4053 #line 1160 "ldgram.y" 4054 { 4055 (yyval.etree) = NULL; 4056 } 4057 break; 4058 4059 case 319: 4060 #line 1164 "ldgram.y" 4061 { 4062 (yyval.etree) = (yyvsp[(2) - (3)].etree); 4063 } 4064 break; 4065 4066 case 320: 4067 #line 1170 "ldgram.y" 4068 { 4069 ldlex_version_file (); 4070 PUSH_ERROR (_("dynamic list")); 4071 } 4072 break; 4073 4074 case 321: 4075 #line 1175 "ldgram.y" 4076 { 4077 ldlex_popstate (); 4078 POP_ERROR (); 4079 } 4080 break; 4081 4082 case 325: 4083 #line 1192 "ldgram.y" 4084 { 4085 lang_append_dynamic_list ((yyvsp[(1) - (2)].versyms)); 4086 } 4087 break; 4088 4089 case 326: 4090 #line 1200 "ldgram.y" 4091 { 4092 ldlex_version_file (); 4093 PUSH_ERROR (_("VERSION script")); 4094 } 4095 break; 4096 4097 case 327: 4098 #line 1205 "ldgram.y" 4099 { 4100 ldlex_popstate (); 4101 POP_ERROR (); 4102 } 4103 break; 4104 4105 case 328: 4106 #line 1214 "ldgram.y" 4107 { 4108 ldlex_version_script (); 4109 } 4110 break; 4111 4112 case 329: 4113 #line 1218 "ldgram.y" 4114 { 4115 ldlex_popstate (); 4116 } 4117 break; 4118 4119 case 332: 4120 #line 1230 "ldgram.y" 4121 { 4122 lang_register_vers_node (NULL, (yyvsp[(2) - (4)].versnode), NULL); 4123 } 4124 break; 4125 4126 case 333: 4127 #line 1234 "ldgram.y" 4128 { 4129 lang_register_vers_node ((yyvsp[(1) - (5)].name), (yyvsp[(3) - (5)].versnode), NULL); 4130 } 4131 break; 4132 4133 case 334: 4134 #line 1238 "ldgram.y" 4135 { 4136 lang_register_vers_node ((yyvsp[(1) - (6)].name), (yyvsp[(3) - (6)].versnode), (yyvsp[(5) - (6)].deflist)); 4137 } 4138 break; 4139 4140 case 335: 4141 #line 1245 "ldgram.y" 4142 { 4143 (yyval.deflist) = lang_add_vers_depend (NULL, (yyvsp[(1) - (1)].name)); 4144 } 4145 break; 4146 4147 case 336: 4148 #line 1249 "ldgram.y" 4149 { 4150 (yyval.deflist) = lang_add_vers_depend ((yyvsp[(1) - (2)].deflist), (yyvsp[(2) - (2)].name)); 4151 } 4152 break; 4153 4154 case 337: 4155 #line 1256 "ldgram.y" 4156 { 4157 (yyval.versnode) = lang_new_vers_node (NULL, NULL); 4158 } 4159 break; 4160 4161 case 338: 4162 #line 1260 "ldgram.y" 4163 { 4164 (yyval.versnode) = lang_new_vers_node ((yyvsp[(1) - (2)].versyms), NULL); 4165 } 4166 break; 4167 4168 case 339: 4169 #line 1264 "ldgram.y" 4170 { 4171 (yyval.versnode) = lang_new_vers_node ((yyvsp[(3) - (4)].versyms), NULL); 4172 } 4173 break; 4174 4175 case 340: 4176 #line 1268 "ldgram.y" 4177 { 4178 (yyval.versnode) = lang_new_vers_node (NULL, (yyvsp[(3) - (4)].versyms)); 4179 } 4180 break; 4181 4182 case 341: 4183 #line 1272 "ldgram.y" 4184 { 4185 (yyval.versnode) = lang_new_vers_node ((yyvsp[(3) - (8)].versyms), (yyvsp[(7) - (8)].versyms)); 4186 } 4187 break; 4188 4189 case 342: 4190 #line 1279 "ldgram.y" 4191 { 4192 (yyval.versyms) = lang_new_vers_pattern (NULL, (yyvsp[(1) - (1)].name), ldgram_vers_current_lang, FALSE); 4193 } 4194 break; 4195 4196 case 343: 4197 #line 1283 "ldgram.y" 4198 { 4199 (yyval.versyms) = lang_new_vers_pattern (NULL, (yyvsp[(1) - (1)].name), ldgram_vers_current_lang, TRUE); 4200 } 4201 break; 4202 4203 case 344: 4204 #line 1287 "ldgram.y" 4205 { 4206 (yyval.versyms) = lang_new_vers_pattern ((yyvsp[(1) - (3)].versyms), (yyvsp[(3) - (3)].name), ldgram_vers_current_lang, FALSE); 4207 } 4208 break; 4209 4210 case 345: 4211 #line 1291 "ldgram.y" 4212 { 4213 (yyval.versyms) = lang_new_vers_pattern ((yyvsp[(1) - (3)].versyms), (yyvsp[(3) - (3)].name), ldgram_vers_current_lang, TRUE); 4214 } 4215 break; 4216 4217 case 346: 4218 #line 1295 "ldgram.y" 4219 { 4220 (yyval.name) = ldgram_vers_current_lang; 4221 ldgram_vers_current_lang = (yyvsp[(4) - (5)].name); 4222 } 4223 break; 4224 4225 case 347: 4226 #line 1300 "ldgram.y" 4227 { 4228 struct bfd_elf_version_expr *pat; 4229 for (pat = (yyvsp[(7) - (9)].versyms); pat->next != NULL; pat = pat->next); 4230 pat->next = (yyvsp[(1) - (9)].versyms); 4231 (yyval.versyms) = (yyvsp[(7) - (9)].versyms); 4232 ldgram_vers_current_lang = (yyvsp[(6) - (9)].name); 4233 } 4234 break; 4235 4236 case 348: 4237 #line 1308 "ldgram.y" 4238 { 4239 (yyval.name) = ldgram_vers_current_lang; 4240 ldgram_vers_current_lang = (yyvsp[(2) - (3)].name); 4241 } 4242 break; 4243 4244 case 349: 4245 #line 1313 "ldgram.y" 4246 { 4247 (yyval.versyms) = (yyvsp[(5) - (7)].versyms); 4248 ldgram_vers_current_lang = (yyvsp[(4) - (7)].name); 4249 } 4250 break; 4251 4252 case 350: 4253 #line 1318 "ldgram.y" 4254 { 4255 (yyval.versyms) = lang_new_vers_pattern (NULL, "global", ldgram_vers_current_lang, FALSE); 4256 } 4257 break; 4258 4259 case 351: 4260 #line 1322 "ldgram.y" 4261 { 4262 (yyval.versyms) = lang_new_vers_pattern ((yyvsp[(1) - (3)].versyms), "global", ldgram_vers_current_lang, FALSE); 4263 } 4264 break; 4265 4266 case 352: 4267 #line 1326 "ldgram.y" 4268 { 4269 (yyval.versyms) = lang_new_vers_pattern (NULL, "local", ldgram_vers_current_lang, FALSE); 4270 } 4271 break; 4272 4273 case 353: 4274 #line 1330 "ldgram.y" 4275 { 4276 (yyval.versyms) = lang_new_vers_pattern ((yyvsp[(1) - (3)].versyms), "local", ldgram_vers_current_lang, FALSE); 4277 } 4278 break; 4279 4280 case 354: 4281 #line 1334 "ldgram.y" 4282 { 4283 (yyval.versyms) = lang_new_vers_pattern (NULL, "extern", ldgram_vers_current_lang, FALSE); 4284 } 4285 break; 4286 4287 case 355: 4288 #line 1338 "ldgram.y" 4289 { 4290 (yyval.versyms) = lang_new_vers_pattern ((yyvsp[(1) - (3)].versyms), "extern", ldgram_vers_current_lang, FALSE); 4291 } 4292 break; 4293 4294 4295 /* Line 1267 of yacc.c. */ 4296 #line 4294 "ldgram.c" 4297 default: break; 4298 } 4299 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 4300 4301 YYPOPSTACK (yylen); 4302 yylen = 0; 4303 YY_STACK_PRINT (yyss, yyssp); 4304 4305 *++yyvsp = yyval; 4306 4307 4308 /* Now `shift' the result of the reduction. Determine what state 4309 that goes to, based on the state we popped back to and the rule 4310 number reduced by. */ 4311 4312 yyn = yyr1[yyn]; 4313 4314 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 4315 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 4316 yystate = yytable[yystate]; 4317 else 4318 yystate = yydefgoto[yyn - YYNTOKENS]; 4319 4320 goto yynewstate; 4321 4322 4323 /*------------------------------------. 4324 | yyerrlab -- here on detecting error | 4325 `------------------------------------*/ 4326 yyerrlab: 4327 /* If not already recovering from an error, report this error. */ 4328 if (!yyerrstatus) 4329 { 4330 ++yynerrs; 4331 #if ! YYERROR_VERBOSE 4332 yyerror (YY_("syntax error")); 4333 #else 4334 { 4335 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 4336 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 4337 { 4338 YYSIZE_T yyalloc = 2 * yysize; 4339 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 4340 yyalloc = YYSTACK_ALLOC_MAXIMUM; 4341 if (yymsg != yymsgbuf) 4342 YYSTACK_FREE (yymsg); 4343 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 4344 if (yymsg) 4345 yymsg_alloc = yyalloc; 4346 else 4347 { 4348 yymsg = yymsgbuf; 4349 yymsg_alloc = sizeof yymsgbuf; 4350 } 4351 } 4352 4353 if (0 < yysize && yysize <= yymsg_alloc) 4354 { 4355 (void) yysyntax_error (yymsg, yystate, yychar); 4356 yyerror (yymsg); 4357 } 4358 else 4359 { 4360 yyerror (YY_("syntax error")); 4361 if (yysize != 0) 4362 goto yyexhaustedlab; 4363 } 4364 } 4365 #endif 4366 } 4367 4368 4369 4370 if (yyerrstatus == 3) 4371 { 4372 /* If just tried and failed to reuse look-ahead token after an 4373 error, discard it. */ 4374 4375 if (yychar <= YYEOF) 4376 { 4377 /* Return failure if at end of input. */ 4378 if (yychar == YYEOF) 4379 YYABORT; 4380 } 4381 else 4382 { 4383 yydestruct ("Error: discarding", 4384 yytoken, &yylval); 4385 yychar = YYEMPTY; 4386 } 4387 } 4388 4389 /* Else will try to reuse look-ahead token after shifting the error 4390 token. */ 4391 goto yyerrlab1; 4392 4393 4394 /*---------------------------------------------------. 4395 | yyerrorlab -- error raised explicitly by YYERROR. | 4396 `---------------------------------------------------*/ 4397 yyerrorlab: 4398 4399 /* Pacify compilers like GCC when the user code never invokes 4400 YYERROR and the label yyerrorlab therefore never appears in user 4401 code. */ 4402 if (/*CONSTCOND*/ 0) 4403 goto yyerrorlab; 4404 4405 /* Do not reclaim the symbols of the rule which action triggered 4406 this YYERROR. */ 4407 YYPOPSTACK (yylen); 4408 yylen = 0; 4409 YY_STACK_PRINT (yyss, yyssp); 4410 yystate = *yyssp; 4411 goto yyerrlab1; 4412 4413 4414 /*-------------------------------------------------------------. 4415 | yyerrlab1 -- common code for both syntax error and YYERROR. | 4416 `-------------------------------------------------------------*/ 4417 yyerrlab1: 4418 yyerrstatus = 3; /* Each real token shifted decrements this. */ 4419 4420 for (;;) 4421 { 4422 yyn = yypact[yystate]; 4423 if (yyn != YYPACT_NINF) 4424 { 4425 yyn += YYTERROR; 4426 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 4427 { 4428 yyn = yytable[yyn]; 4429 if (0 < yyn) 4430 break; 4431 } 4432 } 4433 4434 /* Pop the current state because it cannot handle the error token. */ 4435 if (yyssp == yyss) 4436 YYABORT; 4437 4438 4439 yydestruct ("Error: popping", 4440 yystos[yystate], yyvsp); 4441 YYPOPSTACK (1); 4442 yystate = *yyssp; 4443 YY_STACK_PRINT (yyss, yyssp); 4444 } 4445 4446 if (yyn == YYFINAL) 4447 YYACCEPT; 4448 4449 *++yyvsp = yylval; 4450 4451 4452 /* Shift the error token. */ 4453 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 4454 4455 yystate = yyn; 4456 goto yynewstate; 4457 4458 4459 /*-------------------------------------. 4460 | yyacceptlab -- YYACCEPT comes here. | 4461 `-------------------------------------*/ 4462 yyacceptlab: 4463 yyresult = 0; 4464 goto yyreturn; 4465 4466 /*-----------------------------------. 4467 | yyabortlab -- YYABORT comes here. | 4468 `-----------------------------------*/ 4469 yyabortlab: 4470 yyresult = 1; 4471 goto yyreturn; 4472 4473 #ifndef yyoverflow 4474 /*-------------------------------------------------. 4475 | yyexhaustedlab -- memory exhaustion comes here. | 4476 `-------------------------------------------------*/ 4477 yyexhaustedlab: 4478 yyerror (YY_("memory exhausted")); 4479 yyresult = 2; 4480 /* Fall through. */ 4481 #endif 4482 4483 yyreturn: 4484 if (yychar != YYEOF && yychar != YYEMPTY) 4485 yydestruct ("Cleanup: discarding lookahead", 4486 yytoken, &yylval); 4487 /* Do not reclaim the symbols of the rule which action triggered 4488 this YYABORT or YYACCEPT. */ 4489 YYPOPSTACK (yylen); 4490 YY_STACK_PRINT (yyss, yyssp); 4491 while (yyssp != yyss) 4492 { 4493 yydestruct ("Cleanup: popping", 4494 yystos[*yyssp], yyvsp); 4495 YYPOPSTACK (1); 4496 } 4497 #ifndef yyoverflow 4498 if (yyss != yyssa) 4499 YYSTACK_FREE (yyss); 4500 #endif 4501 #if YYERROR_VERBOSE 4502 if (yymsg != yymsgbuf) 4503 YYSTACK_FREE (yymsg); 4504 #endif 4505 /* Make sure YYID is used. */ 4506 return YYID (yyresult); 4507 } 4508 4509 4510 #line 1348 "ldgram.y" 4511 4512 void 4513 yyerror(arg) 4514 const char *arg; 4515 { 4516 if (ldfile_assumed_script) 4517 einfo (_("%P:%s: file format not recognized; treating as linker script\n"), 4518 ldfile_input_filename); 4519 if (error_index > 0 && error_index < ERROR_NAME_MAX) 4520 einfo ("%P%F:%S: %s in %s\n", arg, error_names[error_index-1]); 4521 else 4522 einfo ("%P%F:%S: %s\n", arg); 4523 } 4524 4525
Indexes created Sat Mar 21 00:23:06 UTC 2026