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