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