?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Replace binutils 2.24 with latest binutils 2.27.
[dragonfly.git] / gnu / usr.bin / binutils224 / libgold / yyscript.c
blob88470f981dabc950520e1d06edef6617f826508f
1 /* A Bison parser, made by GNU Bison 2.7.12-4996. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43 /* Identify Bison output. */
44 #define YYBISON 1
45
46 /* Bison version. */
47 #define YYBISON_VERSION "2.7.12-4996"
48
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers. */
53 #define YYPURE 1
54
55 /* Push parsers. */
56 #define YYPUSH 0
57
58 /* Pull parsers. */
59 #define YYPULL 1
60
61
62
63
64 /* Copy the first part of user declarations. */
65 /* Line 371 of yacc.c */
66 #line 26 "yyscript.y"
67
68
69 #include "config.h"
70
71 #include <stddef.h>
72 #include <stdint.h>
73 #include <stdlib.h>
74 #include <string.h>
75
76 #include "script-c.h"
77
78
79 /* Line 371 of yacc.c */
80 #line 81 "yyscript.c"
81
82 # ifndef YY_NULL
83 # if defined __cplusplus && 201103L <= __cplusplus
84 # define YY_NULL nullptr
85 # else
86 # define YY_NULL 0
87 # endif
88 # endif
89
90 /* Enabling verbose error messages. */
91 #ifdef YYERROR_VERBOSE
92 # undef YYERROR_VERBOSE
93 # define YYERROR_VERBOSE 1
94 #else
95 # define YYERROR_VERBOSE 1
96 #endif
97
98 /* In a future release of Bison, this section will be replaced
99 by #include "y.tab.h". */
100 #ifndef YY_YY_Y_TAB_H_INCLUDED
101 # define YY_YY_Y_TAB_H_INCLUDED
102 /* Enabling traces. */
103 #ifndef YYDEBUG
104 # define YYDEBUG 0
105 #endif
106 #if YYDEBUG
107 extern int yydebug;
108 #endif
109
110 /* Tokens. */
111 #ifndef YYTOKENTYPE
112 # define YYTOKENTYPE
113 /* Put the tokens into the symbol table, so that GDB and other debuggers
114 know about them. */
115 enum yytokentype {
116 OREQ = 258,
117 ANDEQ = 259,
118 RSHIFTEQ = 260,
119 LSHIFTEQ = 261,
120 DIVEQ = 262,
121 MULTEQ = 263,
122 MINUSEQ = 264,
123 PLUSEQ = 265,
124 OROR = 266,
125 ANDAND = 267,
126 NE = 268,
127 EQ = 269,
128 GE = 270,
129 LE = 271,
130 RSHIFT = 272,
131 LSHIFT = 273,
132 UNARY = 274,
133 STRING = 275,
134 QUOTED_STRING = 276,
135 INTEGER = 277,
136 ABSOLUTE = 278,
137 ADDR = 279,
138 ALIGN_K = 280,
139 ALIGNOF = 281,
140 ASSERT_K = 282,
141 AS_NEEDED = 283,
142 AT = 284,
143 BIND = 285,
144 BLOCK = 286,
145 BYTE = 287,
146 CONSTANT = 288,
147 CONSTRUCTORS = 289,
148 COPY = 290,
149 CREATE_OBJECT_SYMBOLS = 291,
150 DATA_SEGMENT_ALIGN = 292,
151 DATA_SEGMENT_END = 293,
152 DATA_SEGMENT_RELRO_END = 294,
153 DEFINED = 295,
154 DSECT = 296,
155 ENTRY = 297,
156 EXCLUDE_FILE = 298,
157 EXTERN = 299,
158 FILL = 300,
159 FLOAT = 301,
160 FORCE_COMMON_ALLOCATION = 302,
161 GLOBAL = 303,
162 GROUP = 304,
163 HLL = 305,
164 INCLUDE = 306,
165 INHIBIT_COMMON_ALLOCATION = 307,
166 INFO = 308,
167 INPUT = 309,
168 KEEP = 310,
169 LEN = 311,
170 LENGTH = 312,
171 LOADADDR = 313,
172 LOCAL = 314,
173 LONG = 315,
174 MAP = 316,
175 MAX_K = 317,
176 MEMORY = 318,
177 MIN_K = 319,
178 NEXT = 320,
179 NOCROSSREFS = 321,
180 NOFLOAT = 322,
181 NOLOAD = 323,
182 ONLY_IF_RO = 324,
183 ONLY_IF_RW = 325,
184 ORG = 326,
185 ORIGIN = 327,
186 OUTPUT = 328,
187 OUTPUT_ARCH = 329,
188 OUTPUT_FORMAT = 330,
189 OVERLAY = 331,
190 PHDRS = 332,
191 PROVIDE = 333,
192 PROVIDE_HIDDEN = 334,
193 QUAD = 335,
194 SEARCH_DIR = 336,
195 SECTIONS = 337,
196 SEGMENT_START = 338,
197 SHORT = 339,
198 SIZEOF = 340,
199 SIZEOF_HEADERS = 341,
200 SORT_BY_ALIGNMENT = 342,
201 SORT_BY_NAME = 343,
202 SPECIAL = 344,
203 SQUAD = 345,
204 STARTUP = 346,
205 SUBALIGN = 347,
206 SYSLIB = 348,
207 TARGET_K = 349,
208 TRUNCATE = 350,
209 VERSIONK = 351,
210 OPTION = 352,
211 PARSING_LINKER_SCRIPT = 353,
212 PARSING_VERSION_SCRIPT = 354,
213 PARSING_DEFSYM = 355,
214 PARSING_DYNAMIC_LIST = 356
215 };
216 #endif
217 /* Tokens. */
218 #define OREQ 258
219 #define ANDEQ 259
220 #define RSHIFTEQ 260
221 #define LSHIFTEQ 261
222 #define DIVEQ 262
223 #define MULTEQ 263
224 #define MINUSEQ 264
225 #define PLUSEQ 265
226 #define OROR 266
227 #define ANDAND 267
228 #define NE 268
229 #define EQ 269
230 #define GE 270
231 #define LE 271
232 #define RSHIFT 272
233 #define LSHIFT 273
234 #define UNARY 274
235 #define STRING 275
236 #define QUOTED_STRING 276
237 #define INTEGER 277
238 #define ABSOLUTE 278
239 #define ADDR 279
240 #define ALIGN_K 280
241 #define ALIGNOF 281
242 #define ASSERT_K 282
243 #define AS_NEEDED 283
244 #define AT 284
245 #define BIND 285
246 #define BLOCK 286
247 #define BYTE 287
248 #define CONSTANT 288
249 #define CONSTRUCTORS 289
250 #define COPY 290
251 #define CREATE_OBJECT_SYMBOLS 291
252 #define DATA_SEGMENT_ALIGN 292
253 #define DATA_SEGMENT_END 293
254 #define DATA_SEGMENT_RELRO_END 294
255 #define DEFINED 295
256 #define DSECT 296
257 #define ENTRY 297
258 #define EXCLUDE_FILE 298
259 #define EXTERN 299
260 #define FILL 300
261 #define FLOAT 301
262 #define FORCE_COMMON_ALLOCATION 302
263 #define GLOBAL 303
264 #define GROUP 304
265 #define HLL 305
266 #define INCLUDE 306
267 #define INHIBIT_COMMON_ALLOCATION 307
268 #define INFO 308
269 #define INPUT 309
270 #define KEEP 310
271 #define LEN 311
272 #define LENGTH 312
273 #define LOADADDR 313
274 #define LOCAL 314
275 #define LONG 315
276 #define MAP 316
277 #define MAX_K 317
278 #define MEMORY 318
279 #define MIN_K 319
280 #define NEXT 320
281 #define NOCROSSREFS 321
282 #define NOFLOAT 322
283 #define NOLOAD 323
284 #define ONLY_IF_RO 324
285 #define ONLY_IF_RW 325
286 #define ORG 326
287 #define ORIGIN 327
288 #define OUTPUT 328
289 #define OUTPUT_ARCH 329
290 #define OUTPUT_FORMAT 330
291 #define OVERLAY 331
292 #define PHDRS 332
293 #define PROVIDE 333
294 #define PROVIDE_HIDDEN 334
295 #define QUAD 335
296 #define SEARCH_DIR 336
297 #define SECTIONS 337
298 #define SEGMENT_START 338
299 #define SHORT 339
300 #define SIZEOF 340
301 #define SIZEOF_HEADERS 341
302 #define SORT_BY_ALIGNMENT 342
303 #define SORT_BY_NAME 343
304 #define SPECIAL 344
305 #define SQUAD 345
306 #define STARTUP 346
307 #define SUBALIGN 347
308 #define SYSLIB 348
309 #define TARGET_K 349
310 #define TRUNCATE 350
311 #define VERSIONK 351
312 #define OPTION 352
313 #define PARSING_LINKER_SCRIPT 353
314 #define PARSING_VERSION_SCRIPT 354
315 #define PARSING_DEFSYM 355
316 #define PARSING_DYNAMIC_LIST 356
317
318
319
320 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
321 typedef union YYSTYPE
322 {
323 /* Line 387 of yacc.c */
324 #line 53 "yyscript.y"
325
326 /* A string. */
327 struct Parser_string string;
328 /* A number. */
329 uint64_t integer;
330 /* An expression. */
331 Expression_ptr expr;
332 /* An output section header. */
333 struct Parser_output_section_header output_section_header;
334 /* An output section trailer. */
335 struct Parser_output_section_trailer output_section_trailer;
336 /* A section constraint. */
337 enum Section_constraint constraint;
338 /* A complete input section specification. */
339 struct Input_section_spec input_section_spec;
340 /* A list of wildcard specifications, with exclusions. */
341 struct Wildcard_sections wildcard_sections;
342 /* A single wildcard specification. */
343 struct Wildcard_section wildcard_section;
344 /* A list of strings. */
345 String_list_ptr string_list;
346 /* Information for a program header. */
347 struct Phdr_info phdr_info;
348 /* Used for version scripts and within VERSION {}. */
349 struct Version_dependency_list* deplist;
350 struct Version_expression_list* versyms;
351 struct Version_tree* versnode;
352 enum Script_section_type section_type;
353
354
355 /* Line 387 of yacc.c */
356 #line 357 "yyscript.c"
357 } YYSTYPE;
358 # define YYSTYPE_IS_TRIVIAL 1
359 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
360 # define YYSTYPE_IS_DECLARED 1
361 #endif
362
363
364 #ifdef YYPARSE_PARAM
365 #if defined __STDC__ || defined __cplusplus
366 int yyparse (void *YYPARSE_PARAM);
367 #else
368 int yyparse ();
369 #endif
370 #else /* ! YYPARSE_PARAM */
371 #if defined __STDC__ || defined __cplusplus
372 int yyparse (void* closure);
373 #else
374 int yyparse ();
375 #endif
376 #endif /* ! YYPARSE_PARAM */
377
378 #endif /* !YY_YY_Y_TAB_H_INCLUDED */
379
380 /* Copy the second part of user declarations. */
381
382 /* Line 390 of yacc.c */
383 #line 384 "yyscript.c"
384
385 #ifdef short
386 # undef short
387 #endif
388
389 #ifdef YYTYPE_UINT8
390 typedef YYTYPE_UINT8 yytype_uint8;
391 #else
392 typedef unsigned char yytype_uint8;
393 #endif
394
395 #ifdef YYTYPE_INT8
396 typedef YYTYPE_INT8 yytype_int8;
397 #elif (defined __STDC__ || defined __C99__FUNC__ \
398 || defined __cplusplus || defined _MSC_VER)
399 typedef signed char yytype_int8;
400 #else
401 typedef short int yytype_int8;
402 #endif
403
404 #ifdef YYTYPE_UINT16
405 typedef YYTYPE_UINT16 yytype_uint16;
406 #else
407 typedef unsigned short int yytype_uint16;
408 #endif
409
410 #ifdef YYTYPE_INT16
411 typedef YYTYPE_INT16 yytype_int16;
412 #else
413 typedef short int yytype_int16;
414 #endif
415
416 #ifndef YYSIZE_T
417 # ifdef __SIZE_TYPE__
418 # define YYSIZE_T __SIZE_TYPE__
419 # elif defined size_t
420 # define YYSIZE_T size_t
421 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
422 || defined __cplusplus || defined _MSC_VER)
423 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
424 # define YYSIZE_T size_t
425 # else
426 # define YYSIZE_T unsigned int
427 # endif
428 #endif
429
430 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
431
432 #ifndef YY_
433 # if defined YYENABLE_NLS && YYENABLE_NLS
434 # if ENABLE_NLS
435 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
436 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
437 # endif
438 # endif
439 # ifndef YY_
440 # define YY_(Msgid) Msgid
441 # endif
442 #endif
443
444 #ifndef __attribute__
445 /* This feature is available in gcc versions 2.5 and later. */
446 # if (! defined __GNUC__ || __GNUC__ < 2 \
447 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
448 # define __attribute__(Spec) /* empty */
449 # endif
450 #endif
451
452 /* Suppress unused-variable warnings by "using" E. */
453 #if ! defined lint || defined __GNUC__
454 # define YYUSE(E) ((void) (E))
455 #else
456 # define YYUSE(E) /* empty */
457 #endif
458
459
460 /* Identity function, used to suppress warnings about constant conditions. */
461 #ifndef lint
462 # define YYID(N) (N)
463 #else
464 #if (defined __STDC__ || defined __C99__FUNC__ \
465 || defined __cplusplus || defined _MSC_VER)
466 static int
467 YYID (int yyi)
468 #else
469 static int
470 YYID (yyi)
471 int yyi;
472 #endif
473 {
474 return yyi;
475 }
476 #endif
477
478 #if ! defined yyoverflow || YYERROR_VERBOSE
479
480 /* The parser invokes alloca or malloc; define the necessary symbols. */
481
482 # ifdef YYSTACK_USE_ALLOCA
483 # if YYSTACK_USE_ALLOCA
484 # ifdef __GNUC__
485 # define YYSTACK_ALLOC __builtin_alloca
486 # elif defined __BUILTIN_VA_ARG_INCR
487 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
488 # elif defined _AIX
489 # define YYSTACK_ALLOC __alloca
490 # elif defined _MSC_VER
491 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
492 # define alloca _alloca
493 # else
494 # define YYSTACK_ALLOC alloca
495 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
496 || defined __cplusplus || defined _MSC_VER)
497 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
498 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
499 # ifndef EXIT_SUCCESS
500 # define EXIT_SUCCESS 0
501 # endif
502 # endif
503 # endif
504 # endif
505 # endif
506
507 # ifdef YYSTACK_ALLOC
508 /* Pacify GCC's `empty if-body' warning. */
509 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
510 # ifndef YYSTACK_ALLOC_MAXIMUM
511 /* The OS might guarantee only one guard page at the bottom of the stack,
512 and a page size can be as small as 4096 bytes. So we cannot safely
513 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
514 to allow for a few compiler-allocated temporary stack slots. */
515 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
516 # endif
517 # else
518 # define YYSTACK_ALLOC YYMALLOC
519 # define YYSTACK_FREE YYFREE
520 # ifndef YYSTACK_ALLOC_MAXIMUM
521 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
522 # endif
523 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
524 && ! ((defined YYMALLOC || defined malloc) \
525 && (defined YYFREE || defined free)))
526 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
527 # ifndef EXIT_SUCCESS
528 # define EXIT_SUCCESS 0
529 # endif
530 # endif
531 # ifndef YYMALLOC
532 # define YYMALLOC malloc
533 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
534 || defined __cplusplus || defined _MSC_VER)
535 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
536 # endif
537 # endif
538 # ifndef YYFREE
539 # define YYFREE free
540 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
541 || defined __cplusplus || defined _MSC_VER)
542 void free (void *); /* INFRINGES ON USER NAME SPACE */
543 # endif
544 # endif
545 # endif
546 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
547
548
549 #if (! defined yyoverflow \
550 && (! defined __cplusplus \
551 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
552
553 /* A type that is properly aligned for any stack member. */
554 union yyalloc
555 {
556 yytype_int16 yyss_alloc;
557 YYSTYPE yyvs_alloc;
558 };
559
560 /* The size of the maximum gap between one aligned stack and the next. */
561 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
562
563 /* The size of an array large to enough to hold all stacks, each with
564 N elements. */
565 # define YYSTACK_BYTES(N) \
566 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
567 + YYSTACK_GAP_MAXIMUM)
568
569 # define YYCOPY_NEEDED 1
570
571 /* Relocate STACK from its old location to the new one. The
572 local variables YYSIZE and YYSTACKSIZE give the old and new number of
573 elements in the stack, and YYPTR gives the new location of the
574 stack. Advance YYPTR to a properly aligned location for the next
575 stack. */
576 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
577 do \
578 { \
579 YYSIZE_T yynewbytes; \
580 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
581 Stack = &yyptr->Stack_alloc; \
582 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
583 yyptr += yynewbytes / sizeof (*yyptr); \
584 } \
585 while (YYID (0))
586
587 #endif
588
589 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
590 /* Copy COUNT objects from SRC to DST. The source and destination do
591 not overlap. */
592 # ifndef YYCOPY
593 # if defined __GNUC__ && 1 < __GNUC__
594 # define YYCOPY(Dst, Src, Count) \
595 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
596 # else
597 # define YYCOPY(Dst, Src, Count) \
598 do \
599 { \
600 YYSIZE_T yyi; \
601 for (yyi = 0; yyi < (Count); yyi++) \
602 (Dst)[yyi] = (Src)[yyi]; \
603 } \
604 while (YYID (0))
605 # endif
606 # endif
607 #endif /* !YYCOPY_NEEDED */
608
609 /* YYFINAL -- State number of the termination state. */
610 #define YYFINAL 20
611 /* YYLAST -- Last index in YYTABLE. */
612 #define YYLAST 1329
613
614 /* YYNTOKENS -- Number of terminals. */
615 #define YYNTOKENS 125
616 /* YYNNTS -- Number of nonterminals. */
617 #define YYNNTS 71
618 /* YYNRULES -- Number of rules. */
619 #define YYNRULES 234
620 /* YYNRULES -- Number of states. */
621 #define YYNSTATES 527
622
623 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
624 #define YYUNDEFTOK 2
625 #define YYMAXUTOK 356
626
627 #define YYTRANSLATE(YYX) \
628 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
629
630 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
631 static const yytype_uint8 yytranslate[] =
632 {
633 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
634 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
635 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
636 2, 2, 2, 121, 2, 2, 2, 31, 18, 2,
637 115, 116, 29, 27, 119, 28, 2, 30, 2, 2,
638 2, 2, 2, 2, 2, 2, 2, 2, 13, 120,
639 21, 3, 22, 12, 2, 2, 2, 2, 2, 2,
640 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
641 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
642 2, 2, 2, 2, 17, 2, 2, 2, 2, 2,
643 2, 2, 2, 2, 2, 2, 2, 2, 123, 2,
644 2, 122, 2, 2, 2, 2, 2, 2, 2, 2,
645 2, 2, 2, 117, 16, 118, 124, 2, 2, 2,
646 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
647 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
648 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
649 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
650 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
651 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
652 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
653 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
654 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
655 2, 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, 2, 2, 2, 1, 2, 4, 5,
659 6, 7, 8, 9, 10, 11, 14, 15, 19, 20,
660 23, 24, 25, 26, 32, 33, 34, 35, 36, 37,
661 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
662 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
663 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
664 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
665 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
666 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
667 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
668 108, 109, 110, 111, 112, 113, 114
669 };
670
671 #if YYDEBUG
672 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
673 YYRHS. */
674 static const yytype_uint16 yyprhs[] =
675 {
676 0, 0, 3, 6, 9, 12, 15, 18, 19, 24,
677 26, 27, 33, 35, 40, 45, 50, 55, 64, 69,
678 74, 75, 81, 86, 87, 93, 95, 97, 99, 104,
679 105, 108, 110, 113, 117, 119, 123, 125, 128, 129,
680 135, 138, 139, 141, 142, 150, 151, 152, 160, 162,
681 166, 169, 174, 179, 185, 187, 189, 191, 193, 195,
682 196, 201, 202, 207, 208, 213, 214, 216, 218, 220,
683 226, 229, 230, 234, 235, 239, 240, 243, 244, 245,
684 248, 251, 253, 258, 265, 270, 272, 277, 280, 282,
685 284, 286, 288, 290, 292, 294, 299, 301, 306, 308,
686 313, 317, 319, 326, 331, 333, 338, 343, 347, 349,
687 351, 353, 355, 360, 363, 370, 373, 377, 378, 389,
688 392, 393, 397, 402, 403, 405, 407, 409, 411, 413,
689 415, 418, 419, 424, 426, 428, 429, 432, 435, 441,
690 447, 451, 455, 459, 463, 467, 471, 475, 479, 483,
691 490, 497, 498, 501, 505, 508, 511, 514, 517, 521,
692 525, 529, 533, 537, 541, 545, 549, 553, 557, 561,
693 565, 569, 573, 577, 581, 585, 589, 595, 597, 599,
694 606, 613, 618, 620, 625, 630, 635, 640, 645, 650,
695 655, 660, 665, 672, 677, 684, 691, 696, 703, 710,
696 714, 716, 718, 721, 727, 729, 731, 734, 739, 745,
697 752, 754, 757, 758, 761, 766, 771, 780, 782, 784,
698 788, 792, 793, 801, 802, 812, 814, 818, 820, 822,
699 824, 826, 828, 829, 831
700 };
701
702 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
703 static const yytype_int16 yyrhs[] =
704 {
705 126, 0, -1, 111, 127, -1, 112, 184, -1, 113,
706 180, -1, 114, 181, -1, 127, 128, -1, -1, 57,
707 115, 133, 116, -1, 60, -1, -1, 62, 129, 115,
708 136, 116, -1, 65, -1, 67, 115, 136, 116, -1,
709 76, 117, 167, 118, -1, 110, 115, 192, 116, -1,
710 88, 115, 192, 116, -1, 88, 115, 192, 119, 192,
711 119, 192, 116, -1, 90, 117, 172, 118, -1, 94,
712 115, 192, 116, -1, -1, 95, 117, 130, 139, 118,
713 -1, 107, 115, 192, 116, -1, -1, 109, 117, 131,
714 184, 118, -1, 166, -1, 132, -1, 120, -1, 87,
715 115, 192, 116, -1, -1, 134, 135, -1, 192, -1,
716 135, 192, -1, 135, 119, 192, -1, 137, -1, 136,
717 195, 137, -1, 192, -1, 28, 33, -1, -1, 41,
718 138, 115, 136, 116, -1, 139, 140, -1, -1, 166,
719 -1, -1, 192, 142, 141, 117, 156, 118, 151, -1,
720 -1, -1, 143, 145, 147, 148, 149, 144, 150, -1,
721 13, -1, 115, 116, 13, -1, 179, 13, -1, 179,
722 115, 116, 13, -1, 115, 146, 116, 13, -1, 179,
723 115, 146, 116, 13, -1, 81, -1, 54, -1, 48,
724 -1, 66, -1, 89, -1, -1, 42, 115, 179, 116,
725 -1, -1, 38, 115, 179, 116, -1, -1, 105, 115,
726 179, 116, -1, -1, 82, -1, 83, -1, 102, -1,
727 152, 153, 154, 155, 195, -1, 22, 192, -1, -1,
728 42, 22, 192, -1, -1, 154, 13, 192, -1, -1,
729 3, 177, -1, -1, -1, 156, 157, -1, 176, 193,
730 -1, 159, -1, 158, 115, 177, 116, -1, 40, 115,
731 177, 119, 192, 116, -1, 58, 115, 177, 116, -1,
732 47, -1, 101, 115, 47, 116, -1, 64, 192, -1,
733 120, -1, 93, -1, 103, -1, 73, -1, 97, -1,
734 45, -1, 160, -1, 68, 115, 160, 116, -1, 192,
735 -1, 161, 115, 162, 116, -1, 165, -1, 101, 115,
736 165, 116, -1, 162, 195, 163, -1, 163, -1, 162,
737 195, 56, 115, 164, 116, -1, 56, 115, 164, 116,
738 -1, 165, -1, 101, 115, 163, 116, -1, 100, 115,
739 163, 116, -1, 164, 195, 165, -1, 165, -1, 192,
740 -1, 29, -1, 12, -1, 55, 115, 192, 116, -1,
741 176, 193, -1, 40, 115, 177, 119, 192, 116, -1,
742 64, 192, -1, 167, 195, 168, -1, -1, 192, 169,
743 13, 170, 3, 177, 195, 171, 3, 177, -1, 64,
744 192, -1, -1, 115, 192, 116, -1, 115, 121, 192,
745 116, -1, -1, 85, -1, 84, -1, 122, -1, 70,
746 -1, 69, -1, 123, -1, 172, 173, -1, -1, 192,
747 174, 175, 120, -1, 192, -1, 35, -1, -1, 192,
748 175, -1, 90, 175, -1, 192, 115, 35, 116, 175,
749 -1, 42, 115, 177, 116, 175, -1, 192, 3, 177,
750 -1, 192, 11, 177, -1, 192, 10, 177, -1, 192,
751 9, 177, -1, 192, 8, 177, -1, 192, 7, 177,
752 -1, 192, 6, 177, -1, 192, 5, 177, -1, 192,
753 4, 177, -1, 91, 115, 192, 3, 177, 116, -1,
754 92, 115, 192, 3, 177, 116, -1, -1, 178, 179,
755 -1, 115, 179, 116, -1, 28, 179, -1, 121, 179,
756 -1, 124, 179, -1, 27, 179, -1, 179, 29, 179,
757 -1, 179, 30, 179, -1, 179, 31, 179, -1, 179,
758 27, 179, -1, 179, 28, 179, -1, 179, 26, 179,
759 -1, 179, 25, 179, -1, 179, 20, 179, -1, 179,
760 19, 179, -1, 179, 24, 179, -1, 179, 23, 179,
761 -1, 179, 21, 179, -1, 179, 22, 179, -1, 179,
762 18, 179, -1, 179, 17, 179, -1, 179, 16, 179,
763 -1, 179, 15, 179, -1, 179, 14, 179, -1, 179,
764 12, 179, 13, 179, -1, 35, -1, 192, -1, 75,
765 115, 179, 119, 179, 116, -1, 77, 115, 179, 119,
766 179, 116, -1, 53, 115, 192, 116, -1, 99, -1,
767 39, 115, 192, 116, -1, 98, 115, 192, 116, -1,
768 37, 115, 192, 116, -1, 71, 115, 192, 116, -1,
769 85, 115, 192, 116, -1, 70, 115, 192, 116, -1,
770 46, 115, 192, 116, -1, 36, 115, 179, 116, -1,
771 38, 115, 179, 116, -1, 38, 115, 179, 119, 179,
772 116, -1, 44, 115, 179, 116, -1, 50, 115, 179,
773 119, 179, 116, -1, 52, 115, 179, 119, 179, 116,
774 -1, 51, 115, 179, 116, -1, 96, 115, 192, 119,
775 179, 116, -1, 40, 115, 179, 119, 192, 116, -1,
776 192, 3, 177, -1, 182, -1, 183, -1, 182, 183,
777 -1, 117, 189, 120, 118, 120, -1, 185, -1, 186,
778 -1, 185, 186, -1, 117, 188, 118, 120, -1, 192,
779 117, 188, 118, 120, -1, 192, 117, 188, 118, 187,
780 120, -1, 192, -1, 187, 192, -1, -1, 189, 120,
781 -1, 61, 13, 189, 120, -1, 72, 13, 189, 120,
782 -1, 61, 13, 189, 120, 72, 13, 189, 120, -1,
783 33, -1, 34, -1, 189, 120, 33, -1, 189, 120,
784 34, -1, -1, 57, 192, 117, 190, 189, 194, 118,
785 -1, -1, 189, 120, 57, 192, 117, 191, 189, 194,
786 118, -1, 57, -1, 189, 120, 57, -1, 33, -1,
787 34, -1, 120, -1, 119, -1, 120, -1, -1, 119,
788 -1, -1
789 };
790
791 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
792 static const yytype_uint16 yyrline[] =
793 {
794 0, 231, 231, 232, 233, 234, 239, 240, 245, 246,
795 249, 248, 252, 254, 255, 256, 258, 264, 271, 272,
796 275, 274, 278, 281, 280, 284, 285, 286, 294, 302,
797 302, 308, 310, 312, 318, 319, 324, 326, 329, 328,
798 336, 337, 342, 344, 343, 352, 354, 352, 371, 376,
799 381, 386, 391, 396, 405, 407, 412, 417, 422, 432,
800 433, 440, 441, 448, 449, 456, 457, 459, 461, 467,
801 476, 478, 483, 485, 490, 493, 499, 502, 507, 509,
802 515, 516, 517, 519, 521, 523, 530, 531, 533, 539,
803 541, 543, 545, 547, 554, 556, 562, 569, 578, 583,
804 592, 597, 602, 607, 616, 621, 640, 663, 665, 672,
805 674, 679, 689, 691, 692, 694, 700, 701, 706, 710,
806 712, 717, 720, 723, 727, 729, 731, 735, 737, 739,
807 744, 745, 750, 759, 761, 768, 769, 777, 782, 793,
808 802, 804, 810, 816, 822, 828, 834, 840, 846, 852,
809 854, 860, 860, 870, 872, 874, 876, 878, 880, 882,
810 884, 886, 888, 890, 892, 894, 896, 898, 900, 902,
811 904, 906, 908, 910, 912, 914, 916, 918, 920, 922,
812 924, 926, 928, 930, 932, 934, 936, 938, 940, 942,
813 944, 946, 948, 950, 952, 957, 962, 964, 972, 978,
814 988, 991, 992, 996, 1002, 1006, 1007, 1011, 1015, 1020,
815 1027, 1031, 1039, 1040, 1042, 1044, 1046, 1055, 1060, 1065,
816 1070, 1077, 1076, 1087, 1086, 1093, 1098, 1108, 1110, 1117,
817 1118, 1123, 1124, 1129, 1130
818 };
819 #endif
820
821 #if YYDEBUG || YYERROR_VERBOSE || 1
822 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
823 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
824 static const char *const yytname[] =
825 {
826 "$end", "error", "$undefined", "'='", "OREQ", "ANDEQ", "RSHIFTEQ",
827 "LSHIFTEQ", "DIVEQ", "MULTEQ", "MINUSEQ", "PLUSEQ", "'?'", "':'", "OROR",
828 "ANDAND", "'|'", "'^'", "'&'", "NE", "EQ", "'<'", "'>'", "GE", "LE",
829 "RSHIFT", "LSHIFT", "'+'", "'-'", "'*'", "'/'", "'%'", "UNARY", "STRING",
830 "QUOTED_STRING", "INTEGER", "ABSOLUTE", "ADDR", "ALIGN_K", "ALIGNOF",
831 "ASSERT_K", "AS_NEEDED", "AT", "BIND", "BLOCK", "BYTE", "CONSTANT",
832 "CONSTRUCTORS", "COPY", "CREATE_OBJECT_SYMBOLS", "DATA_SEGMENT_ALIGN",
833 "DATA_SEGMENT_END", "DATA_SEGMENT_RELRO_END", "DEFINED", "DSECT",
834 "ENTRY", "EXCLUDE_FILE", "EXTERN", "FILL", "FLOAT",
835 "FORCE_COMMON_ALLOCATION", "GLOBAL", "GROUP", "HLL", "INCLUDE",
836 "INHIBIT_COMMON_ALLOCATION", "INFO", "INPUT", "KEEP", "LEN", "LENGTH",
837 "LOADADDR", "LOCAL", "LONG", "MAP", "MAX_K", "MEMORY", "MIN_K", "NEXT",
838 "NOCROSSREFS", "NOFLOAT", "NOLOAD", "ONLY_IF_RO", "ONLY_IF_RW", "ORG",
839 "ORIGIN", "OUTPUT", "OUTPUT_ARCH", "OUTPUT_FORMAT", "OVERLAY", "PHDRS",
840 "PROVIDE", "PROVIDE_HIDDEN", "QUAD", "SEARCH_DIR", "SECTIONS",
841 "SEGMENT_START", "SHORT", "SIZEOF", "SIZEOF_HEADERS",
842 "SORT_BY_ALIGNMENT", "SORT_BY_NAME", "SPECIAL", "SQUAD", "STARTUP",
843 "SUBALIGN", "SYSLIB", "TARGET_K", "TRUNCATE", "VERSIONK", "OPTION",
844 "PARSING_LINKER_SCRIPT", "PARSING_VERSION_SCRIPT", "PARSING_DEFSYM",
845 "PARSING_DYNAMIC_LIST", "'('", "')'", "'{'", "'}'", "','", "';'", "'!'",
846 "'o'", "'l'", "'~'", "$accept", "top", "linker_script", "file_cmd",
847 "$@1", "$@2", "$@3", "ignore_cmd", "extern_name_list", "$@4",
848 "extern_name_list_body", "input_list", "input_list_element", "$@5",
849 "sections_block", "section_block_cmd", "$@6", "section_header", "$@7",
850 "$@8", "opt_address_and_section_type", "section_type", "opt_at",
851 "opt_align", "opt_subalign", "opt_constraint", "section_trailer",
852 "opt_memspec", "opt_at_memspec", "opt_phdr", "opt_fill", "section_cmds",
853 "section_cmd", "data_length", "input_section_spec",
854 "input_section_no_keep", "wildcard_file", "wildcard_sections",
855 "wildcard_section", "exclude_names", "wildcard_name",
856 "file_or_sections_cmd", "memory_defs", "memory_def", "memory_attr",
857 "memory_origin", "memory_length", "phdrs_defs", "phdr_def", "phdr_type",
858 "phdr_info", "assignment", "parse_exp", "$@9", "exp", "defsym_expr",
859 "dynamic_list_expr", "dynamic_list_nodes", "dynamic_list_node",
860 "version_script", "vers_nodes", "vers_node", "verdep", "vers_tag",
861 "vers_defns", "$@10", "$@11", "string", "end", "opt_semicolon",
862 "opt_comma", YY_NULL
863 };
864 #endif
865
866 # ifdef YYPRINT
867 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
868 token YYLEX-NUM. */
869 static const yytype_uint16 yytoknum[] =
870 {
871 0, 256, 257, 61, 258, 259, 260, 261, 262, 263,
872 264, 265, 63, 58, 266, 267, 124, 94, 38, 268,
873 269, 60, 62, 270, 271, 272, 273, 43, 45, 42,
874 47, 37, 274, 275, 276, 277, 278, 279, 280, 281,
875 282, 283, 284, 285, 286, 287, 288, 289, 290, 291,
876 292, 293, 294, 295, 296, 297, 298, 299, 300, 301,
877 302, 303, 304, 305, 306, 307, 308, 309, 310, 311,
878 312, 313, 314, 315, 316, 317, 318, 319, 320, 321,
879 322, 323, 324, 325, 326, 327, 328, 329, 330, 331,
880 332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
881 342, 343, 344, 345, 346, 347, 348, 349, 350, 351,
882 352, 353, 354, 355, 356, 40, 41, 123, 125, 44,
883 59, 33, 111, 108, 126
884 };
885 # endif
886
887 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
888 static const yytype_uint8 yyr1[] =
889 {
890 0, 125, 126, 126, 126, 126, 127, 127, 128, 128,
891 129, 128, 128, 128, 128, 128, 128, 128, 128, 128,
892 130, 128, 128, 131, 128, 128, 128, 128, 132, 134,
893 133, 135, 135, 135, 136, 136, 137, 137, 138, 137,
894 139, 139, 140, 141, 140, 143, 144, 142, 145, 145,
895 145, 145, 145, 145, 146, 146, 146, 146, 146, 147,
896 147, 148, 148, 149, 149, 150, 150, 150, 150, 151,
897 152, 152, 153, 153, 154, 154, 155, 155, 156, 156,
898 157, 157, 157, 157, 157, 157, 157, 157, 157, 158,
899 158, 158, 158, 158, 159, 159, 160, 160, 161, 161,
900 162, 162, 162, 162, 163, 163, 163, 164, 164, 165,
901 165, 165, 166, 166, 166, 166, 167, 167, 168, 168,
902 168, 169, 169, 169, 170, 170, 170, 171, 171, 171,
903 172, 172, 173, 174, 174, 175, 175, 175, 175, 175,
904 176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
905 176, 178, 177, 179, 179, 179, 179, 179, 179, 179,
906 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
907 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
908 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
909 179, 179, 179, 179, 179, 179, 179, 179, 179, 180,
910 181, 182, 182, 183, 184, 185, 185, 186, 186, 186,
911 187, 187, 188, 188, 188, 188, 188, 189, 189, 189,
912 189, 190, 189, 191, 189, 189, 189, 192, 192, 193,
913 193, 194, 194, 195, 195
914 };
915
916 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
917 static const yytype_uint8 yyr2[] =
918 {
919 0, 2, 2, 2, 2, 2, 2, 0, 4, 1,
920 0, 5, 1, 4, 4, 4, 4, 8, 4, 4,
921 0, 5, 4, 0, 5, 1, 1, 1, 4, 0,
922 2, 1, 2, 3, 1, 3, 1, 2, 0, 5,
923 2, 0, 1, 0, 7, 0, 0, 7, 1, 3,
924 2, 4, 4, 5, 1, 1, 1, 1, 1, 0,
925 4, 0, 4, 0, 4, 0, 1, 1, 1, 5,
926 2, 0, 3, 0, 3, 0, 2, 0, 0, 2,
927 2, 1, 4, 6, 4, 1, 4, 2, 1, 1,
928 1, 1, 1, 1, 1, 4, 1, 4, 1, 4,
929 3, 1, 6, 4, 1, 4, 4, 3, 1, 1,
930 1, 1, 4, 2, 6, 2, 3, 0, 10, 2,
931 0, 3, 4, 0, 1, 1, 1, 1, 1, 1,
932 2, 0, 4, 1, 1, 0, 2, 2, 5, 5,
933 3, 3, 3, 3, 3, 3, 3, 3, 3, 6,
934 6, 0, 2, 3, 2, 2, 2, 2, 3, 3,
935 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
936 3, 3, 3, 3, 3, 3, 5, 1, 1, 6,
937 6, 4, 1, 4, 4, 4, 4, 4, 4, 4,
938 4, 4, 6, 4, 6, 6, 4, 6, 6, 3,
939 1, 1, 2, 5, 1, 1, 2, 4, 5, 6,
940 1, 2, 0, 2, 4, 4, 8, 1, 1, 3,
941 3, 0, 7, 0, 9, 1, 3, 1, 1, 1,
942 1, 1, 0, 1, 0
943 };
944
945 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
946 Performed when YYTABLE doesn't specify something else to do. Zero
947 means the default is an error. */
948 static const yytype_uint8 yydefact[] =
949 {
950 0, 7, 0, 0, 0, 0, 2, 227, 228, 212,
951 3, 204, 205, 0, 4, 0, 0, 5, 200, 201,
952 1, 0, 0, 0, 9, 10, 0, 12, 0, 0,
953 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
954 27, 6, 26, 25, 0, 0, 217, 218, 225, 0,
955 0, 0, 0, 206, 212, 151, 0, 202, 151, 0,
956 29, 0, 115, 0, 117, 0, 0, 131, 0, 0,
957 0, 20, 0, 23, 0, 230, 229, 113, 151, 151,
958 151, 151, 151, 151, 151, 151, 151, 0, 0, 0,
959 0, 213, 0, 199, 0, 0, 0, 0, 0, 0,
960 0, 0, 38, 234, 34, 36, 234, 0, 0, 0,
961 0, 0, 0, 41, 0, 0, 0, 140, 148, 147,
962 146, 145, 144, 143, 142, 141, 221, 0, 0, 207,
963 219, 220, 226, 0, 0, 0, 177, 0, 0, 0,
964 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
965 0, 0, 0, 0, 0, 182, 0, 0, 0, 152,
966 178, 0, 0, 112, 8, 30, 31, 234, 37, 0,
967 13, 233, 0, 14, 120, 28, 16, 0, 18, 130,
968 0, 151, 151, 19, 0, 22, 0, 15, 0, 214,
969 215, 0, 208, 0, 210, 157, 154, 0, 0, 0,
970 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
971 0, 0, 0, 0, 0, 0, 155, 156, 0, 0,
972 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
973 0, 0, 0, 0, 0, 0, 0, 203, 0, 0,
974 32, 11, 0, 35, 0, 116, 123, 0, 134, 135,
975 133, 0, 0, 21, 40, 42, 45, 24, 232, 0,
976 223, 209, 211, 0, 0, 0, 0, 0, 0, 0,
977 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
978 0, 153, 0, 175, 174, 173, 172, 171, 166, 165,
979 169, 170, 168, 167, 164, 163, 161, 162, 158, 159,
980 160, 114, 33, 234, 119, 0, 0, 0, 0, 135,
981 0, 135, 149, 150, 43, 0, 231, 0, 0, 0,
982 190, 185, 191, 0, 183, 0, 193, 189, 0, 196,
983 0, 181, 188, 186, 0, 0, 187, 0, 184, 0,
984 39, 0, 0, 0, 0, 151, 137, 132, 0, 136,
985 0, 48, 0, 59, 0, 222, 0, 232, 0, 0,
986 0, 0, 0, 0, 0, 176, 0, 121, 125, 124,
987 126, 0, 17, 0, 0, 78, 56, 55, 57, 54,
988 58, 0, 0, 0, 61, 50, 0, 216, 0, 192,
989 198, 194, 195, 179, 180, 197, 122, 151, 135, 135,
990 0, 49, 0, 0, 0, 63, 0, 0, 224, 234,
991 139, 138, 111, 110, 0, 93, 85, 0, 0, 0,
992 91, 89, 92, 0, 90, 71, 88, 79, 0, 81,
993 94, 0, 98, 0, 96, 52, 0, 0, 0, 46,
994 51, 0, 0, 151, 151, 87, 0, 0, 0, 44,
995 73, 151, 0, 80, 60, 0, 0, 65, 53, 128,
996 127, 129, 0, 0, 0, 0, 0, 96, 0, 0,
997 109, 70, 0, 75, 0, 0, 0, 0, 234, 101,
998 104, 62, 0, 66, 67, 68, 47, 151, 0, 84,
999 0, 95, 86, 99, 0, 77, 82, 0, 0, 0,
1000 97, 0, 64, 118, 0, 72, 151, 0, 234, 234,
1001 108, 0, 0, 0, 100, 83, 76, 74, 69, 103,
1002 0, 106, 105, 0, 107, 234, 102
1003 };
1004
1005 /* YYDEFGOTO[NTERM-NUM]. */
1006 static const yytype_int16 yydefgoto[] =
1007 {
1008 -1, 5, 6, 41, 61, 113, 115, 42, 98, 99,
1009 165, 103, 104, 169, 184, 254, 350, 314, 315, 457,
1010 353, 382, 384, 405, 439, 486, 449, 450, 473, 495,
1011 508, 400, 427, 428, 429, 430, 431, 478, 479, 509,
1012 480, 43, 106, 245, 306, 371, 462, 109, 179, 249,
1013 310, 44, 93, 94, 215, 14, 17, 18, 19, 10,
1014 11, 12, 193, 51, 52, 188, 319, 160, 77, 317,
1015 172
1016 };
1017
1018 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1019 STATE-NUM. */
1020 #define YYPACT_NINF -396
1021 static const yytype_int16 yypact[] =
1022 {
1023 155, -396, 42, 90, -106, 13, 1169, -396, -396, 122,
1024 -396, 42, -396, -85, -396, 44, 135, -396, -106, -396,
1025 -396, -72, -55, -46, -396, -396, 90, -396, -11, -7,
1026 4, 19, 29, 46, 52, 69, 35, 78, 54, 82,
1027 -396, -396, -396, -396, 20, 321, -396, -396, 90, 144,
1028 202, -6, 97, -396, 122, -396, 103, -396, -396, 90,
1029 -396, 110, -396, 185, -396, 90, 90, -396, 90, 90,
1030 90, -396, 90, -396, 90, -396, -396, -396, -396, -396,
1031 -396, -396, -396, -396, -396, -396, -396, 111, 135, 135,
1032 118, 143, 127, -396, 1129, 72, 124, 113, 157, 90,
1033 185, 265, -396, -63, -396, -396, 84, 186, 108, 40,
1034 301, 305, 218, -396, 220, 42, 232, -396, -396, -396,
1035 -396, -396, -396, -396, -396, -396, -396, 229, 231, -396,
1036 -396, -396, 90, -3, 1129, 1129, -396, 237, 258, 259,
1037 262, 263, 289, 300, 302, 303, 304, 306, 309, 332,
1038 333, 334, 337, 338, 339, -396, 1129, 1129, 1129, 1298,
1039 -396, 335, 90, -396, -396, -5, -396, 120, -396, 341,
1040 -396, -396, 185, -396, 131, -396, -396, 90, -396, -396,
1041 310, -396, -396, -396, 56, -396, 340, -396, 135, 109,
1042 143, 343, -396, 25, -396, -396, -396, 1129, 90, 1129,
1043 90, 1129, 1129, 90, 1129, 1129, 1129, 90, 90, 90,
1044 1129, 1129, 90, 90, 90, 234, -396, -396, 1129, 1129,
1045 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,
1046 1129, 1129, 1129, 1129, 1129, 1129, 1129, -396, 345, 90,
1047 -396, -396, 185, -396, 90, -396, 342, 344, -396, 59,
1048 -396, 349, 351, -396, -396, -396, 321, -396, 348, 407,
1049 -396, -396, -396, 718, 353, 260, 356, 411, 744, 358,
1050 638, 764, 658, 360, 361, 362, 678, 698, 363, 365,
1051 366, -396, 1278, 590, 364, 801, 617, 900, 291, 291,
1052 383, 383, 383, 383, 204, 204, 372, 372, -396, -396,
1053 -396, -396, -396, 125, -396, -27, 467, 90, 368, 59,
1054 367, 99, -396, -396, -396, 476, 143, 373, 135, 135,
1055 -396, -396, -396, 1129, -396, 90, -396, -396, 1129, -396,
1056 1129, -396, -396, -396, 1129, 1129, -396, 1129, -396, 1129,
1057 -396, 90, 369, 51, 374, -396, -396, -396, 446, -396,
1058 376, -396, 1037, 452, 1029, -396, 378, 348, 784, 384,
1059 821, 847, 867, 887, 924, 1298, 385, -396, -396, -396,
1060 -396, 499, -396, 390, 391, -396, -396, -396, -396, -396,
1061 -396, 495, 401, 404, 485, -396, 37, 143, 406, -396,
1062 -396, -396, -396, -396, -396, -396, -396, -396, 59, 59,
1063 531, -396, 512, 1129, 416, 427, 520, 418, -396, 417,
1064 -396, -396, -396, -396, 420, -396, -396, 422, 90, 423,
1065 -396, -396, -396, 425, -396, 519, -396, -396, 429, -396,
1066 -396, 430, -396, 20, 12, -396, 950, 1129, 433, -396,
1067 -396, 529, 39, -396, -396, -396, 53, 175, 90, -396,
1068 507, -396, 15, -396, -396, 970, 1129, -57, -396, -396,
1069 -396, -396, 547, 435, 436, 440, 441, 443, 447, 450,
1070 -396, -396, 534, -396, 451, 444, 453, 454, 176, -396,
1071 -396, -396, 990, -396, -396, -396, -396, -396, 90, -396,
1072 187, -396, -396, -396, 90, 75, -396, 187, 50, 50,
1073 -396, 21, -396, -396, 461, -396, -396, 90, 417, 180,
1074 -396, 463, 464, 455, -396, -396, -396, -396, -396, -396,
1075 187, -396, -396, 187, -396, 181, -396
1076 };
1077
1078 /* YYPGOTO[NTERM-NUM]. */
1079 static const yytype_int16 yypgoto[] =
1080 {
1081 -396, -396, -396, -396, -396, -396, -396, -396, -396, -396,
1082 -396, -98, 409, -396, -396, -396, -396, -396, -396, -396,
1083 -396, 196, -396, -396, -396, -396, -396, -396, -396, -396,
1084 -396, -396, -396, -396, -396, 116, -396, -396, -313, 60,
1085 -395, 400, -396, -396, -396, -396, -396, -396, -396, -396,
1086 -299, 188, -44, -396, 136, -396, -396, -396, 567, 471,
1087 -396, 576, -396, 536, -8, -396, -396, -2, 160, 239,
1088 -103
1089 };
1090
1091 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1092 positive, shift that token. If negative, reduce the rule which
1093 number is the opposite. If YYTABLE_NINF, syntax error. */
1094 #define YYTABLE_NINF -110
1095 static const yytype_int16 yytable[] =
1096 {
1097 13, 15, 167, 174, 45, 432, 7, 8, 56, 13,
1098 346, 16, 349, 20, 96, 78, 79, 80, 81, 82,
1099 83, 84, 85, 86, 62, 483, 484, 412, 7, 8,
1100 7, 8, 54, 412, 117, 118, 119, 120, 121, 122,
1101 123, 124, 125, 58, 413, 485, 87, 55, 7, 8,
1102 413, 432, 469, 170, 7, 8, 171, 97, 7, 8,
1103 59, 105, 412, 107, 108, 412, 110, 111, 112, 60,
1104 114, 475, 116, 7, 8, 7, 8, 513, 506, 413,
1105 127, 128, 413, 7, 8, 376, 7, 8, 507, 7,
1106 8, 377, 7, 8, 341, 469, 21, 166, 105, 410,
1107 411, 308, 510, 378, 63, 130, 131, 180, 459, 460,
1108 64, 22, 90, 13, 239, 476, 477, 192, 379, 65,
1109 26, 476, 477, 7, 8, 524, 380, -109, 510, 132,
1110 191, 194, 7, 8, 66, 368, 369, 251, 252, 75,
1111 76, 308, 130, 131, 303, 261, 67, 33, 34, 309,
1112 476, 477, 71, 406, 465, 46, 47, 88, 178, 9,
1113 238, 68, 461, 240, 7, 8, 132, 69, 46, 47,
1114 105, 73, 246, 370, 253, 247, 130, 131, 250, 48,
1115 258, 259, 256, 49, 70, 511, 512, 412, 514, 309,
1116 161, 262, 48, 72, 50, 244, 264, 74, 266, 412,
1117 132, 269, 173, 171, 413, 273, 274, 275, 7, 8,
1118 278, 279, 280, 101, 348, 89, 413, 91, 7, 8,
1119 7, 8, 468, 95, 176, 100, 102, 177, 126, 163,
1120 159, 232, 233, 234, 235, 236, 241, 302, 129, 171,
1121 105, 340, 304, 162, 171, 133, 218, 311, 219, 220,
1122 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
1123 231, 232, 233, 234, 235, 236, 1, 2, 3, 4,
1124 195, 196, 218, 164, 219, 220, 221, 222, 223, 224,
1125 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,
1126 235, 236, 500, 216, 217, 171, 519, 526, 168, 171,
1127 171, 373, 175, 342, 181, 344, 442, 311, 182, 311,
1128 356, 357, 226, 227, 228, 229, 230, 231, 232, 233,
1129 234, 235, 236, 359, 78, 79, 80, 81, 82, 83,
1130 84, 85, 86, 263, 183, 265, 185, 267, 268, 366,
1131 270, 271, 272, 7, 8, 248, 276, 277, 187, 189,
1132 281, 190, 197, 409, 282, 283, 284, 285, 286, 287,
1133 288, 289, 290, 291, 292, 293, 294, 295, 296, 297,
1134 298, 299, 300, 198, 199, 501, 322, 200, 201, 323,
1135 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
1136 231, 232, 233, 234, 235, 236, 311, 311, 434, 463,
1137 464, 234, 235, 236, 202, 518, 520, 474, 230, 231,
1138 232, 233, 234, 235, 236, 203, 445, 204, 205, 206,
1139 318, 207, 520, 218, 208, 219, 220, 221, 222, 223,
1140 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
1141 234, 235, 236, 503, 467, 470, 471, 209, 210, 211,
1142 470, 354, 212, 213, 214, 237, 242, 305, 257, 358,
1143 260, 301, 516, 307, 360, 312, 361, 313, 316, 321,
1144 362, 363, 324, 364, 327, 365, 331, 332, 333, 336,
1145 343, 374, 338, 345, 337, 367, 504, 347, 470, 351,
1146 372, 355, 505, 375, 383, 470, 470, 470, 387, 470,
1147 390, 396, 397, 134, 135, 517, 398, 399, 401, 7,
1148 8, 136, 137, 138, 139, 140, 141, 402, 470, 403,
1149 142, 470, 143, 404, 408, 435, 144, 145, 146, 147,
1150 325, 437, 438, 440, 441, 443, 171, 444, 446, 436,
1151 447, 448, 458, 412, 451, 452, 148, 149, 456, 472,
1152 487, 150, 489, 151, 488, 490, 494, 491, -109, 497,
1153 413, 152, 466, 492, 7, 8, 493, 496, 498, 499,
1154 523, 414, 153, 455, 154, 155, 415, 515, 416, 521,
1155 522, 243, 407, 525, 255, 57, 186, 53, 433, 417,
1156 92, 352, 482, 453, 0, 418, 388, 157, 0, 419,
1157 158, 0, 0, 0, 420, 220, 221, 222, 223, 224,
1158 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,
1159 235, 236, 33, 34, 421, 0, 0, 0, 422, 0,
1160 0, 0, 423, 0, 424, 223, 224, 225, 226, 227,
1161 228, 229, 230, 231, 232, 233, 234, 235, 236, 425,
1162 218, 426, 219, 220, 221, 222, 223, 224, 225, 226,
1163 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
1164 218, 0, 219, 220, 221, 222, 223, 224, 225, 226,
1165 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
1166 218, 0, 219, 220, 221, 222, 223, 224, 225, 226,
1167 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
1168 218, 0, 219, 220, 221, 222, 223, 224, 225, 226,
1169 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
1170 218, 0, 219, 220, 221, 222, 223, 224, 225, 226,
1171 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
1172 0, 0, 0, 0, 0, 0, 218, 328, 219, 220,
1173 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
1174 231, 232, 233, 234, 235, 236, 218, 330, 219, 220,
1175 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
1176 231, 232, 233, 234, 235, 236, 218, 334, 219, 220,
1177 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
1178 231, 232, 233, 234, 235, 236, 0, 335, 222, 223,
1179 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
1180 234, 235, 236, 218, 320, 219, 220, 221, 222, 223,
1181 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
1182 234, 235, 236, 0, 0, 0, 0, 0, 0, 218,
1183 326, 219, 220, 221, 222, 223, 224, 225, 226, 227,
1184 228, 229, 230, 231, 232, 233, 234, 235, 236, 218,
1185 329, 219, 220, 221, 222, 223, 224, 225, 226, 227,
1186 228, 229, 230, 231, 232, 233, 234, 235, 236, 218,
1187 389, 219, 220, 221, 222, 223, 224, 225, 226, 227,
1188 228, 229, 230, 231, 232, 233, 234, 235, 236, 224,
1189 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,
1190 235, 236, 0, 0, 0, 0, 218, 391, 219, 220,
1191 221, 222, 223, 224, 225, 226, 227, 228, 229, 230,
1192 231, 232, 233, 234, 235, 236, 0, 0, 0, 0,
1193 0, 0, 218, 392, 219, 220, 221, 222, 223, 224,
1194 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,
1195 235, 236, 218, 393, 219, 220, 221, 222, 223, 224,
1196 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,
1197 235, 236, 218, 394, 219, 220, 221, 222, 223, 224,
1198 225, 226, 227, 228, 229, 230, 231, 232, 233, 234,
1199 235, 236, 0, 0, 0, 0, 0, 0, 0, 0,
1200 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1201 395, 218, 385, 219, 220, 221, 222, 223, 224, 225,
1202 226, 227, 228, 229, 230, 231, 232, 233, 234, 235,
1203 236, 0, 0, 0, 134, 135, 454, 0, 0, 0,
1204 7, 8, 136, 137, 138, 139, 140, 141, 0, 0,
1205 0, 142, 0, 143, 0, 376, 481, 144, 145, 146,
1206 147, 377, 0, 0, 0, 0, 0, 0, 0, 0,
1207 0, 0, 0, 378, 0, 0, 502, 148, 149, 0,
1208 0, 0, 150, 0, 151, 0, 0, 0, 379, 0,
1209 0, 0, 152, 0, 0, 0, 380, 0, 0, 0,
1210 0, 0, 0, 153, 0, 154, 155, 0, 0, 0,
1211 0, 0, 0, 0, 386, 0, 0, 0, 0, 0,
1212 0, 0, 156, 381, 0, 0, 134, 135, 157, 0,
1213 0, 158, 7, 8, 136, 137, 138, 139, 140, 141,
1214 0, 0, 0, 142, 0, 143, 0, 0, 0, 144,
1215 145, 146, 147, 0, 0, 0, 0, 0, 0, 0,
1216 0, 0, 0, 0, 0, 0, 0, 0, 0, 148,
1217 149, 0, 7, 8, 150, 0, 151, 0, 0, 21,
1218 0, 0, 0, 0, 152, 0, 0, 0, 0, 0,
1219 0, 0, 0, 0, 22, 153, 23, 154, 155, 24,
1220 0, 25, 0, 26, 27, 0, 28, 0, 0, 0,
1221 0, 0, 0, 0, 156, 29, 0, 0, 0, 0,
1222 157, 0, 0, 158, 0, 0, 30, 31, 0, 32,
1223 33, 34, 0, 35, 36, 0, 0, 0, 0, 0,
1224 0, 0, 0, 0, 0, 0, 37, 0, 38, 39,
1225 0, 0, 0, 0, 0, 0, 0, 0, 0, 40,
1226 218, 339, 219, 220, 221, 222, 223, 224, 225, 226,
1227 227, 228, 229, 230, 231, 232, 233, 234, 235, 236,
1228 218, 0, 219, 220, 221, 222, 223, 224, 225, 226,
1229 227, 228, 229, 230, 231, 232, 233, 234, 235, 236
1230 };
1231
1232 #define yypact_value_is_default(Yystate) \
1233 (!!((Yystate) == (-396)))
1234
1235 #define yytable_value_is_error(Yytable_value) \
1236 YYID (0)
1237
1238 static const yytype_int16 yycheck[] =
1239 {
1240 2, 3, 100, 106, 6, 400, 33, 34, 16, 11,
1241 309, 117, 311, 0, 58, 3, 4, 5, 6, 7,
1242 8, 9, 10, 11, 26, 82, 83, 12, 33, 34,
1243 33, 34, 117, 12, 78, 79, 80, 81, 82, 83,
1244 84, 85, 86, 115, 29, 102, 48, 3, 33, 34,
1245 29, 446, 447, 116, 33, 34, 119, 59, 33, 34,
1246 115, 63, 12, 65, 66, 12, 68, 69, 70, 115,
1247 72, 56, 74, 33, 34, 33, 34, 56, 3, 29,
1248 88, 89, 29, 33, 34, 48, 33, 34, 13, 33,
1249 34, 54, 33, 34, 121, 490, 40, 99, 100, 398,
1250 399, 42, 497, 66, 115, 33, 34, 109, 69, 70,
1251 117, 55, 118, 115, 119, 100, 101, 120, 81, 115,
1252 64, 100, 101, 33, 34, 520, 89, 115, 523, 57,
1253 132, 133, 33, 34, 115, 84, 85, 181, 182, 119,
1254 120, 42, 33, 34, 242, 120, 117, 91, 92, 90,
1255 100, 101, 117, 116, 101, 33, 34, 13, 118, 117,
1256 162, 115, 123, 165, 33, 34, 57, 115, 33, 34,
1257 172, 117, 174, 122, 118, 177, 33, 34, 180, 57,
1258 188, 72, 184, 61, 115, 498, 499, 12, 501, 90,
1259 118, 193, 57, 115, 72, 64, 198, 115, 200, 12,
1260 57, 203, 118, 119, 29, 207, 208, 209, 33, 34,
1261 212, 213, 214, 28, 115, 13, 29, 120, 33, 34,
1262 33, 34, 47, 120, 116, 115, 41, 119, 117, 116,
1263 94, 27, 28, 29, 30, 31, 116, 239, 120, 119,
1264 242, 116, 244, 119, 119, 118, 12, 249, 14, 15,
1265 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1266 26, 27, 28, 29, 30, 31, 111, 112, 113, 114,
1267 134, 135, 12, 116, 14, 15, 16, 17, 18, 19,
1268 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1269 30, 31, 116, 157, 158, 119, 116, 116, 33, 119,
1270 119, 345, 116, 305, 3, 307, 409, 309, 3, 311,
1271 318, 319, 21, 22, 23, 24, 25, 26, 27, 28,
1272 29, 30, 31, 325, 3, 4, 5, 6, 7, 8,
1273 9, 10, 11, 197, 116, 199, 116, 201, 202, 341,
1274 204, 205, 206, 33, 34, 35, 210, 211, 116, 120,
1275 116, 120, 115, 397, 218, 219, 220, 221, 222, 223,
1276 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
1277 234, 235, 236, 115, 115, 478, 116, 115, 115, 119,
1278 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1279 26, 27, 28, 29, 30, 31, 398, 399, 400, 443,
1280 444, 29, 30, 31, 115, 508, 509, 451, 25, 26,
1281 27, 28, 29, 30, 31, 115, 418, 115, 115, 115,
1282 13, 115, 525, 12, 115, 14, 15, 16, 17, 18,
1283 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1284 29, 30, 31, 487, 446, 447, 448, 115, 115, 115,
1285 452, 315, 115, 115, 115, 120, 115, 115, 118, 323,
1286 117, 116, 506, 119, 328, 116, 330, 116, 120, 116,
1287 334, 335, 116, 337, 116, 339, 116, 116, 116, 116,
1288 13, 35, 116, 115, 119, 116, 488, 120, 490, 13,
1289 116, 118, 494, 117, 42, 497, 498, 499, 120, 501,
1290 116, 116, 3, 27, 28, 507, 116, 116, 13, 33,
1291 34, 35, 36, 37, 38, 39, 40, 116, 520, 115,
1292 44, 523, 46, 38, 118, 13, 50, 51, 52, 53,
1293 119, 115, 105, 13, 116, 115, 119, 115, 115, 403,
1294 115, 22, 13, 12, 115, 115, 70, 71, 115, 42,
1295 3, 75, 116, 77, 119, 115, 22, 116, 115, 115,
1296 29, 85, 446, 116, 33, 34, 116, 116, 115, 115,
1297 115, 40, 96, 437, 98, 99, 45, 116, 47, 116,
1298 116, 172, 386, 523, 184, 18, 115, 11, 400, 58,
1299 54, 115, 456, 433, -1, 64, 357, 121, -1, 68,
1300 124, -1, -1, -1, 73, 15, 16, 17, 18, 19,
1301 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1302 30, 31, 91, 92, 93, -1, -1, -1, 97, -1,
1303 -1, -1, 101, -1, 103, 18, 19, 20, 21, 22,
1304 23, 24, 25, 26, 27, 28, 29, 30, 31, 118,
1305 12, 120, 14, 15, 16, 17, 18, 19, 20, 21,
1306 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1307 12, -1, 14, 15, 16, 17, 18, 19, 20, 21,
1308 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1309 12, -1, 14, 15, 16, 17, 18, 19, 20, 21,
1310 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1311 12, -1, 14, 15, 16, 17, 18, 19, 20, 21,
1312 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1313 12, -1, 14, 15, 16, 17, 18, 19, 20, 21,
1314 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1315 -1, -1, -1, -1, -1, -1, 12, 119, 14, 15,
1316 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1317 26, 27, 28, 29, 30, 31, 12, 119, 14, 15,
1318 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1319 26, 27, 28, 29, 30, 31, 12, 119, 14, 15,
1320 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1321 26, 27, 28, 29, 30, 31, -1, 119, 17, 18,
1322 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1323 29, 30, 31, 12, 116, 14, 15, 16, 17, 18,
1324 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1325 29, 30, 31, -1, -1, -1, -1, -1, -1, 12,
1326 116, 14, 15, 16, 17, 18, 19, 20, 21, 22,
1327 23, 24, 25, 26, 27, 28, 29, 30, 31, 12,
1328 116, 14, 15, 16, 17, 18, 19, 20, 21, 22,
1329 23, 24, 25, 26, 27, 28, 29, 30, 31, 12,
1330 116, 14, 15, 16, 17, 18, 19, 20, 21, 22,
1331 23, 24, 25, 26, 27, 28, 29, 30, 31, 19,
1332 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1333 30, 31, -1, -1, -1, -1, 12, 116, 14, 15,
1334 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
1335 26, 27, 28, 29, 30, 31, -1, -1, -1, -1,
1336 -1, -1, 12, 116, 14, 15, 16, 17, 18, 19,
1337 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1338 30, 31, 12, 116, 14, 15, 16, 17, 18, 19,
1339 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1340 30, 31, 12, 116, 14, 15, 16, 17, 18, 19,
1341 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1342 30, 31, -1, -1, -1, -1, -1, -1, -1, -1,
1343 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1344 116, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1345 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1346 31, -1, -1, -1, 27, 28, 116, -1, -1, -1,
1347 33, 34, 35, 36, 37, 38, 39, 40, -1, -1,
1348 -1, 44, -1, 46, -1, 48, 116, 50, 51, 52,
1349 53, 54, -1, -1, -1, -1, -1, -1, -1, -1,
1350 -1, -1, -1, 66, -1, -1, 116, 70, 71, -1,
1351 -1, -1, 75, -1, 77, -1, -1, -1, 81, -1,
1352 -1, -1, 85, -1, -1, -1, 89, -1, -1, -1,
1353 -1, -1, -1, 96, -1, 98, 99, -1, -1, -1,
1354 -1, -1, -1, -1, 115, -1, -1, -1, -1, -1,
1355 -1, -1, 115, 116, -1, -1, 27, 28, 121, -1,
1356 -1, 124, 33, 34, 35, 36, 37, 38, 39, 40,
1357 -1, -1, -1, 44, -1, 46, -1, -1, -1, 50,
1358 51, 52, 53, -1, -1, -1, -1, -1, -1, -1,
1359 -1, -1, -1, -1, -1, -1, -1, -1, -1, 70,
1360 71, -1, 33, 34, 75, -1, 77, -1, -1, 40,
1361 -1, -1, -1, -1, 85, -1, -1, -1, -1, -1,
1362 -1, -1, -1, -1, 55, 96, 57, 98, 99, 60,
1363 -1, 62, -1, 64, 65, -1, 67, -1, -1, -1,
1364 -1, -1, -1, -1, 115, 76, -1, -1, -1, -1,
1365 121, -1, -1, 124, -1, -1, 87, 88, -1, 90,
1366 91, 92, -1, 94, 95, -1, -1, -1, -1, -1,
1367 -1, -1, -1, -1, -1, -1, 107, -1, 109, 110,
1368 -1, -1, -1, -1, -1, -1, -1, -1, -1, 120,
1369 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1370 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
1371 12, -1, 14, 15, 16, 17, 18, 19, 20, 21,
1372 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
1373 };
1374
1375 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1376 symbol of state STATE-NUM. */
1377 static const yytype_uint8 yystos[] =
1378 {
1379 0, 111, 112, 113, 114, 126, 127, 33, 34, 117,
1380 184, 185, 186, 192, 180, 192, 117, 181, 182, 183,
1381 0, 40, 55, 57, 60, 62, 64, 65, 67, 76,
1382 87, 88, 90, 91, 92, 94, 95, 107, 109, 110,
1383 120, 128, 132, 166, 176, 192, 33, 34, 57, 61,
1384 72, 188, 189, 186, 117, 3, 189, 183, 115, 115,
1385 115, 129, 192, 115, 117, 115, 115, 117, 115, 115,
1386 115, 117, 115, 117, 115, 119, 120, 193, 3, 4,
1387 5, 6, 7, 8, 9, 10, 11, 192, 13, 13,
1388 118, 120, 188, 177, 178, 120, 177, 192, 133, 134,
1389 115, 28, 41, 136, 137, 192, 167, 192, 192, 172,
1390 192, 192, 192, 130, 192, 131, 192, 177, 177, 177,
1391 177, 177, 177, 177, 177, 177, 117, 189, 189, 120,
1392 33, 34, 57, 118, 27, 28, 35, 36, 37, 38,
1393 39, 40, 44, 46, 50, 51, 52, 53, 70, 71,
1394 75, 77, 85, 96, 98, 99, 115, 121, 124, 179,
1395 192, 118, 119, 116, 116, 135, 192, 136, 33, 138,
1396 116, 119, 195, 118, 195, 116, 116, 119, 118, 173,
1397 192, 3, 3, 116, 139, 116, 184, 116, 190, 120,
1398 120, 192, 120, 187, 192, 179, 179, 115, 115, 115,
1399 115, 115, 115, 115, 115, 115, 115, 115, 115, 115,
1400 115, 115, 115, 115, 115, 179, 179, 179, 12, 14,
1401 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1402 25, 26, 27, 28, 29, 30, 31, 120, 192, 119,
1403 192, 116, 115, 137, 64, 168, 192, 192, 35, 174,
1404 192, 177, 177, 118, 140, 166, 192, 118, 189, 72,
1405 117, 120, 192, 179, 192, 179, 192, 179, 179, 192,
1406 179, 179, 179, 192, 192, 192, 179, 179, 192, 192,
1407 192, 116, 179, 179, 179, 179, 179, 179, 179, 179,
1408 179, 179, 179, 179, 179, 179, 179, 179, 179, 179,
1409 179, 116, 192, 136, 192, 115, 169, 119, 42, 90,
1410 175, 192, 116, 116, 142, 143, 120, 194, 13, 191,
1411 116, 116, 116, 119, 116, 119, 116, 116, 119, 116,
1412 119, 116, 116, 116, 119, 119, 116, 119, 116, 13,
1413 116, 121, 192, 13, 192, 115, 175, 120, 115, 175,
1414 141, 13, 115, 145, 179, 118, 189, 189, 179, 192,
1415 179, 179, 179, 179, 179, 179, 192, 116, 84, 85,
1416 122, 170, 116, 177, 35, 117, 48, 54, 66, 81,
1417 89, 116, 146, 42, 147, 13, 115, 120, 194, 116,
1418 116, 116, 116, 116, 116, 116, 116, 3, 116, 116,
1419 156, 13, 116, 115, 38, 148, 116, 146, 118, 177,
1420 175, 175, 12, 29, 40, 45, 47, 58, 64, 68,
1421 73, 93, 97, 101, 103, 118, 120, 157, 158, 159,
1422 160, 161, 165, 176, 192, 13, 179, 115, 105, 149,
1423 13, 116, 195, 115, 115, 192, 115, 115, 22, 151,
1424 152, 115, 115, 193, 116, 179, 115, 144, 13, 69,
1425 70, 123, 171, 177, 177, 101, 160, 192, 47, 165,
1426 192, 192, 42, 153, 177, 56, 100, 101, 162, 163,
1427 165, 116, 179, 82, 83, 102, 150, 3, 119, 116,
1428 115, 116, 116, 116, 22, 154, 116, 115, 115, 115,
1429 116, 195, 116, 177, 192, 192, 3, 13, 155, 164,
1430 165, 163, 163, 56, 163, 116, 177, 192, 195, 116,
1431 195, 116, 116, 115, 165, 164, 116
1432 };
1433
1434 #define yyerrok (yyerrstatus = 0)
1435 #define yyclearin (yychar = YYEMPTY)
1436 #define YYEMPTY (-2)
1437 #define YYEOF 0
1438
1439 #define YYACCEPT goto yyacceptlab
1440 #define YYABORT goto yyabortlab
1441 #define YYERROR goto yyerrorlab
1442
1443
1444 /* Like YYERROR except do call yyerror. This remains here temporarily
1445 to ease the transition to the new meaning of YYERROR, for GCC.
1446 Once GCC version 2 has supplanted version 1, this can go. However,
1447 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1448 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1449 discussed. */
1450
1451 #define YYFAIL goto yyerrlab
1452 #if defined YYFAIL
1453 /* This is here to suppress warnings from the GCC cpp's
1454 -Wunused-macros. Normally we don't worry about that warning, but
1455 some users do, and we want to make it easy for users to remove
1456 YYFAIL uses, which will produce warnings from Bison 2.5. */
1457 #endif
1458
1459 #define YYRECOVERING() (!!yyerrstatus)
1460
1461 #define YYBACKUP(Token, Value) \
1462 do \
1463 if (yychar == YYEMPTY) \
1464 { \
1465 yychar = (Token); \
1466 yylval = (Value); \
1467 YYPOPSTACK (yylen); \
1468 yystate = *yyssp; \
1469 goto yybackup; \
1470 } \
1471 else \
1472 { \
1473 yyerror (closure, YY_("syntax error: cannot back up")); \
1474 YYERROR; \
1475 } \
1476 while (YYID (0))
1477
1478 /* Error token number */
1479 #define YYTERROR 1
1480 #define YYERRCODE 256
1481
1482
1483 /* This macro is provided for backward compatibility. */
1484 #ifndef YY_LOCATION_PRINT
1485 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1486 #endif
1487
1488
1489 /* YYLEX -- calling `yylex' with the right arguments. */
1490 #ifdef YYLEX_PARAM
1491 # define YYLEX yylex (&yylval, YYLEX_PARAM)
1492 #else
1493 # define YYLEX yylex (&yylval, closure)
1494 #endif
1495
1496 /* Enable debugging if requested. */
1497 #if YYDEBUG
1498
1499 # ifndef YYFPRINTF
1500 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1501 # define YYFPRINTF fprintf
1502 # endif
1503
1504 # define YYDPRINTF(Args) \
1505 do { \
1506 if (yydebug) \
1507 YYFPRINTF Args; \
1508 } while (YYID (0))
1509
1510 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1511 do { \
1512 if (yydebug) \
1513 { \
1514 YYFPRINTF (stderr, "%s ", Title); \
1515 yy_symbol_print (stderr, \
1516 Type, Value, closure); \
1517 YYFPRINTF (stderr, "\n"); \
1518 } \
1519 } while (YYID (0))
1520
1521
1522 /*--------------------------------.
1523 | Print this symbol on YYOUTPUT. |
1524 `--------------------------------*/
1525
1526 /*ARGSUSED*/
1527 #if (defined __STDC__ || defined __C99__FUNC__ \
1528 || defined __cplusplus || defined _MSC_VER)
1529 static void
1530 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void* closure)
1531 #else
1532 static void
1533 yy_symbol_value_print (yyoutput, yytype, yyvaluep, closure)
1534 FILE *yyoutput;
1535 int yytype;
1536 YYSTYPE const * const yyvaluep;
1537 void* closure;
1538 #endif
1539 {
1540 FILE *yyo = yyoutput;
1541 YYUSE (yyo);
1542 if (!yyvaluep)
1543 return;
1544 YYUSE (closure);
1545 # ifdef YYPRINT
1546 if (yytype < YYNTOKENS)
1547 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1548 # else
1549 YYUSE (yyoutput);
1550 # endif
1551 YYUSE (yytype);
1552 }
1553
1554
1555 /*--------------------------------.
1556 | Print this symbol on YYOUTPUT. |
1557 `--------------------------------*/
1558
1559 #if (defined __STDC__ || defined __C99__FUNC__ \
1560 || defined __cplusplus || defined _MSC_VER)
1561 static void
1562 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void* closure)
1563 #else
1564 static void
1565 yy_symbol_print (yyoutput, yytype, yyvaluep, closure)
1566 FILE *yyoutput;
1567 int yytype;
1568 YYSTYPE const * const yyvaluep;
1569 void* closure;
1570 #endif
1571 {
1572 if (yytype < YYNTOKENS)
1573 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1574 else
1575 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1576
1577 yy_symbol_value_print (yyoutput, yytype, yyvaluep, closure);
1578 YYFPRINTF (yyoutput, ")");
1579 }
1580
1581 /*------------------------------------------------------------------.
1582 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1583 | TOP (included). |
1584 `------------------------------------------------------------------*/
1585
1586 #if (defined __STDC__ || defined __C99__FUNC__ \
1587 || defined __cplusplus || defined _MSC_VER)
1588 static void
1589 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1590 #else
1591 static void
1592 yy_stack_print (yybottom, yytop)
1593 yytype_int16 *yybottom;
1594 yytype_int16 *yytop;
1595 #endif
1596 {
1597 YYFPRINTF (stderr, "Stack now");
1598 for (; yybottom <= yytop; yybottom++)
1599 {
1600 int yybot = *yybottom;
1601 YYFPRINTF (stderr, " %d", yybot);
1602 }
1603 YYFPRINTF (stderr, "\n");
1604 }
1605
1606 # define YY_STACK_PRINT(Bottom, Top) \
1607 do { \
1608 if (yydebug) \
1609 yy_stack_print ((Bottom), (Top)); \
1610 } while (YYID (0))
1611
1612
1613 /*------------------------------------------------.
1614 | Report that the YYRULE is going to be reduced. |
1615 `------------------------------------------------*/
1616
1617 #if (defined __STDC__ || defined __C99__FUNC__ \
1618 || defined __cplusplus || defined _MSC_VER)
1619 static void
1620 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, void* closure)
1621 #else
1622 static void
1623 yy_reduce_print (yyvsp, yyrule, closure)
1624 YYSTYPE *yyvsp;
1625 int yyrule;
1626 void* closure;
1627 #endif
1628 {
1629 int yynrhs = yyr2[yyrule];
1630 int yyi;
1631 unsigned long int yylno = yyrline[yyrule];
1632 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1633 yyrule - 1, yylno);
1634 /* The symbols being reduced. */
1635 for (yyi = 0; yyi < yynrhs; yyi++)
1636 {
1637 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1638 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1639 &(yyvsp[(yyi + 1) - (yynrhs)])
1640 , closure);
1641 YYFPRINTF (stderr, "\n");
1642 }
1643 }
1644
1645 # define YY_REDUCE_PRINT(Rule) \
1646 do { \
1647 if (yydebug) \
1648 yy_reduce_print (yyvsp, Rule, closure); \
1649 } while (YYID (0))
1650
1651 /* Nonzero means print parse trace. It is left uninitialized so that
1652 multiple parsers can coexist. */
1653 int yydebug;
1654 #else /* !YYDEBUG */
1655 # define YYDPRINTF(Args)
1656 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1657 # define YY_STACK_PRINT(Bottom, Top)
1658 # define YY_REDUCE_PRINT(Rule)
1659 #endif /* !YYDEBUG */
1660
1661
1662 /* YYINITDEPTH -- initial size of the parser's stacks. */
1663 #ifndef YYINITDEPTH
1664 # define YYINITDEPTH 200
1665 #endif
1666
1667 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1668 if the built-in stack extension method is used).
1669
1670 Do not make this value too large; the results are undefined if
1671 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1672 evaluated with infinite-precision integer arithmetic. */
1673
1674 #ifndef YYMAXDEPTH
1675 # define YYMAXDEPTH 10000
1676 #endif
1677
1678
1679 #if YYERROR_VERBOSE
1680
1681 # ifndef yystrlen
1682 # if defined __GLIBC__ && defined _STRING_H
1683 # define yystrlen strlen
1684 # else
1685 /* Return the length of YYSTR. */
1686 #if (defined __STDC__ || defined __C99__FUNC__ \
1687 || defined __cplusplus || defined _MSC_VER)
1688 static YYSIZE_T
1689 yystrlen (const char *yystr)
1690 #else
1691 static YYSIZE_T
1692 yystrlen (yystr)
1693 const char *yystr;
1694 #endif
1695 {
1696 YYSIZE_T yylen;
1697 for (yylen = 0; yystr[yylen]; yylen++)
1698 continue;
1699 return yylen;
1700 }
1701 # endif
1702 # endif
1703
1704 # ifndef yystpcpy
1705 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1706 # define yystpcpy stpcpy
1707 # else
1708 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1709 YYDEST. */
1710 #if (defined __STDC__ || defined __C99__FUNC__ \
1711 || defined __cplusplus || defined _MSC_VER)
1712 static char *
1713 yystpcpy (char *yydest, const char *yysrc)
1714 #else
1715 static char *
1716 yystpcpy (yydest, yysrc)
1717 char *yydest;
1718 const char *yysrc;
1719 #endif
1720 {
1721 char *yyd = yydest;
1722 const char *yys = yysrc;
1723
1724 while ((*yyd++ = *yys++) != '\0')
1725 continue;
1726
1727 return yyd - 1;
1728 }
1729 # endif
1730 # endif
1731
1732 # ifndef yytnamerr
1733 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1734 quotes and backslashes, so that it's suitable for yyerror. The
1735 heuristic is that double-quoting is unnecessary unless the string
1736 contains an apostrophe, a comma, or backslash (other than
1737 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1738 null, do not copy; instead, return the length of what the result
1739 would have been. */
1740 static YYSIZE_T
1741 yytnamerr (char *yyres, const char *yystr)
1742 {
1743 if (*yystr == '"')
1744 {
1745 YYSIZE_T yyn = 0;
1746 char const *yyp = yystr;
1747
1748 for (;;)
1749 switch (*++yyp)
1750 {
1751 case '\'':
1752 case ',':
1753 goto do_not_strip_quotes;
1754
1755 case '\\':
1756 if (*++yyp != '\\')
1757 goto do_not_strip_quotes;
1758 /* Fall through. */
1759 default:
1760 if (yyres)
1761 yyres[yyn] = *yyp;
1762 yyn++;
1763 break;
1764
1765 case '"':
1766 if (yyres)
1767 yyres[yyn] = '\0';
1768 return yyn;
1769 }
1770 do_not_strip_quotes: ;
1771 }
1772
1773 if (! yyres)
1774 return yystrlen (yystr);
1775
1776 return yystpcpy (yyres, yystr) - yyres;
1777 }
1778 # endif
1779
1780 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1781 about the unexpected token YYTOKEN for the state stack whose top is
1782 YYSSP.
1783
1784 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1785 not large enough to hold the message. In that case, also set
1786 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1787 required number of bytes is too large to store. */
1788 static int
1789 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1790 yytype_int16 *yyssp, int yytoken)
1791 {
1792 YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1793 YYSIZE_T yysize = yysize0;
1794 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1795 /* Internationalized format string. */
1796 const char *yyformat = YY_NULL;
1797 /* Arguments of yyformat. */
1798 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1799 /* Number of reported tokens (one for the "unexpected", one per
1800 "expected"). */
1801 int yycount = 0;
1802
1803 /* There are many possibilities here to consider:
1804 - Assume YYFAIL is not used. It's too flawed to consider. See
1805 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1806 for details. YYERROR is fine as it does not invoke this
1807 function.
1808 - If this state is a consistent state with a default action, then
1809 the only way this function was invoked is if the default action
1810 is an error action. In that case, don't check for expected
1811 tokens because there are none.
1812 - The only way there can be no lookahead present (in yychar) is if
1813 this state is a consistent state with a default action. Thus,
1814 detecting the absence of a lookahead is sufficient to determine
1815 that there is no unexpected or expected token to report. In that
1816 case, just report a simple "syntax error".
1817 - Don't assume there isn't a lookahead just because this state is a
1818 consistent state with a default action. There might have been a
1819 previous inconsistent state, consistent state with a non-default
1820 action, or user semantic action that manipulated yychar.
1821 - Of course, the expected token list depends on states to have
1822 correct lookahead information, and it depends on the parser not
1823 to perform extra reductions after fetching a lookahead from the
1824 scanner and before detecting a syntax error. Thus, state merging
1825 (from LALR or IELR) and default reductions corrupt the expected
1826 token list. However, the list is correct for canonical LR with
1827 one exception: it will still contain any token that will not be
1828 accepted due to an error action in a later state.
1829 */
1830 if (yytoken != YYEMPTY)
1831 {
1832 int yyn = yypact[*yyssp];
1833 yyarg[yycount++] = yytname[yytoken];
1834 if (!yypact_value_is_default (yyn))
1835 {
1836 /* Start YYX at -YYN if negative to avoid negative indexes in
1837 YYCHECK. In other words, skip the first -YYN actions for
1838 this state because they are default actions. */
1839 int yyxbegin = yyn < 0 ? -yyn : 0;
1840 /* Stay within bounds of both yycheck and yytname. */
1841 int yychecklim = YYLAST - yyn + 1;
1842 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1843 int yyx;
1844
1845 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1846 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1847 && !yytable_value_is_error (yytable[yyx + yyn]))
1848 {
1849 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1850 {
1851 yycount = 1;
1852 yysize = yysize0;
1853 break;
1854 }
1855 yyarg[yycount++] = yytname[yyx];
1856 {
1857 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
1858 if (! (yysize <= yysize1
1859 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1860 return 2;
1861 yysize = yysize1;
1862 }
1863 }
1864 }
1865 }
1866
1867 switch (yycount)
1868 {
1869 # define YYCASE_(N, S) \
1870 case N: \
1871 yyformat = S; \
1872 break
1873 YYCASE_(0, YY_("syntax error"));
1874 YYCASE_(1, YY_("syntax error, unexpected %s"));
1875 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1876 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1877 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1878 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1879 # undef YYCASE_
1880 }
1881
1882 {
1883 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1884 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1885 return 2;
1886 yysize = yysize1;
1887 }
1888
1889 if (*yymsg_alloc < yysize)
1890 {
1891 *yymsg_alloc = 2 * yysize;
1892 if (! (yysize <= *yymsg_alloc
1893 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1894 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1895 return 1;
1896 }
1897
1898 /* Avoid sprintf, as that infringes on the user's name space.
1899 Don't have undefined behavior even if the translation
1900 produced a string with the wrong number of "%s"s. */
1901 {
1902 char *yyp = *yymsg;
1903 int yyi = 0;
1904 while ((*yyp = *yyformat) != '\0')
1905 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1906 {
1907 yyp += yytnamerr (yyp, yyarg[yyi++]);
1908 yyformat += 2;
1909 }
1910 else
1911 {
1912 yyp++;
1913 yyformat++;
1914 }
1915 }
1916 return 0;
1917 }
1918 #endif /* YYERROR_VERBOSE */
1919
1920 /*-----------------------------------------------.
1921 | Release the memory associated to this symbol. |
1922 `-----------------------------------------------*/
1923
1924 /*ARGSUSED*/
1925 #if (defined __STDC__ || defined __C99__FUNC__ \
1926 || defined __cplusplus || defined _MSC_VER)
1927 static void
1928 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, void* closure)
1929 #else
1930 static void
1931 yydestruct (yymsg, yytype, yyvaluep, closure)
1932 const char *yymsg;
1933 int yytype;
1934 YYSTYPE *yyvaluep;
1935 void* closure;
1936 #endif
1937 {
1938 YYUSE (yyvaluep);
1939 YYUSE (closure);
1940
1941 if (!yymsg)
1942 yymsg = "Deleting";
1943 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1944
1945 YYUSE (yytype);
1946 }
1947
1948
1949
1950
1951 /*----------.
1952 | yyparse. |
1953 `----------*/
1954
1955 #ifdef YYPARSE_PARAM
1956 #if (defined __STDC__ || defined __C99__FUNC__ \
1957 || defined __cplusplus || defined _MSC_VER)
1958 int
1959 yyparse (void *YYPARSE_PARAM)
1960 #else
1961 int
1962 yyparse (YYPARSE_PARAM)
1963 void *YYPARSE_PARAM;
1964 #endif
1965 #else /* ! YYPARSE_PARAM */
1966 #if (defined __STDC__ || defined __C99__FUNC__ \
1967 || defined __cplusplus || defined _MSC_VER)
1968 int
1969 yyparse (void* closure)
1970 #else
1971 int
1972 yyparse (closure)
1973 void* closure;
1974 #endif
1975 #endif
1976 {
1977 /* The lookahead symbol. */
1978 int yychar;
1979
1980
1981 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
1982 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
1983 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
1984 _Pragma ("GCC diagnostic push") \
1985 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
1986 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
1987 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
1988 _Pragma ("GCC diagnostic pop")
1989 #else
1990 /* Default value used for initialization, for pacifying older GCCs
1991 or non-GCC compilers. */
1992 static YYSTYPE yyval_default;
1993 # define YY_INITIAL_VALUE(Value) = Value
1994 #endif
1995 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1996 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1997 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
1998 #endif
1999 #ifndef YY_INITIAL_VALUE
2000 # define YY_INITIAL_VALUE(Value) /* Nothing. */
2001 #endif
2002
2003 /* The semantic value of the lookahead symbol. */
2004 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
2005
2006 /* Number of syntax errors so far. */
2007 int yynerrs;
2008
2009 int yystate;
2010 /* Number of tokens to shift before error messages enabled. */
2011 int yyerrstatus;
2012
2013 /* The stacks and their tools:
2014 `yyss': related to states.
2015 `yyvs': related to semantic values.
2016
2017 Refer to the stacks through separate pointers, to allow yyoverflow
2018 to reallocate them elsewhere. */
2019
2020 /* The state stack. */
2021 yytype_int16 yyssa[YYINITDEPTH];
2022 yytype_int16 *yyss;
2023 yytype_int16 *yyssp;
2024
2025 /* The semantic value stack. */
2026 YYSTYPE yyvsa[YYINITDEPTH];
2027 YYSTYPE *yyvs;
2028 YYSTYPE *yyvsp;
2029
2030 YYSIZE_T yystacksize;
2031
2032 int yyn;
2033 int yyresult;
2034 /* Lookahead token as an internal (translated) token number. */
2035 int yytoken = 0;
2036 /* The variables used to return semantic value and location from the
2037 action routines. */
2038 YYSTYPE yyval;
2039
2040 #if YYERROR_VERBOSE
2041 /* Buffer for error messages, and its allocated size. */
2042 char yymsgbuf[128];
2043 char *yymsg = yymsgbuf;
2044 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2045 #endif
2046
2047 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2048
2049 /* The number of symbols on the RHS of the reduced rule.
2050 Keep to zero when no symbol should be popped. */
2051 int yylen = 0;
2052
2053 yyssp = yyss = yyssa;
2054 yyvsp = yyvs = yyvsa;
2055 yystacksize = YYINITDEPTH;
2056
2057 YYDPRINTF ((stderr, "Starting parse\n"));
2058
2059 yystate = 0;
2060 yyerrstatus = 0;
2061 yynerrs = 0;
2062 yychar = YYEMPTY; /* Cause a token to be read. */
2063 goto yysetstate;
2064
2065 /*------------------------------------------------------------.
2066 | yynewstate -- Push a new state, which is found in yystate. |
2067 `------------------------------------------------------------*/
2068 yynewstate:
2069 /* In all cases, when you get here, the value and location stacks
2070 have just been pushed. So pushing a state here evens the stacks. */
2071 yyssp++;
2072
2073 yysetstate:
2074 *yyssp = yystate;
2075
2076 if (yyss + yystacksize - 1 <= yyssp)
2077 {
2078 /* Get the current used size of the three stacks, in elements. */
2079 YYSIZE_T yysize = yyssp - yyss + 1;
2080
2081 #ifdef yyoverflow
2082 {
2083 /* Give user a chance to reallocate the stack. Use copies of
2084 these so that the &'s don't force the real ones into
2085 memory. */
2086 YYSTYPE *yyvs1 = yyvs;
2087 yytype_int16 *yyss1 = yyss;
2088
2089 /* Each stack pointer address is followed by the size of the
2090 data in use in that stack, in bytes. This used to be a
2091 conditional around just the two extra args, but that might
2092 be undefined if yyoverflow is a macro. */
2093 yyoverflow (YY_("memory exhausted"),
2094 &yyss1, yysize * sizeof (*yyssp),
2095 &yyvs1, yysize * sizeof (*yyvsp),
2096 &yystacksize);
2097
2098 yyss = yyss1;
2099 yyvs = yyvs1;
2100 }
2101 #else /* no yyoverflow */
2102 # ifndef YYSTACK_RELOCATE
2103 goto yyexhaustedlab;
2104 # else
2105 /* Extend the stack our own way. */
2106 if (YYMAXDEPTH <= yystacksize)
2107 goto yyexhaustedlab;
2108 yystacksize *= 2;
2109 if (YYMAXDEPTH < yystacksize)
2110 yystacksize = YYMAXDEPTH;
2111
2112 {
2113 yytype_int16 *yyss1 = yyss;
2114 union yyalloc *yyptr =
2115 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2116 if (! yyptr)
2117 goto yyexhaustedlab;
2118 YYSTACK_RELOCATE (yyss_alloc, yyss);
2119 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2120 # undef YYSTACK_RELOCATE
2121 if (yyss1 != yyssa)
2122 YYSTACK_FREE (yyss1);
2123 }
2124 # endif
2125 #endif /* no yyoverflow */
2126
2127 yyssp = yyss + yysize - 1;
2128 yyvsp = yyvs + yysize - 1;
2129
2130 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2131 (unsigned long int) yystacksize));
2132
2133 if (yyss + yystacksize - 1 <= yyssp)
2134 YYABORT;
2135 }
2136
2137 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2138
2139 if (yystate == YYFINAL)
2140 YYACCEPT;
2141
2142 goto yybackup;
2143
2144 /*-----------.
2145 | yybackup. |
2146 `-----------*/
2147 yybackup:
2148
2149 /* Do appropriate processing given the current state. Read a
2150 lookahead token if we need one and don't already have one. */
2151
2152 /* First try to decide what to do without reference to lookahead token. */
2153 yyn = yypact[yystate];
2154 if (yypact_value_is_default (yyn))
2155 goto yydefault;
2156
2157 /* Not known => get a lookahead token if don't already have one. */
2158
2159 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2160 if (yychar == YYEMPTY)
2161 {
2162 YYDPRINTF ((stderr, "Reading a token: "));
2163 yychar = YYLEX;
2164 }
2165
2166 if (yychar <= YYEOF)
2167 {
2168 yychar = yytoken = YYEOF;
2169 YYDPRINTF ((stderr, "Now at end of input.\n"));
2170 }
2171 else
2172 {
2173 yytoken = YYTRANSLATE (yychar);
2174 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2175 }
2176
2177 /* If the proper action on seeing token YYTOKEN is to reduce or to
2178 detect an error, take that action. */
2179 yyn += yytoken;
2180 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2181 goto yydefault;
2182 yyn = yytable[yyn];
2183 if (yyn <= 0)
2184 {
2185 if (yytable_value_is_error (yyn))
2186 goto yyerrlab;
2187 yyn = -yyn;
2188 goto yyreduce;
2189 }
2190
2191 /* Count tokens shifted since error; after three, turn off error
2192 status. */
2193 if (yyerrstatus)
2194 yyerrstatus--;
2195
2196 /* Shift the lookahead token. */
2197 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2198
2199 /* Discard the shifted token. */
2200 yychar = YYEMPTY;
2201
2202 yystate = yyn;
2203 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2204 *++yyvsp = yylval;
2205 YY_IGNORE_MAYBE_UNINITIALIZED_END
2206
2207 goto yynewstate;
2208
2209
2210 /*-----------------------------------------------------------.
2211 | yydefault -- do the default action for the current state. |
2212 `-----------------------------------------------------------*/
2213 yydefault:
2214 yyn = yydefact[yystate];
2215 if (yyn == 0)
2216 goto yyerrlab;
2217 goto yyreduce;
2218
2219
2220 /*-----------------------------.
2221 | yyreduce -- Do a reduction. |
2222 `-----------------------------*/
2223 yyreduce:
2224 /* yyn is the number of a rule to reduce with. */
2225 yylen = yyr2[yyn];
2226
2227 /* If YYLEN is nonzero, implement the default value of the action:
2228 `$$ = $1'.
2229
2230 Otherwise, the following line sets YYVAL to garbage.
2231 This behavior is undocumented and Bison
2232 users should not rely upon it. Assigning to YYVAL
2233 unconditionally makes the parser a bit smaller, and it avoids a
2234 GCC warning that YYVAL may be used uninitialized. */
2235 yyval = yyvsp[1-yylen];
2236
2237
2238 YY_REDUCE_PRINT (yyn);
2239 switch (yyn)
2240 {
2241 case 9:
2242 /* Line 1787 of yacc.c */
2243 #line 247 "yyscript.y"
2244 { script_set_common_allocation(closure, 1); }
2245 break;
2246
2247 case 10:
2248 /* Line 1787 of yacc.c */
2249 #line 249 "yyscript.y"
2250 { script_start_group(closure); }
2251 break;
2252
2253 case 11:
2254 /* Line 1787 of yacc.c */
2255 #line 251 "yyscript.y"
2256 { script_end_group(closure); }
2257 break;
2258
2259 case 12:
2260 /* Line 1787 of yacc.c */
2261 #line 253 "yyscript.y"
2262 { script_set_common_allocation(closure, 0); }
2263 break;
2264
2265 case 15:
2266 /* Line 1787 of yacc.c */
2267 #line 257 "yyscript.y"
2268 { script_parse_option(closure, (yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
2269 break;
2270
2271 case 16:
2272 /* Line 1787 of yacc.c */
2273 #line 259 "yyscript.y"
2274 {
2275 if (!script_check_output_format(closure, (yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length,
2276 NULL, 0, NULL, 0))
2277 YYABORT;
2278 }
2279 break;
2280
2281 case 17:
2282 /* Line 1787 of yacc.c */
2283 #line 265 "yyscript.y"
2284 {
2285 if (!script_check_output_format(closure, (yyvsp[(3) - (8)].string).value, (yyvsp[(3) - (8)].string).length,
2286 (yyvsp[(5) - (8)].string).value, (yyvsp[(5) - (8)].string).length,
2287 (yyvsp[(7) - (8)].string).value, (yyvsp[(7) - (8)].string).length))
2288 YYABORT;
2289 }
2290 break;
2291
2292 case 19:
2293 /* Line 1787 of yacc.c */
2294 #line 273 "yyscript.y"
2295 { script_add_search_dir(closure, (yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
2296 break;
2297
2298 case 20:
2299 /* Line 1787 of yacc.c */
2300 #line 275 "yyscript.y"
2301 { script_start_sections(closure); }
2302 break;
2303
2304 case 21:
2305 /* Line 1787 of yacc.c */
2306 #line 277 "yyscript.y"
2307 { script_finish_sections(closure); }
2308 break;
2309
2310 case 22:
2311 /* Line 1787 of yacc.c */
2312 #line 279 "yyscript.y"
2313 { script_set_target(closure, (yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
2314 break;
2315
2316 case 23:
2317 /* Line 1787 of yacc.c */
2318 #line 281 "yyscript.y"
2319 { script_push_lex_into_version_mode(closure); }
2320 break;
2321
2322 case 24:
2323 /* Line 1787 of yacc.c */
2324 #line 283 "yyscript.y"
2325 { script_pop_lex_mode(closure); }
2326 break;
2327
2328 case 29:
2329 /* Line 1787 of yacc.c */
2330 #line 302 "yyscript.y"
2331 { script_push_lex_into_expression_mode(closure); }
2332 break;
2333
2334 case 30:
2335 /* Line 1787 of yacc.c */
2336 #line 304 "yyscript.y"
2337 { script_pop_lex_mode(closure); }
2338 break;
2339
2340 case 31:
2341 /* Line 1787 of yacc.c */
2342 #line 309 "yyscript.y"
2343 { script_add_extern(closure, (yyvsp[(1) - (1)].string).value, (yyvsp[(1) - (1)].string).length); }
2344 break;
2345
2346 case 32:
2347 /* Line 1787 of yacc.c */
2348 #line 311 "yyscript.y"
2349 { script_add_extern(closure, (yyvsp[(2) - (2)].string).value, (yyvsp[(2) - (2)].string).length); }
2350 break;
2351
2352 case 33:
2353 /* Line 1787 of yacc.c */
2354 #line 313 "yyscript.y"
2355 { script_add_extern(closure, (yyvsp[(3) - (3)].string).value, (yyvsp[(3) - (3)].string).length); }
2356 break;
2357
2358 case 36:
2359 /* Line 1787 of yacc.c */
2360 #line 325 "yyscript.y"
2361 { script_add_file(closure, (yyvsp[(1) - (1)].string).value, (yyvsp[(1) - (1)].string).length); }
2362 break;
2363
2364 case 37:
2365 /* Line 1787 of yacc.c */
2366 #line 327 "yyscript.y"
2367 { script_add_library(closure, (yyvsp[(2) - (2)].string).value, (yyvsp[(2) - (2)].string).length); }
2368 break;
2369
2370 case 38:
2371 /* Line 1787 of yacc.c */
2372 #line 329 "yyscript.y"
2373 { script_start_as_needed(closure); }
2374 break;
2375
2376 case 39:
2377 /* Line 1787 of yacc.c */
2378 #line 331 "yyscript.y"
2379 { script_end_as_needed(closure); }
2380 break;
2381
2382 case 43:
2383 /* Line 1787 of yacc.c */
2384 #line 344 "yyscript.y"
2385 { script_start_output_section(closure, (yyvsp[(1) - (2)].string).value, (yyvsp[(1) - (2)].string).length, &(yyvsp[(2) - (2)].output_section_header)); }
2386 break;
2387
2388 case 44:
2389 /* Line 1787 of yacc.c */
2390 #line 346 "yyscript.y"
2391 { script_finish_output_section(closure, &(yyvsp[(7) - (7)].output_section_trailer)); }
2392 break;
2393
2394 case 45:
2395 /* Line 1787 of yacc.c */
2396 #line 352 "yyscript.y"
2397 { script_push_lex_into_expression_mode(closure); }
2398 break;
2399
2400 case 46:
2401 /* Line 1787 of yacc.c */
2402 #line 354 "yyscript.y"
2403 { script_pop_lex_mode(closure); }
2404 break;
2405
2406 case 47:
2407 /* Line 1787 of yacc.c */
2408 #line 356 "yyscript.y"
2409 {
2410 (yyval.output_section_header).address = (yyvsp[(2) - (7)].output_section_header).address;
2411 (yyval.output_section_header).section_type = (yyvsp[(2) - (7)].output_section_header).section_type;
2412 (yyval.output_section_header).load_address = (yyvsp[(3) - (7)].expr);
2413 (yyval.output_section_header).align = (yyvsp[(4) - (7)].expr);
2414 (yyval.output_section_header).subalign = (yyvsp[(5) - (7)].expr);
2415 (yyval.output_section_header).constraint = (yyvsp[(7) - (7)].constraint);
2416 }
2417 break;
2418
2419 case 48:
2420 /* Line 1787 of yacc.c */
2421 #line 372 "yyscript.y"
2422 {
2423 (yyval.output_section_header).address = NULL;
2424 (yyval.output_section_header).section_type = SCRIPT_SECTION_TYPE_NONE;
2425 }
2426 break;
2427
2428 case 49:
2429 /* Line 1787 of yacc.c */
2430 #line 377 "yyscript.y"
2431 {
2432 (yyval.output_section_header).address = NULL;
2433 (yyval.output_section_header).section_type = SCRIPT_SECTION_TYPE_NONE;
2434 }
2435 break;
2436
2437 case 50:
2438 /* Line 1787 of yacc.c */
2439 #line 382 "yyscript.y"
2440 {
2441 (yyval.output_section_header).address = (yyvsp[(1) - (2)].expr);
2442 (yyval.output_section_header).section_type = SCRIPT_SECTION_TYPE_NONE;
2443 }
2444 break;
2445
2446 case 51:
2447 /* Line 1787 of yacc.c */
2448 #line 387 "yyscript.y"
2449 {
2450 (yyval.output_section_header).address = (yyvsp[(1) - (4)].expr);
2451 (yyval.output_section_header).section_type = SCRIPT_SECTION_TYPE_NONE;
2452 }
2453 break;
2454
2455 case 52:
2456 /* Line 1787 of yacc.c */
2457 #line 392 "yyscript.y"
2458 {
2459 (yyval.output_section_header).address = NULL;
2460 (yyval.output_section_header).section_type = (yyvsp[(2) - (4)].section_type);
2461 }
2462 break;
2463
2464 case 53:
2465 /* Line 1787 of yacc.c */
2466 #line 397 "yyscript.y"
2467 {
2468 (yyval.output_section_header).address = (yyvsp[(1) - (5)].expr);
2469 (yyval.output_section_header).section_type = (yyvsp[(3) - (5)].section_type);
2470 }
2471 break;
2472
2473 case 54:
2474 /* Line 1787 of yacc.c */
2475 #line 406 "yyscript.y"
2476 { (yyval.section_type) = SCRIPT_SECTION_TYPE_NOLOAD; }
2477 break;
2478
2479 case 55:
2480 /* Line 1787 of yacc.c */
2481 #line 408 "yyscript.y"
2482 {
2483 yyerror(closure, "DSECT section type is unsupported");
2484 (yyval.section_type) = SCRIPT_SECTION_TYPE_DSECT;
2485 }
2486 break;
2487
2488 case 56:
2489 /* Line 1787 of yacc.c */
2490 #line 413 "yyscript.y"
2491 {
2492 yyerror(closure, "COPY section type is unsupported");
2493 (yyval.section_type) = SCRIPT_SECTION_TYPE_COPY;
2494 }
2495 break;
2496
2497 case 57:
2498 /* Line 1787 of yacc.c */
2499 #line 418 "yyscript.y"
2500 {
2501 yyerror(closure, "INFO section type is unsupported");
2502 (yyval.section_type) = SCRIPT_SECTION_TYPE_INFO;
2503 }
2504 break;
2505
2506 case 58:
2507 /* Line 1787 of yacc.c */
2508 #line 423 "yyscript.y"
2509 {
2510 yyerror(closure, "OVERLAY section type is unsupported");
2511 (yyval.section_type) = SCRIPT_SECTION_TYPE_OVERLAY;
2512 }
2513 break;
2514
2515 case 59:
2516 /* Line 1787 of yacc.c */
2517 #line 432 "yyscript.y"
2518 { (yyval.expr) = NULL; }
2519 break;
2520
2521 case 60:
2522 /* Line 1787 of yacc.c */
2523 #line 434 "yyscript.y"
2524 { (yyval.expr) = (yyvsp[(3) - (4)].expr); }
2525 break;
2526
2527 case 61:
2528 /* Line 1787 of yacc.c */
2529 #line 440 "yyscript.y"
2530 { (yyval.expr) = NULL; }
2531 break;
2532
2533 case 62:
2534 /* Line 1787 of yacc.c */
2535 #line 442 "yyscript.y"
2536 { (yyval.expr) = (yyvsp[(3) - (4)].expr); }
2537 break;
2538
2539 case 63:
2540 /* Line 1787 of yacc.c */
2541 #line 448 "yyscript.y"
2542 { (yyval.expr) = NULL; }
2543 break;
2544
2545 case 64:
2546 /* Line 1787 of yacc.c */
2547 #line 450 "yyscript.y"
2548 { (yyval.expr) = (yyvsp[(3) - (4)].expr); }
2549 break;
2550
2551 case 65:
2552 /* Line 1787 of yacc.c */
2553 #line 456 "yyscript.y"
2554 { (yyval.constraint) = CONSTRAINT_NONE; }
2555 break;
2556
2557 case 66:
2558 /* Line 1787 of yacc.c */
2559 #line 458 "yyscript.y"
2560 { (yyval.constraint) = CONSTRAINT_ONLY_IF_RO; }
2561 break;
2562
2563 case 67:
2564 /* Line 1787 of yacc.c */
2565 #line 460 "yyscript.y"
2566 { (yyval.constraint) = CONSTRAINT_ONLY_IF_RW; }
2567 break;
2568
2569 case 68:
2570 /* Line 1787 of yacc.c */
2571 #line 462 "yyscript.y"
2572 { (yyval.constraint) = CONSTRAINT_SPECIAL; }
2573 break;
2574
2575 case 69:
2576 /* Line 1787 of yacc.c */
2577 #line 468 "yyscript.y"
2578 {
2579 (yyval.output_section_trailer).fill = (yyvsp[(4) - (5)].expr);
2580 (yyval.output_section_trailer).phdrs = (yyvsp[(3) - (5)].string_list);
2581 }
2582 break;
2583
2584 case 70:
2585 /* Line 1787 of yacc.c */
2586 #line 477 "yyscript.y"
2587 { script_set_section_region(closure, (yyvsp[(2) - (2)].string).value, (yyvsp[(2) - (2)].string).length, 1); }
2588 break;
2589
2590 case 72:
2591 /* Line 1787 of yacc.c */
2592 #line 484 "yyscript.y"
2593 { script_set_section_region(closure, (yyvsp[(3) - (3)].string).value, (yyvsp[(3) - (3)].string).length, 0); }
2594 break;
2595
2596 case 74:
2597 /* Line 1787 of yacc.c */
2598 #line 491 "yyscript.y"
2599 { (yyval.string_list) = script_string_list_push_back((yyvsp[(1) - (3)].string_list), (yyvsp[(3) - (3)].string).value, (yyvsp[(3) - (3)].string).length); }
2600 break;
2601
2602 case 75:
2603 /* Line 1787 of yacc.c */
2604 #line 493 "yyscript.y"
2605 { (yyval.string_list) = NULL; }
2606 break;
2607
2608 case 76:
2609 /* Line 1787 of yacc.c */
2610 #line 500 "yyscript.y"
2611 { (yyval.expr) = (yyvsp[(2) - (2)].expr); }
2612 break;
2613
2614 case 77:
2615 /* Line 1787 of yacc.c */
2616 #line 502 "yyscript.y"
2617 { (yyval.expr) = NULL; }
2618 break;
2619
2620 case 82:
2621 /* Line 1787 of yacc.c */
2622 #line 518 "yyscript.y"
2623 { script_add_data(closure, (yyvsp[(1) - (4)].integer), (yyvsp[(3) - (4)].expr)); }
2624 break;
2625
2626 case 83:
2627 /* Line 1787 of yacc.c */
2628 #line 520 "yyscript.y"
2629 { script_add_assertion(closure, (yyvsp[(3) - (6)].expr), (yyvsp[(5) - (6)].string).value, (yyvsp[(5) - (6)].string).length); }
2630 break;
2631
2632 case 84:
2633 /* Line 1787 of yacc.c */
2634 #line 522 "yyscript.y"
2635 { script_add_fill(closure, (yyvsp[(3) - (4)].expr)); }
2636 break;
2637
2638 case 85:
2639 /* Line 1787 of yacc.c */
2640 #line 524 "yyscript.y"
2641 {
2642 /* The GNU linker uses CONSTRUCTORS for the a.out object
2643 file format. It does nothing when using ELF. Since
2644 some ELF linker scripts use it although it does
2645 nothing, we accept it and ignore it. */
2646 }
2647 break;
2648
2649 case 87:
2650 /* Line 1787 of yacc.c */
2651 #line 532 "yyscript.y"
2652 { script_include_directive(closure, (yyvsp[(2) - (2)].string).value, (yyvsp[(2) - (2)].string).length); }
2653 break;
2654
2655 case 89:
2656 /* Line 1787 of yacc.c */
2657 #line 540 "yyscript.y"
2658 { (yyval.integer) = QUAD; }
2659 break;
2660
2661 case 90:
2662 /* Line 1787 of yacc.c */
2663 #line 542 "yyscript.y"
2664 { (yyval.integer) = SQUAD; }
2665 break;
2666
2667 case 91:
2668 /* Line 1787 of yacc.c */
2669 #line 544 "yyscript.y"
2670 { (yyval.integer) = LONG; }
2671 break;
2672
2673 case 92:
2674 /* Line 1787 of yacc.c */
2675 #line 546 "yyscript.y"
2676 { (yyval.integer) = SHORT; }
2677 break;
2678
2679 case 93:
2680 /* Line 1787 of yacc.c */
2681 #line 548 "yyscript.y"
2682 { (yyval.integer) = BYTE; }
2683 break;
2684
2685 case 94:
2686 /* Line 1787 of yacc.c */
2687 #line 555 "yyscript.y"
2688 { script_add_input_section(closure, &(yyvsp[(1) - (1)].input_section_spec), 0); }
2689 break;
2690
2691 case 95:
2692 /* Line 1787 of yacc.c */
2693 #line 557 "yyscript.y"
2694 { script_add_input_section(closure, &(yyvsp[(3) - (4)].input_section_spec), 1); }
2695 break;
2696
2697 case 96:
2698 /* Line 1787 of yacc.c */
2699 #line 563 "yyscript.y"
2700 {
2701 (yyval.input_section_spec).file.name = (yyvsp[(1) - (1)].string);
2702 (yyval.input_section_spec).file.sort = SORT_WILDCARD_NONE;
2703 (yyval.input_section_spec).input_sections.sections = NULL;
2704 (yyval.input_section_spec).input_sections.exclude = NULL;
2705 }
2706 break;
2707
2708 case 97:
2709 /* Line 1787 of yacc.c */
2710 #line 570 "yyscript.y"
2711 {
2712 (yyval.input_section_spec).file = (yyvsp[(1) - (4)].wildcard_section);
2713 (yyval.input_section_spec).input_sections = (yyvsp[(3) - (4)].wildcard_sections);
2714 }
2715 break;
2716
2717 case 98:
2718 /* Line 1787 of yacc.c */
2719 #line 579 "yyscript.y"
2720 {
2721 (yyval.wildcard_section).name = (yyvsp[(1) - (1)].string);
2722 (yyval.wildcard_section).sort = SORT_WILDCARD_NONE;
2723 }
2724 break;
2725
2726 case 99:
2727 /* Line 1787 of yacc.c */
2728 #line 584 "yyscript.y"
2729 {
2730 (yyval.wildcard_section).name = (yyvsp[(3) - (4)].string);
2731 (yyval.wildcard_section).sort = SORT_WILDCARD_BY_NAME;
2732 }
2733 break;
2734
2735 case 100:
2736 /* Line 1787 of yacc.c */
2737 #line 593 "yyscript.y"
2738 {
2739 (yyval.wildcard_sections).sections = script_string_sort_list_add((yyvsp[(1) - (3)].wildcard_sections).sections, &(yyvsp[(3) - (3)].wildcard_section));
2740 (yyval.wildcard_sections).exclude = (yyvsp[(1) - (3)].wildcard_sections).exclude;
2741 }
2742 break;
2743
2744 case 101:
2745 /* Line 1787 of yacc.c */
2746 #line 598 "yyscript.y"
2747 {
2748 (yyval.wildcard_sections).sections = script_new_string_sort_list(&(yyvsp[(1) - (1)].wildcard_section));
2749 (yyval.wildcard_sections).exclude = NULL;
2750 }
2751 break;
2752
2753 case 102:
2754 /* Line 1787 of yacc.c */
2755 #line 603 "yyscript.y"
2756 {
2757 (yyval.wildcard_sections).sections = (yyvsp[(1) - (6)].wildcard_sections).sections;
2758 (yyval.wildcard_sections).exclude = script_string_list_append((yyvsp[(1) - (6)].wildcard_sections).exclude, (yyvsp[(5) - (6)].string_list));
2759 }
2760 break;
2761
2762 case 103:
2763 /* Line 1787 of yacc.c */
2764 #line 608 "yyscript.y"
2765 {
2766 (yyval.wildcard_sections).sections = NULL;
2767 (yyval.wildcard_sections).exclude = (yyvsp[(3) - (4)].string_list);
2768 }
2769 break;
2770
2771 case 104:
2772 /* Line 1787 of yacc.c */
2773 #line 617 "yyscript.y"
2774 {
2775 (yyval.wildcard_section).name = (yyvsp[(1) - (1)].string);
2776 (yyval.wildcard_section).sort = SORT_WILDCARD_NONE;
2777 }
2778 break;
2779
2780 case 105:
2781 /* Line 1787 of yacc.c */
2782 #line 622 "yyscript.y"
2783 {
2784 (yyval.wildcard_section).name = (yyvsp[(3) - (4)].wildcard_section).name;
2785 switch ((yyvsp[(3) - (4)].wildcard_section).sort)
2786 {
2787 case SORT_WILDCARD_NONE:
2788 (yyval.wildcard_section).sort = SORT_WILDCARD_BY_NAME;
2789 break;
2790 case SORT_WILDCARD_BY_NAME:
2791 case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
2792 break;
2793 case SORT_WILDCARD_BY_ALIGNMENT:
2794 case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
2795 (yyval.wildcard_section).sort = SORT_WILDCARD_BY_NAME_BY_ALIGNMENT;
2796 break;
2797 default:
2798 abort();
2799 }
2800 }
2801 break;
2802
2803 case 106:
2804 /* Line 1787 of yacc.c */
2805 #line 641 "yyscript.y"
2806 {
2807 (yyval.wildcard_section).name = (yyvsp[(3) - (4)].wildcard_section).name;
2808 switch ((yyvsp[(3) - (4)].wildcard_section).sort)
2809 {
2810 case SORT_WILDCARD_NONE:
2811 (yyval.wildcard_section).sort = SORT_WILDCARD_BY_ALIGNMENT;
2812 break;
2813 case SORT_WILDCARD_BY_ALIGNMENT:
2814 case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
2815 break;
2816 case SORT_WILDCARD_BY_NAME:
2817 case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
2818 (yyval.wildcard_section).sort = SORT_WILDCARD_BY_ALIGNMENT_BY_NAME;
2819 break;
2820 default:
2821 abort();
2822 }
2823 }
2824 break;
2825
2826 case 107:
2827 /* Line 1787 of yacc.c */
2828 #line 664 "yyscript.y"
2829 { (yyval.string_list) = script_string_list_push_back((yyvsp[(1) - (3)].string_list), (yyvsp[(3) - (3)].string).value, (yyvsp[(3) - (3)].string).length); }
2830 break;
2831
2832 case 108:
2833 /* Line 1787 of yacc.c */
2834 #line 666 "yyscript.y"
2835 { (yyval.string_list) = script_new_string_list((yyvsp[(1) - (1)].string).value, (yyvsp[(1) - (1)].string).length); }
2836 break;
2837
2838 case 109:
2839 /* Line 1787 of yacc.c */
2840 #line 673 "yyscript.y"
2841 { (yyval.string) = (yyvsp[(1) - (1)].string); }
2842 break;
2843
2844 case 110:
2845 /* Line 1787 of yacc.c */
2846 #line 675 "yyscript.y"
2847 {
2848 (yyval.string).value = "*";
2849 (yyval.string).length = 1;
2850 }
2851 break;
2852
2853 case 111:
2854 /* Line 1787 of yacc.c */
2855 #line 680 "yyscript.y"
2856 {
2857 (yyval.string).value = "?";
2858 (yyval.string).length = 1;
2859 }
2860 break;
2861
2862 case 112:
2863 /* Line 1787 of yacc.c */
2864 #line 690 "yyscript.y"
2865 { script_set_entry(closure, (yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
2866 break;
2867
2868 case 114:
2869 /* Line 1787 of yacc.c */
2870 #line 693 "yyscript.y"
2871 { script_add_assertion(closure, (yyvsp[(3) - (6)].expr), (yyvsp[(5) - (6)].string).value, (yyvsp[(5) - (6)].string).length); }
2872 break;
2873
2874 case 115:
2875 /* Line 1787 of yacc.c */
2876 #line 695 "yyscript.y"
2877 { script_include_directive(closure, (yyvsp[(2) - (2)].string).value, (yyvsp[(2) - (2)].string).length); }
2878 break;
2879
2880 case 118:
2881 /* Line 1787 of yacc.c */
2882 #line 707 "yyscript.y"
2883 { script_add_memory(closure, (yyvsp[(1) - (10)].string).value, (yyvsp[(1) - (10)].string).length, (yyvsp[(2) - (10)].integer), (yyvsp[(6) - (10)].expr), (yyvsp[(10) - (10)].expr)); }
2884 break;
2885
2886 case 119:
2887 /* Line 1787 of yacc.c */
2888 #line 711 "yyscript.y"
2889 { script_include_directive(closure, (yyvsp[(2) - (2)].string).value, (yyvsp[(2) - (2)].string).length); }
2890 break;
2891
2892 case 121:
2893 /* Line 1787 of yacc.c */
2894 #line 718 "yyscript.y"
2895 { (yyval.integer) = script_parse_memory_attr(closure, (yyvsp[(2) - (3)].string).value, (yyvsp[(2) - (3)].string).length, 0); }
2896 break;
2897
2898 case 122:
2899 /* Line 1787 of yacc.c */
2900 #line 721 "yyscript.y"
2901 { (yyval.integer) = script_parse_memory_attr(closure, (yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length, 1); }
2902 break;
2903
2904 case 123:
2905 /* Line 1787 of yacc.c */
2906 #line 723 "yyscript.y"
2907 { (yyval.integer) = 0; }
2908 break;
2909
2910 case 132:
2911 /* Line 1787 of yacc.c */
2912 #line 751 "yyscript.y"
2913 { script_add_phdr(closure, (yyvsp[(1) - (4)].string).value, (yyvsp[(1) - (4)].string).length, (yyvsp[(2) - (4)].integer), &(yyvsp[(3) - (4)].phdr_info)); }
2914 break;
2915
2916 case 133:
2917 /* Line 1787 of yacc.c */
2918 #line 760 "yyscript.y"
2919 { (yyval.integer) = script_phdr_string_to_type(closure, (yyvsp[(1) - (1)].string).value, (yyvsp[(1) - (1)].string).length); }
2920 break;
2921
2922 case 134:
2923 /* Line 1787 of yacc.c */
2924 #line 762 "yyscript.y"
2925 { (yyval.integer) = (yyvsp[(1) - (1)].integer); }
2926 break;
2927
2928 case 135:
2929 /* Line 1787 of yacc.c */
2930 #line 768 "yyscript.y"
2931 { memset(&(yyval.phdr_info), 0, sizeof(struct Phdr_info)); }
2932 break;
2933
2934 case 136:
2935 /* Line 1787 of yacc.c */
2936 #line 770 "yyscript.y"
2937 {
2938 (yyval.phdr_info) = (yyvsp[(2) - (2)].phdr_info);
2939 if ((yyvsp[(1) - (2)].string).length == 7 && strncmp((yyvsp[(1) - (2)].string).value, "FILEHDR", 7) == 0)
2940 (yyval.phdr_info).includes_filehdr = 1;
2941 else
2942 yyerror(closure, "PHDRS syntax error");
2943 }
2944 break;
2945
2946 case 137:
2947 /* Line 1787 of yacc.c */
2948 #line 778 "yyscript.y"
2949 {
2950 (yyval.phdr_info) = (yyvsp[(2) - (2)].phdr_info);
2951 (yyval.phdr_info).includes_phdrs = 1;
2952 }
2953 break;
2954
2955 case 138:
2956 /* Line 1787 of yacc.c */
2957 #line 783 "yyscript.y"
2958 {
2959 (yyval.phdr_info) = (yyvsp[(5) - (5)].phdr_info);
2960 if ((yyvsp[(1) - (5)].string).length == 5 && strncmp((yyvsp[(1) - (5)].string).value, "FLAGS", 5) == 0)
2961 {
2962 (yyval.phdr_info).is_flags_valid = 1;
2963 (yyval.phdr_info).flags = (yyvsp[(3) - (5)].integer);
2964 }
2965 else
2966 yyerror(closure, "PHDRS syntax error");
2967 }
2968 break;
2969
2970 case 139:
2971 /* Line 1787 of yacc.c */
2972 #line 794 "yyscript.y"
2973 {
2974 (yyval.phdr_info) = (yyvsp[(5) - (5)].phdr_info);
2975 (yyval.phdr_info).load_address = (yyvsp[(3) - (5)].expr);
2976 }
2977 break;
2978
2979 case 140:
2980 /* Line 1787 of yacc.c */
2981 #line 803 "yyscript.y"
2982 { script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, (yyvsp[(3) - (3)].expr), 0, 0); }
2983 break;
2984
2985 case 141:
2986 /* Line 1787 of yacc.c */
2987 #line 805 "yyscript.y"
2988 {
2989 Expression_ptr s = script_exp_string((yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length);
2990 Expression_ptr e = script_exp_binary_add(s, (yyvsp[(3) - (3)].expr));
2991 script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, e, 0, 0);
2992 }
2993 break;
2994
2995 case 142:
2996 /* Line 1787 of yacc.c */
2997 #line 811 "yyscript.y"
2998 {
2999 Expression_ptr s = script_exp_string((yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length);
3000 Expression_ptr e = script_exp_binary_sub(s, (yyvsp[(3) - (3)].expr));
3001 script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, e, 0, 0);
3002 }
3003 break;
3004
3005 case 143:
3006 /* Line 1787 of yacc.c */
3007 #line 817 "yyscript.y"
3008 {
3009 Expression_ptr s = script_exp_string((yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length);
3010 Expression_ptr e = script_exp_binary_mult(s, (yyvsp[(3) - (3)].expr));
3011 script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, e, 0, 0);
3012 }
3013 break;
3014
3015 case 144:
3016 /* Line 1787 of yacc.c */
3017 #line 823 "yyscript.y"
3018 {
3019 Expression_ptr s = script_exp_string((yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length);
3020 Expression_ptr e = script_exp_binary_div(s, (yyvsp[(3) - (3)].expr));
3021 script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, e, 0, 0);
3022 }
3023 break;
3024
3025 case 145:
3026 /* Line 1787 of yacc.c */
3027 #line 829 "yyscript.y"
3028 {
3029 Expression_ptr s = script_exp_string((yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length);
3030 Expression_ptr e = script_exp_binary_lshift(s, (yyvsp[(3) - (3)].expr));
3031 script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, e, 0, 0);
3032 }
3033 break;
3034
3035 case 146:
3036 /* Line 1787 of yacc.c */
3037 #line 835 "yyscript.y"
3038 {
3039 Expression_ptr s = script_exp_string((yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length);
3040 Expression_ptr e = script_exp_binary_rshift(s, (yyvsp[(3) - (3)].expr));
3041 script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, e, 0, 0);
3042 }
3043 break;
3044
3045 case 147:
3046 /* Line 1787 of yacc.c */
3047 #line 841 "yyscript.y"
3048 {
3049 Expression_ptr s = script_exp_string((yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length);
3050 Expression_ptr e = script_exp_binary_bitwise_and(s, (yyvsp[(3) - (3)].expr));
3051 script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, e, 0, 0);
3052 }
3053 break;
3054
3055 case 148:
3056 /* Line 1787 of yacc.c */
3057 #line 847 "yyscript.y"
3058 {
3059 Expression_ptr s = script_exp_string((yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length);
3060 Expression_ptr e = script_exp_binary_bitwise_or(s, (yyvsp[(3) - (3)].expr));
3061 script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, e, 0, 0);
3062 }
3063 break;
3064
3065 case 149:
3066 /* Line 1787 of yacc.c */
3067 #line 853 "yyscript.y"
3068 { script_set_symbol(closure, (yyvsp[(3) - (6)].string).value, (yyvsp[(3) - (6)].string).length, (yyvsp[(5) - (6)].expr), 1, 0); }
3069 break;
3070
3071 case 150:
3072 /* Line 1787 of yacc.c */
3073 #line 855 "yyscript.y"
3074 { script_set_symbol(closure, (yyvsp[(3) - (6)].string).value, (yyvsp[(3) - (6)].string).length, (yyvsp[(5) - (6)].expr), 1, 1); }
3075 break;
3076
3077 case 151:
3078 /* Line 1787 of yacc.c */
3079 #line 860 "yyscript.y"
3080 { script_push_lex_into_expression_mode(closure); }
3081 break;
3082
3083 case 152:
3084 /* Line 1787 of yacc.c */
3085 #line 862 "yyscript.y"
3086 {
3087 script_pop_lex_mode(closure);
3088 (yyval.expr) = (yyvsp[(2) - (2)].expr);
3089 }
3090 break;
3091
3092 case 153:
3093 /* Line 1787 of yacc.c */
3094 #line 871 "yyscript.y"
3095 { (yyval.expr) = (yyvsp[(2) - (3)].expr); }
3096 break;
3097
3098 case 154:
3099 /* Line 1787 of yacc.c */
3100 #line 873 "yyscript.y"
3101 { (yyval.expr) = script_exp_unary_minus((yyvsp[(2) - (2)].expr)); }
3102 break;
3103
3104 case 155:
3105 /* Line 1787 of yacc.c */
3106 #line 875 "yyscript.y"
3107 { (yyval.expr) = script_exp_unary_logical_not((yyvsp[(2) - (2)].expr)); }
3108 break;
3109
3110 case 156:
3111 /* Line 1787 of yacc.c */
3112 #line 877 "yyscript.y"
3113 { (yyval.expr) = script_exp_unary_bitwise_not((yyvsp[(2) - (2)].expr)); }
3114 break;
3115
3116 case 157:
3117 /* Line 1787 of yacc.c */
3118 #line 879 "yyscript.y"
3119 { (yyval.expr) = (yyvsp[(2) - (2)].expr); }
3120 break;
3121
3122 case 158:
3123 /* Line 1787 of yacc.c */
3124 #line 881 "yyscript.y"
3125 { (yyval.expr) = script_exp_binary_mult((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3126 break;
3127
3128 case 159:
3129 /* Line 1787 of yacc.c */
3130 #line 883 "yyscript.y"
3131 { (yyval.expr) = script_exp_binary_div((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3132 break;
3133
3134 case 160:
3135 /* Line 1787 of yacc.c */
3136 #line 885 "yyscript.y"
3137 { (yyval.expr) = script_exp_binary_mod((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3138 break;
3139
3140 case 161:
3141 /* Line 1787 of yacc.c */
3142 #line 887 "yyscript.y"
3143 { (yyval.expr) = script_exp_binary_add((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3144 break;
3145
3146 case 162:
3147 /* Line 1787 of yacc.c */
3148 #line 889 "yyscript.y"
3149 { (yyval.expr) = script_exp_binary_sub((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3150 break;
3151
3152 case 163:
3153 /* Line 1787 of yacc.c */
3154 #line 891 "yyscript.y"
3155 { (yyval.expr) = script_exp_binary_lshift((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3156 break;
3157
3158 case 164:
3159 /* Line 1787 of yacc.c */
3160 #line 893 "yyscript.y"
3161 { (yyval.expr) = script_exp_binary_rshift((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3162 break;
3163
3164 case 165:
3165 /* Line 1787 of yacc.c */
3166 #line 895 "yyscript.y"
3167 { (yyval.expr) = script_exp_binary_eq((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3168 break;
3169
3170 case 166:
3171 /* Line 1787 of yacc.c */
3172 #line 897 "yyscript.y"
3173 { (yyval.expr) = script_exp_binary_ne((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3174 break;
3175
3176 case 167:
3177 /* Line 1787 of yacc.c */
3178 #line 899 "yyscript.y"
3179 { (yyval.expr) = script_exp_binary_le((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3180 break;
3181
3182 case 168:
3183 /* Line 1787 of yacc.c */
3184 #line 901 "yyscript.y"
3185 { (yyval.expr) = script_exp_binary_ge((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3186 break;
3187
3188 case 169:
3189 /* Line 1787 of yacc.c */
3190 #line 903 "yyscript.y"
3191 { (yyval.expr) = script_exp_binary_lt((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3192 break;
3193
3194 case 170:
3195 /* Line 1787 of yacc.c */
3196 #line 905 "yyscript.y"
3197 { (yyval.expr) = script_exp_binary_gt((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3198 break;
3199
3200 case 171:
3201 /* Line 1787 of yacc.c */
3202 #line 907 "yyscript.y"
3203 { (yyval.expr) = script_exp_binary_bitwise_and((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3204 break;
3205
3206 case 172:
3207 /* Line 1787 of yacc.c */
3208 #line 909 "yyscript.y"
3209 { (yyval.expr) = script_exp_binary_bitwise_xor((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3210 break;
3211
3212 case 173:
3213 /* Line 1787 of yacc.c */
3214 #line 911 "yyscript.y"
3215 { (yyval.expr) = script_exp_binary_bitwise_or((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3216 break;
3217
3218 case 174:
3219 /* Line 1787 of yacc.c */
3220 #line 913 "yyscript.y"
3221 { (yyval.expr) = script_exp_binary_logical_and((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3222 break;
3223
3224 case 175:
3225 /* Line 1787 of yacc.c */
3226 #line 915 "yyscript.y"
3227 { (yyval.expr) = script_exp_binary_logical_or((yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr)); }
3228 break;
3229
3230 case 176:
3231 /* Line 1787 of yacc.c */
3232 #line 917 "yyscript.y"
3233 { (yyval.expr) = script_exp_trinary_cond((yyvsp[(1) - (5)].expr), (yyvsp[(3) - (5)].expr), (yyvsp[(5) - (5)].expr)); }
3234 break;
3235
3236 case 177:
3237 /* Line 1787 of yacc.c */
3238 #line 919 "yyscript.y"
3239 { (yyval.expr) = script_exp_integer((yyvsp[(1) - (1)].integer)); }
3240 break;
3241
3242 case 178:
3243 /* Line 1787 of yacc.c */
3244 #line 921 "yyscript.y"
3245 { (yyval.expr) = script_symbol(closure, (yyvsp[(1) - (1)].string).value, (yyvsp[(1) - (1)].string).length); }
3246 break;
3247
3248 case 179:
3249 /* Line 1787 of yacc.c */
3250 #line 923 "yyscript.y"
3251 { (yyval.expr) = script_exp_function_max((yyvsp[(3) - (6)].expr), (yyvsp[(5) - (6)].expr)); }
3252 break;
3253
3254 case 180:
3255 /* Line 1787 of yacc.c */
3256 #line 925 "yyscript.y"
3257 { (yyval.expr) = script_exp_function_min((yyvsp[(3) - (6)].expr), (yyvsp[(5) - (6)].expr)); }
3258 break;
3259
3260 case 181:
3261 /* Line 1787 of yacc.c */
3262 #line 927 "yyscript.y"
3263 { (yyval.expr) = script_exp_function_defined((yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
3264 break;
3265
3266 case 182:
3267 /* Line 1787 of yacc.c */
3268 #line 929 "yyscript.y"
3269 { (yyval.expr) = script_exp_function_sizeof_headers(); }
3270 break;
3271
3272 case 183:
3273 /* Line 1787 of yacc.c */
3274 #line 931 "yyscript.y"
3275 { (yyval.expr) = script_exp_function_alignof((yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
3276 break;
3277
3278 case 184:
3279 /* Line 1787 of yacc.c */
3280 #line 933 "yyscript.y"
3281 { (yyval.expr) = script_exp_function_sizeof((yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
3282 break;
3283
3284 case 185:
3285 /* Line 1787 of yacc.c */
3286 #line 935 "yyscript.y"
3287 { (yyval.expr) = script_exp_function_addr((yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
3288 break;
3289
3290 case 186:
3291 /* Line 1787 of yacc.c */
3292 #line 937 "yyscript.y"
3293 { (yyval.expr) = script_exp_function_loadaddr((yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
3294 break;
3295
3296 case 187:
3297 /* Line 1787 of yacc.c */
3298 #line 939 "yyscript.y"
3299 { (yyval.expr) = script_exp_function_origin(closure, (yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
3300 break;
3301
3302 case 188:
3303 /* Line 1787 of yacc.c */
3304 #line 941 "yyscript.y"
3305 { (yyval.expr) = script_exp_function_length(closure, (yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
3306 break;
3307
3308 case 189:
3309 /* Line 1787 of yacc.c */
3310 #line 943 "yyscript.y"
3311 { (yyval.expr) = script_exp_function_constant((yyvsp[(3) - (4)].string).value, (yyvsp[(3) - (4)].string).length); }
3312 break;
3313
3314 case 190:
3315 /* Line 1787 of yacc.c */
3316 #line 945 "yyscript.y"
3317 { (yyval.expr) = script_exp_function_absolute((yyvsp[(3) - (4)].expr)); }
3318 break;
3319
3320 case 191:
3321 /* Line 1787 of yacc.c */
3322 #line 947 "yyscript.y"
3323 { (yyval.expr) = script_exp_function_align(script_exp_string(".", 1), (yyvsp[(3) - (4)].expr)); }
3324 break;
3325
3326 case 192:
3327 /* Line 1787 of yacc.c */
3328 #line 949 "yyscript.y"
3329 { (yyval.expr) = script_exp_function_align((yyvsp[(3) - (6)].expr), (yyvsp[(5) - (6)].expr)); }
3330 break;
3331
3332 case 193:
3333 /* Line 1787 of yacc.c */
3334 #line 951 "yyscript.y"
3335 { (yyval.expr) = script_exp_function_align(script_exp_string(".", 1), (yyvsp[(3) - (4)].expr)); }
3336 break;
3337
3338 case 194:
3339 /* Line 1787 of yacc.c */
3340 #line 953 "yyscript.y"
3341 {
3342 script_data_segment_align(closure);
3343 (yyval.expr) = script_exp_function_data_segment_align((yyvsp[(3) - (6)].expr), (yyvsp[(5) - (6)].expr));
3344 }
3345 break;
3346
3347 case 195:
3348 /* Line 1787 of yacc.c */
3349 #line 958 "yyscript.y"
3350 {
3351 script_data_segment_relro_end(closure);
3352 (yyval.expr) = script_exp_function_data_segment_relro_end((yyvsp[(3) - (6)].expr), (yyvsp[(5) - (6)].expr));
3353 }
3354 break;
3355
3356 case 196:
3357 /* Line 1787 of yacc.c */
3358 #line 963 "yyscript.y"
3359 { (yyval.expr) = script_exp_function_data_segment_end((yyvsp[(3) - (4)].expr)); }
3360 break;
3361
3362 case 197:
3363 /* Line 1787 of yacc.c */
3364 #line 965 "yyscript.y"
3365 {
3366 (yyval.expr) = script_exp_function_segment_start((yyvsp[(3) - (6)].string).value, (yyvsp[(3) - (6)].string).length, (yyvsp[(5) - (6)].expr));
3367 /* We need to take note of any SEGMENT_START expressions
3368 because they change the behaviour of -Ttext, -Tdata and
3369 -Tbss options. */
3370 script_saw_segment_start_expression(closure);
3371 }
3372 break;
3373
3374 case 198:
3375 /* Line 1787 of yacc.c */
3376 #line 973 "yyscript.y"
3377 { (yyval.expr) = script_exp_function_assert((yyvsp[(3) - (6)].expr), (yyvsp[(5) - (6)].string).value, (yyvsp[(5) - (6)].string).length); }
3378 break;
3379
3380 case 199:
3381 /* Line 1787 of yacc.c */
3382 #line 979 "yyscript.y"
3383 { script_set_symbol(closure, (yyvsp[(1) - (3)].string).value, (yyvsp[(1) - (3)].string).length, (yyvsp[(3) - (3)].expr), 0, 0); }
3384 break;
3385
3386 case 203:
3387 /* Line 1787 of yacc.c */
3388 #line 997 "yyscript.y"
3389 { script_new_vers_node (closure, NULL, (yyvsp[(2) - (5)].versyms)); }
3390 break;
3391
3392 case 207:
3393 /* Line 1787 of yacc.c */
3394 #line 1012 "yyscript.y"
3395 {
3396 script_register_vers_node (closure, NULL, 0, (yyvsp[(2) - (4)].versnode), NULL);
3397 }
3398 break;
3399
3400 case 208:
3401 /* Line 1787 of yacc.c */
3402 #line 1016 "yyscript.y"
3403 {
3404 script_register_vers_node (closure, (yyvsp[(1) - (5)].string).value, (yyvsp[(1) - (5)].string).length, (yyvsp[(3) - (5)].versnode),
3405 NULL);
3406 }
3407 break;
3408
3409 case 209:
3410 /* Line 1787 of yacc.c */
3411 #line 1021 "yyscript.y"
3412 {
3413 script_register_vers_node (closure, (yyvsp[(1) - (6)].string).value, (yyvsp[(1) - (6)].string).length, (yyvsp[(3) - (6)].versnode), (yyvsp[(5) - (6)].deplist));
3414 }
3415 break;
3416
3417 case 210:
3418 /* Line 1787 of yacc.c */
3419 #line 1028 "yyscript.y"
3420 {
3421 (yyval.deplist) = script_add_vers_depend (closure, NULL, (yyvsp[(1) - (1)].string).value, (yyvsp[(1) - (1)].string).length);
3422 }
3423 break;
3424
3425 case 211:
3426 /* Line 1787 of yacc.c */
3427 #line 1032 "yyscript.y"
3428 {
3429 (yyval.deplist) = script_add_vers_depend (closure, (yyvsp[(1) - (2)].deplist), (yyvsp[(2) - (2)].string).value, (yyvsp[(2) - (2)].string).length);
3430 }
3431 break;
3432
3433 case 212:
3434 /* Line 1787 of yacc.c */
3435 #line 1039 "yyscript.y"
3436 { (yyval.versnode) = script_new_vers_node (closure, NULL, NULL); }
3437 break;
3438
3439 case 213:
3440 /* Line 1787 of yacc.c */
3441 #line 1041 "yyscript.y"
3442 { (yyval.versnode) = script_new_vers_node (closure, (yyvsp[(1) - (2)].versyms), NULL); }
3443 break;
3444
3445 case 214:
3446 /* Line 1787 of yacc.c */
3447 #line 1043 "yyscript.y"
3448 { (yyval.versnode) = script_new_vers_node (closure, (yyvsp[(3) - (4)].versyms), NULL); }
3449 break;
3450
3451 case 215:
3452 /* Line 1787 of yacc.c */
3453 #line 1045 "yyscript.y"
3454 { (yyval.versnode) = script_new_vers_node (closure, NULL, (yyvsp[(3) - (4)].versyms)); }
3455 break;
3456
3457 case 216:
3458 /* Line 1787 of yacc.c */
3459 #line 1047 "yyscript.y"
3460 { (yyval.versnode) = script_new_vers_node (closure, (yyvsp[(3) - (8)].versyms), (yyvsp[(7) - (8)].versyms)); }
3461 break;
3462
3463 case 217:
3464 /* Line 1787 of yacc.c */
3465 #line 1056 "yyscript.y"
3466 {
3467 (yyval.versyms) = script_new_vers_pattern (closure, NULL, (yyvsp[(1) - (1)].string).value,
3468 (yyvsp[(1) - (1)].string).length, 0);
3469 }
3470 break;
3471
3472 case 218:
3473 /* Line 1787 of yacc.c */
3474 #line 1061 "yyscript.y"
3475 {
3476 (yyval.versyms) = script_new_vers_pattern (closure, NULL, (yyvsp[(1) - (1)].string).value,
3477 (yyvsp[(1) - (1)].string).length, 1);
3478 }
3479 break;
3480
3481 case 219:
3482 /* Line 1787 of yacc.c */
3483 #line 1066 "yyscript.y"
3484 {
3485 (yyval.versyms) = script_new_vers_pattern (closure, (yyvsp[(1) - (3)].versyms), (yyvsp[(3) - (3)].string).value,
3486 (yyvsp[(3) - (3)].string).length, 0);
3487 }
3488 break;
3489
3490 case 220:
3491 /* Line 1787 of yacc.c */
3492 #line 1071 "yyscript.y"
3493 {
3494 (yyval.versyms) = script_new_vers_pattern (closure, (yyvsp[(1) - (3)].versyms), (yyvsp[(3) - (3)].string).value,
3495 (yyvsp[(3) - (3)].string).length, 1);
3496 }
3497 break;
3498
3499 case 221:
3500 /* Line 1787 of yacc.c */
3501 #line 1077 "yyscript.y"
3502 { version_script_push_lang (closure, (yyvsp[(2) - (3)].string).value, (yyvsp[(2) - (3)].string).length); }
3503 break;
3504
3505 case 222:
3506 /* Line 1787 of yacc.c */
3507 #line 1079 "yyscript.y"
3508 {
3509 (yyval.versyms) = (yyvsp[(5) - (7)].versyms);
3510 version_script_pop_lang(closure);
3511 }
3512 break;
3513
3514 case 223:
3515 /* Line 1787 of yacc.c */
3516 #line 1087 "yyscript.y"
3517 { version_script_push_lang (closure, (yyvsp[(4) - (5)].string).value, (yyvsp[(4) - (5)].string).length); }
3518 break;
3519
3520 case 224:
3521 /* Line 1787 of yacc.c */
3522 #line 1089 "yyscript.y"
3523 {
3524 (yyval.versyms) = script_merge_expressions ((yyvsp[(1) - (9)].versyms), (yyvsp[(7) - (9)].versyms));
3525 version_script_pop_lang(closure);
3526 }
3527 break;
3528
3529 case 225:
3530 /* Line 1787 of yacc.c */
3531 #line 1094 "yyscript.y"
3532 {
3533 (yyval.versyms) = script_new_vers_pattern (closure, NULL, "extern",
3534 sizeof("extern") - 1, 1);
3535 }
3536 break;
3537
3538 case 226:
3539 /* Line 1787 of yacc.c */
3540 #line 1099 "yyscript.y"
3541 {
3542 (yyval.versyms) = script_new_vers_pattern (closure, (yyvsp[(1) - (3)].versyms), "extern",
3543 sizeof("extern") - 1, 1);
3544 }
3545 break;
3546
3547 case 227:
3548 /* Line 1787 of yacc.c */
3549 #line 1109 "yyscript.y"
3550 { (yyval.string) = (yyvsp[(1) - (1)].string); }
3551 break;
3552
3553 case 228:
3554 /* Line 1787 of yacc.c */
3555 #line 1111 "yyscript.y"
3556 { (yyval.string) = (yyvsp[(1) - (1)].string); }
3557 break;
3558
3559
3560 /* Line 1787 of yacc.c */
3561 #line 3562 "yyscript.c"
3562 default: break;
3563 }
3564 /* User semantic actions sometimes alter yychar, and that requires
3565 that yytoken be updated with the new translation. We take the
3566 approach of translating immediately before every use of yytoken.
3567 One alternative is translating here after every semantic action,
3568 but that translation would be missed if the semantic action invokes
3569 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
3570 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
3571 incorrect destructor might then be invoked immediately. In the
3572 case of YYERROR or YYBACKUP, subsequent parser actions might lead
3573 to an incorrect destructor call or verbose syntax error message
3574 before the lookahead is translated. */
3575 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3576
3577 YYPOPSTACK (yylen);
3578 yylen = 0;
3579 YY_STACK_PRINT (yyss, yyssp);
3580
3581 *++yyvsp = yyval;
3582
3583 /* Now `shift' the result of the reduction. Determine what state
3584 that goes to, based on the state we popped back to and the rule
3585 number reduced by. */
3586
3587 yyn = yyr1[yyn];
3588
3589 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3590 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3591 yystate = yytable[yystate];
3592 else
3593 yystate = yydefgoto[yyn - YYNTOKENS];
3594
3595 goto yynewstate;
3596
3597
3598 /*------------------------------------.
3599 | yyerrlab -- here on detecting error |
3600 `------------------------------------*/
3601 yyerrlab:
3602 /* Make sure we have latest lookahead translation. See comments at
3603 user semantic actions for why this is necessary. */
3604 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
3605
3606 /* If not already recovering from an error, report this error. */
3607 if (!yyerrstatus)
3608 {
3609 ++yynerrs;
3610 #if ! YYERROR_VERBOSE
3611 yyerror (closure, YY_("syntax error"));
3612 #else
3613 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
3614 yyssp, yytoken)
3615 {
3616 char const *yymsgp = YY_("syntax error");
3617 int yysyntax_error_status;
3618 yysyntax_error_status = YYSYNTAX_ERROR;
3619 if (yysyntax_error_status == 0)
3620 yymsgp = yymsg;
3621 else if (yysyntax_error_status == 1)
3622 {
3623 if (yymsg != yymsgbuf)
3624 YYSTACK_FREE (yymsg);
3625 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
3626 if (!yymsg)
3627 {
3628 yymsg = yymsgbuf;
3629 yymsg_alloc = sizeof yymsgbuf;
3630 yysyntax_error_status = 2;
3631 }
3632 else
3633 {
3634 yysyntax_error_status = YYSYNTAX_ERROR;
3635 yymsgp = yymsg;
3636 }
3637 }
3638 yyerror (closure, yymsgp);
3639 if (yysyntax_error_status == 2)
3640 goto yyexhaustedlab;
3641 }
3642 # undef YYSYNTAX_ERROR
3643 #endif
3644 }
3645
3646
3647
3648 if (yyerrstatus == 3)
3649 {
3650 /* If just tried and failed to reuse lookahead token after an
3651 error, discard it. */
3652
3653 if (yychar <= YYEOF)
3654 {
3655 /* Return failure if at end of input. */
3656 if (yychar == YYEOF)
3657 YYABORT;
3658 }
3659 else
3660 {
3661 yydestruct ("Error: discarding",
3662 yytoken, &yylval, closure);
3663 yychar = YYEMPTY;
3664 }
3665 }
3666
3667 /* Else will try to reuse lookahead token after shifting the error
3668 token. */
3669 goto yyerrlab1;
3670
3671
3672 /*---------------------------------------------------.
3673 | yyerrorlab -- error raised explicitly by YYERROR. |
3674 `---------------------------------------------------*/
3675 yyerrorlab:
3676
3677 /* Pacify compilers like GCC when the user code never invokes
3678 YYERROR and the label yyerrorlab therefore never appears in user
3679 code. */
3680 if (/*CONSTCOND*/ 0)
3681 goto yyerrorlab;
3682
3683 /* Do not reclaim the symbols of the rule which action triggered
3684 this YYERROR. */
3685 YYPOPSTACK (yylen);
3686 yylen = 0;
3687 YY_STACK_PRINT (yyss, yyssp);
3688 yystate = *yyssp;
3689 goto yyerrlab1;
3690
3691
3692 /*-------------------------------------------------------------.
3693 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3694 `-------------------------------------------------------------*/
3695 yyerrlab1:
3696 yyerrstatus = 3; /* Each real token shifted decrements this. */
3697
3698 for (;;)
3699 {
3700 yyn = yypact[yystate];
3701 if (!yypact_value_is_default (yyn))
3702 {
3703 yyn += YYTERROR;
3704 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3705 {
3706 yyn = yytable[yyn];
3707 if (0 < yyn)
3708 break;
3709 }
3710 }
3711
3712 /* Pop the current state because it cannot handle the error token. */
3713 if (yyssp == yyss)
3714 YYABORT;
3715
3716
3717 yydestruct ("Error: popping",
3718 yystos[yystate], yyvsp, closure);
3719 YYPOPSTACK (1);
3720 yystate = *yyssp;
3721 YY_STACK_PRINT (yyss, yyssp);
3722 }
3723
3724 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3725 *++yyvsp = yylval;
3726 YY_IGNORE_MAYBE_UNINITIALIZED_END
3727
3728
3729 /* Shift the error token. */
3730 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3731
3732 yystate = yyn;
3733 goto yynewstate;
3734
3735
3736 /*-------------------------------------.
3737 | yyacceptlab -- YYACCEPT comes here. |
3738 `-------------------------------------*/
3739 yyacceptlab:
3740 yyresult = 0;
3741 goto yyreturn;
3742
3743 /*-----------------------------------.
3744 | yyabortlab -- YYABORT comes here. |
3745 `-----------------------------------*/
3746 yyabortlab:
3747 yyresult = 1;
3748 goto yyreturn;
3749
3750 #if !defined yyoverflow || YYERROR_VERBOSE
3751 /*-------------------------------------------------.
3752 | yyexhaustedlab -- memory exhaustion comes here. |
3753 `-------------------------------------------------*/
3754 yyexhaustedlab:
3755 yyerror (closure, YY_("memory exhausted"));
3756 yyresult = 2;
3757 /* Fall through. */
3758 #endif
3759
3760 yyreturn:
3761 if (yychar != YYEMPTY)
3762 {
3763 /* Make sure we have latest lookahead translation. See comments at
3764 user semantic actions for why this is necessary. */
3765 yytoken = YYTRANSLATE (yychar);
3766 yydestruct ("Cleanup: discarding lookahead",
3767 yytoken, &yylval, closure);
3768 }
3769 /* Do not reclaim the symbols of the rule which action triggered
3770 this YYABORT or YYACCEPT. */
3771 YYPOPSTACK (yylen);
3772 YY_STACK_PRINT (yyss, yyssp);
3773 while (yyssp != yyss)
3774 {
3775 yydestruct ("Cleanup: popping",
3776 yystos[*yyssp], yyvsp, closure);
3777 YYPOPSTACK (1);
3778 }
3779 #ifndef yyoverflow
3780 if (yyss != yyssa)
3781 YYSTACK_FREE (yyss);
3782 #endif
3783 #if YYERROR_VERBOSE
3784 if (yymsg != yymsgbuf)
3785 YYSTACK_FREE (yymsg);
3786 #endif
3787 /* Make sure YYID is used. */
3788 return YYID (yyresult);
3789 }
3790
3791
3792 /* Line 2050 of yacc.c */
3793 #line 1133 "yyscript.y"
3794
DragonFly BSD