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