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