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