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