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