1 /* A Bison parser, made by GNU Bison 2.6.5.63-3ada. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36 /* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43 /* Identify Bison output. */
44 #define YYBISON 1
45
46 /* Bison version. */
47 #define YYBISON_VERSION "2.6.5.63-3ada"
48
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51
52 /* Pure parsers. */
53 #define YYPURE 1
54
55 /* Push parsers. */
56 #define YYPUSH 0
57
58 /* Pull parsers. */
59 #define YYPULL 1
60
61 /* Substitute the type names. */
62 #define YYSTYPE GRAM_STYPE
63 #define YYLTYPE GRAM_LTYPE
64 /* Substitute the variable and function names. */
65 #define yyparse gram_parse
66 #define yylex gram_lex
67 #define yyerror gram_error
68 #define yylval gram_lval
69 #define yychar gram_char
70 #define yydebug gram_debug
71 #define yynerrs gram_nerrs
72 #define yylloc gram_lloc
73
74 /* Copy the first part of user declarations. */
75 /* Line 360 of yacc.c */
76 #line 1 "parse-gram.y"
77 /* Bison Grammar Parser -*- C -*-
78
79 Copyright (C) 2002-2012 Free Software Foundation, Inc.
80
81 This file is part of Bison, the GNU Compiler Compiler.
82
83 This program is free software: you can redistribute it and/or modify
84 it under the terms of the GNU General Public License as published by
85 the Free Software Foundation, either version 3 of the License, or
86 (at your option) any later version.
87
88 This program is distributed in the hope that it will be useful,
89 but WITHOUT ANY WARRANTY; without even the implied warranty of
90 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
91 GNU General Public License for more details.
92
93 You should have received a copy of the GNU General Public License
94 along with this program. If not, see <http://www.gnu.org/licenses/>. */
95
96 #include <config.h>
97 #include "system.h"
98
99 #include "c-ctype.h"
100 #include "complain.h"
101 #include "conflicts.h"
102 #include "files.h"
103 #include "getargs.h"
104 #include "gram.h"
105 #include "muscle-tab.h"
106 #include "named-ref.h"
107 #include "quotearg.h"
108 #include "reader.h"
109 #include "symlist.h"
110 #include "scan-gram.h"
111 #include "scan-code.h"
112 #include "xmemdup0.h"
113
114 #define YYLLOC_DEFAULT(Current, Rhs, N) (Current) = lloc_default (Rhs, N)
115 static YYLTYPE lloc_default (YYLTYPE const *, int);
116
117 #define YY_LOCATION_PRINT(File, Loc) \
118 location_print (File, Loc)
119
120 static void version_check (location const *loc, char const *version);
121
122 /* Request detailed syntax error messages, and pass them to GRAM_ERROR.
123 FIXME: depends on the undocumented availability of YYLLOC. */
124 #undef yyerror
125 #define yyerror(Msg) \
126 gram_error (&yylloc, Msg)
127 static void gram_error (location const *, char const *);
128
129 static char const *char_name (char);
130
131 /** Add a lex-param or a parse-param.
132 *
133 * \param type \a lex_param or \a parse_param
134 * \param decl the formal argument
135 * \param loc the location in the source.
136 */
137 static void add_param (char const *type, char *decl, location loc);
138
139
140 static symbol_class current_class = unknown_sym;
141 static uniqstr current_type = NULL;
142 static symbol *current_lhs_symbol;
143 static location current_lhs_location;
144 static named_ref *current_lhs_named_ref;
145 static int current_prec = 0;
146
147 /** Set the new current left-hand side symbol, possibly common
148 * to several right-hand side parts of rule.
149 */
150 static
151 void
current_lhs(symbol * sym,location loc,named_ref * ref)152 current_lhs(symbol *sym, location loc, named_ref *ref)
153 {
154 current_lhs_symbol = sym;
155 current_lhs_location = loc;
156 /* In order to simplify memory management, named references for lhs
157 are always assigned by deep copy into the current symbol_list
158 node. This is because a single named-ref in the grammar may
159 result in several uses when the user factors lhs between several
160 rules using "|". Therefore free the parser's original copy. */
161 free (current_lhs_named_ref);
162 current_lhs_named_ref = ref;
163 }
164
165
166 #define YYTYPE_INT16 int_fast16_t
167 #define YYTYPE_INT8 int_fast8_t
168 #define YYTYPE_UINT16 uint_fast16_t
169 #define YYTYPE_UINT8 uint_fast8_t
170
171 /* Line 360 of yacc.c */
172 #line 173 "parse-gram.c"
173
174 # ifndef YY_NULL
175 # if defined __cplusplus && 201103L <= __cplusplus
176 # define YY_NULL nullptr
177 # else
178 # define YY_NULL 0
179 # endif
180 # endif
181
182 /* Enabling verbose error messages. */
183 #ifdef YYERROR_VERBOSE
184 # undef YYERROR_VERBOSE
185 # define YYERROR_VERBOSE 1
186 #else
187 # define YYERROR_VERBOSE 1
188 #endif
189
190 /* In a future release of Bison, this section will be replaced
191 by #include "parse-gram.h". */
192 #ifndef YY_GRAM_Y_TAB_H_INCLUDED
193 # define YY_GRAM_Y_TAB_H_INCLUDED
194 /* Enabling traces. */
195 #ifndef GRAM_DEBUG
196 # if defined YYDEBUG
197 # if YYDEBUG
198 # define GRAM_DEBUG 1
199 # else
200 # define GRAM_DEBUG 0
201 # endif
202 # else /* ! defined YYDEBUG */
203 # define GRAM_DEBUG 1
204 # endif /* ! defined YYDEBUG */
205 #endif /* ! defined GRAM_DEBUG */
206 #if GRAM_DEBUG
207 extern int gram_debug;
208 #endif
209
210 /* Tokens. */
211 #ifndef GRAM_TOKENTYPE
212 # define GRAM_TOKENTYPE
213 /* Put the tokens into the symbol table, so that GDB and other debuggers
214 know about them. */
215 enum gram_tokentype {
216 GRAM_EOF = 0,
217 STRING = 258,
218 INT = 259,
219 PERCENT_TOKEN = 260,
220 PERCENT_NTERM = 261,
221 PERCENT_TYPE = 262,
222 PERCENT_DESTRUCTOR = 263,
223 PERCENT_PRINTER = 264,
224 PERCENT_LEFT = 265,
225 PERCENT_RIGHT = 266,
226 PERCENT_NONASSOC = 267,
227 PERCENT_PREC = 268,
228 PERCENT_DPREC = 269,
229 PERCENT_MERGE = 270,
230 PERCENT_CODE = 271,
231 PERCENT_DEBUG = 272,
232 PERCENT_DEFAULT_PREC = 273,
233 PERCENT_DEFINE = 274,
234 PERCENT_DEFINES = 275,
235 PERCENT_ERROR_VERBOSE = 276,
236 PERCENT_EXPECT = 277,
237 PERCENT_EXPECT_RR = 278,
238 PERCENT_FILE_PREFIX = 279,
239 PERCENT_GLR_PARSER = 280,
240 PERCENT_INITIAL_ACTION = 281,
241 PERCENT_LANGUAGE = 282,
242 PERCENT_LEX_PARAM = 283,
243 PERCENT_LOCATIONS = 284,
244 PERCENT_NAME_PREFIX = 285,
245 PERCENT_NO_DEFAULT_PREC = 286,
246 PERCENT_NO_LINES = 287,
247 PERCENT_NONDETERMINISTIC_PARSER = 288,
248 PERCENT_OUTPUT = 289,
249 PERCENT_PARSE_PARAM = 290,
250 PERCENT_PURE_PARSER = 291,
251 PERCENT_REQUIRE = 292,
252 PERCENT_SKELETON = 293,
253 PERCENT_START = 294,
254 PERCENT_TOKEN_TABLE = 295,
255 PERCENT_VERBOSE = 296,
256 PERCENT_YACC = 297,
257 BRACED_CODE = 298,
258 BRACKETED_ID = 299,
259 CHAR = 300,
260 EPILOGUE = 301,
261 EQUAL = 302,
262 ID = 303,
263 ID_COLON = 304,
264 PERCENT_PERCENT = 305,
265 PIPE = 306,
266 PROLOGUE = 307,
267 SEMICOLON = 308,
268 TYPE = 309,
269 TYPE_TAG_ANY = 310,
270 TYPE_TAG_NONE = 311,
271 PERCENT_UNION = 312
272 };
273 #endif
274 /* Tokens. */
275 #define GRAM_EOF 0
276 #define STRING 258
277 #define INT 259
278 #define PERCENT_TOKEN 260
279 #define PERCENT_NTERM 261
280 #define PERCENT_TYPE 262
281 #define PERCENT_DESTRUCTOR 263
282 #define PERCENT_PRINTER 264
283 #define PERCENT_LEFT 265
284 #define PERCENT_RIGHT 266
285 #define PERCENT_NONASSOC 267
286 #define PERCENT_PREC 268
287 #define PERCENT_DPREC 269
288 #define PERCENT_MERGE 270
289 #define PERCENT_CODE 271
290 #define PERCENT_DEBUG 272
291 #define PERCENT_DEFAULT_PREC 273
292 #define PERCENT_DEFINE 274
293 #define PERCENT_DEFINES 275
294 #define PERCENT_ERROR_VERBOSE 276
295 #define PERCENT_EXPECT 277
296 #define PERCENT_EXPECT_RR 278
297 #define PERCENT_FILE_PREFIX 279
298 #define PERCENT_GLR_PARSER 280
299 #define PERCENT_INITIAL_ACTION 281
300 #define PERCENT_LANGUAGE 282
301 #define PERCENT_LEX_PARAM 283
302 #define PERCENT_LOCATIONS 284
303 #define PERCENT_NAME_PREFIX 285
304 #define PERCENT_NO_DEFAULT_PREC 286
305 #define PERCENT_NO_LINES 287
306 #define PERCENT_NONDETERMINISTIC_PARSER 288
307 #define PERCENT_OUTPUT 289
308 #define PERCENT_PARSE_PARAM 290
309 #define PERCENT_PURE_PARSER 291
310 #define PERCENT_REQUIRE 292
311 #define PERCENT_SKELETON 293
312 #define PERCENT_START 294
313 #define PERCENT_TOKEN_TABLE 295
314 #define PERCENT_VERBOSE 296
315 #define PERCENT_YACC 297
316 #define BRACED_CODE 298
317 #define BRACKETED_ID 299
318 #define CHAR 300
319 #define EPILOGUE 301
320 #define EQUAL 302
321 #define ID 303
322 #define ID_COLON 304
323 #define PERCENT_PERCENT 305
324 #define PIPE 306
325 #define PROLOGUE 307
326 #define SEMICOLON 308
327 #define TYPE 309
328 #define TYPE_TAG_ANY 310
329 #define TYPE_TAG_NONE 311
330 #define PERCENT_UNION 312
331
332
333
334 #if ! defined GRAM_STYPE && ! defined GRAM_STYPE_IS_DECLARED
335 typedef union GRAM_STYPE
336 {
337 /* Line 376 of yacc.c */
338 #line 115 "parse-gram.y"
339
340 symbol *symbol;
341 symbol_list *list;
342 int integer;
343 char const *chars;
344 char *code;
345 assoc assoc;
346 uniqstr uniqstr;
347 unsigned char character;
348 named_ref *named_ref;
349
350
351 /* Line 376 of yacc.c */
352 #line 353 "parse-gram.c"
353 } GRAM_STYPE;
354 # define GRAM_STYPE_IS_TRIVIAL 1
355 # define gram_stype GRAM_STYPE /* obsolescent; will be withdrawn */
356 # define GRAM_STYPE_IS_DECLARED 1
357 #endif
358
359 #if ! defined GRAM_LTYPE && ! defined GRAM_LTYPE_IS_DECLARED
360 typedef struct GRAM_LTYPE
361 {
362 int first_line;
363 int first_column;
364 int last_line;
365 int last_column;
366 } GRAM_LTYPE;
367 # define gram_ltype GRAM_LTYPE /* obsolescent; will be withdrawn */
368 # define GRAM_LTYPE_IS_DECLARED 1
369 # define GRAM_LTYPE_IS_TRIVIAL 1
370 #endif
371
372
373 #ifdef YYPARSE_PARAM
374 #if defined __STDC__ || defined __cplusplus
375 int gram_parse (void *YYPARSE_PARAM);
376 #else
377 int gram_parse ();
378 #endif
379 #else /* ! YYPARSE_PARAM */
380 #if defined __STDC__ || defined __cplusplus
381 int gram_parse (void);
382 #else
383 int gram_parse ();
384 #endif
385 #endif /* ! YYPARSE_PARAM */
386
387 #endif /* !YY_GRAM_Y_TAB_H_INCLUDED */
388
389 /* Copy the second part of user declarations. */
390
391 /* Line 379 of yacc.c */
392 #line 393 "parse-gram.c"
393
394 #ifdef short
395 # undef short
396 #endif
397
398 #ifdef YYTYPE_UINT8
399 typedef YYTYPE_UINT8 yytype_uint8;
400 #else
401 typedef unsigned char yytype_uint8;
402 #endif
403
404 #ifdef YYTYPE_INT8
405 typedef YYTYPE_INT8 yytype_int8;
406 #elif (defined __STDC__ || defined __C99__FUNC__ \
407 || defined __cplusplus || defined _MSC_VER)
408 typedef signed char yytype_int8;
409 #else
410 typedef short int yytype_int8;
411 #endif
412
413 #ifdef YYTYPE_UINT16
414 typedef YYTYPE_UINT16 yytype_uint16;
415 #else
416 typedef unsigned short int yytype_uint16;
417 #endif
418
419 #ifdef YYTYPE_INT16
420 typedef YYTYPE_INT16 yytype_int16;
421 #else
422 typedef short int yytype_int16;
423 #endif
424
425 #ifndef YYSIZE_T
426 # ifdef __SIZE_TYPE__
427 # define YYSIZE_T __SIZE_TYPE__
428 # elif defined size_t
429 # define YYSIZE_T size_t
430 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
431 || defined __cplusplus || defined _MSC_VER)
432 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
433 # define YYSIZE_T size_t
434 # else
435 # define YYSIZE_T unsigned int
436 # endif
437 #endif
438
439 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
440
441 #ifndef YY_
442 # if defined YYENABLE_NLS && YYENABLE_NLS
443 # if ENABLE_NLS
444 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
445 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
446 # endif
447 # endif
448 # ifndef YY_
449 # define YY_(Msgid) Msgid
450 # endif
451 #endif
452
453 /* Suppress unused-variable warnings by "using" E. */
454 #if ! defined lint || defined __GNUC__
455 # define YYUSE(E) ((void) (E))
456 #else
457 # define YYUSE(E) /* empty */
458 #endif
459
460 /* Identity function, used to suppress warnings about constant conditions. */
461 #ifndef lint
462 # define YYID(N) (N)
463 #else
464 #if (defined __STDC__ || defined __C99__FUNC__ \
465 || defined __cplusplus || defined _MSC_VER)
466 static int
YYID(int yyi)467 YYID (int yyi)
468 #else
469 static int
470 YYID (yyi)
471 int yyi;
472 #endif
473 {
474 return yyi;
475 }
476 #endif
477
478 #if 1
479
480 /* The parser invokes alloca or malloc; define the necessary symbols. */
481
482 # ifdef YYSTACK_ALLOC
483 /* Pacify GCC's `empty if-body' warning. */
484 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
485 # ifndef YYSTACK_ALLOC_MAXIMUM
486 /* The OS might guarantee only one guard page at the bottom of the stack,
487 and a page size can be as small as 4096 bytes. So we cannot safely
488 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
489 to allow for a few compiler-allocated temporary stack slots. */
490 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
491 # endif
492 # else
493 # define YYSTACK_ALLOC YYMALLOC
494 # define YYSTACK_FREE YYFREE
495 # ifndef YYSTACK_ALLOC_MAXIMUM
496 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
497 # endif
498 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
499 && ! ((defined YYMALLOC || defined malloc) \
500 && (defined YYFREE || defined free)))
501 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
502 # ifndef EXIT_SUCCESS
503 # define EXIT_SUCCESS 0
504 # endif
505 # endif
506 # ifndef YYMALLOC
507 # define YYMALLOC malloc
508 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
509 || defined __cplusplus || defined _MSC_VER)
510 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
511 # endif
512 # endif
513 # ifndef YYFREE
514 # define YYFREE free
515 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
516 || defined __cplusplus || defined _MSC_VER)
517 void free (void *); /* INFRINGES ON USER NAME SPACE */
518 # endif
519 # endif
520 # endif
521 # define YYCOPY_NEEDED 1
522 #endif
523
524
525 #if (! defined yyoverflow \
526 && (! defined __cplusplus \
527 || (defined GRAM_LTYPE_IS_TRIVIAL && GRAM_LTYPE_IS_TRIVIAL \
528 && defined GRAM_STYPE_IS_TRIVIAL && GRAM_STYPE_IS_TRIVIAL)))
529
530 /* A type that is properly aligned for any stack member. */
531 union yyalloc
532 {
533 yytype_int16 yyss_alloc;
534 YYSTYPE yyvs_alloc;
535 YYLTYPE yyls_alloc;
536 };
537
538 /* The size of the maximum gap between one aligned stack and the next. */
539 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
540
541 /* The size of an array large to enough to hold all stacks, each with
542 N elements. */
543 # define YYSTACK_BYTES(N) \
544 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
545 + 2 * YYSTACK_GAP_MAXIMUM)
546
547 # define YYCOPY_NEEDED 1
548
549 /* Relocate STACK from its old location to the new one. The
550 local variables YYSIZE and YYSTACKSIZE give the old and new number of
551 elements in the stack, and YYPTR gives the new location of the
552 stack. Advance YYPTR to a properly aligned location for the next
553 stack. */
554 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
555 do \
556 { \
557 YYSIZE_T yynewbytes; \
558 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
559 Stack = &yyptr->Stack_alloc; \
560 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
561 yyptr += yynewbytes / sizeof (*yyptr); \
562 } \
563 while (YYID (0))
564
565 #endif
566
567 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
568 /* Copy COUNT objects from SRC to DST. The source and destination do
569 not overlap. */
570 # ifndef YYCOPY
571 # if defined __GNUC__ && 1 < __GNUC__
572 # define YYCOPY(Dst, Src, Count) \
573 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
574 # else
575 # define YYCOPY(Dst, Src, Count) \
576 do \
577 { \
578 YYSIZE_T yyi; \
579 for (yyi = 0; yyi < (Count); yyi++) \
580 (Dst)[yyi] = (Src)[yyi]; \
581 } \
582 while (YYID (0))
583 # endif
584 # endif
585 #endif /* !YYCOPY_NEEDED */
586
587 /* YYFINAL -- State number of the termination state. */
588 #define YYFINAL 3
589 /* YYLAST -- Last index in YYTABLE. */
590 #define YYLAST 160
591
592 /* YYNTOKENS -- Number of terminals. */
593 #define YYNTOKENS 58
594 /* YYNNTS -- Number of nonterminals. */
595 #define YYNNTS 34
596 /* YYNRULES -- Number of rules. */
597 #define YYNRULES 108
598 /* YYNRULES -- Number of states. */
599 #define YYNSTATES 148
600
601 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
602 #define YYUNDEFTOK 2
603 #define YYMAXUTOK 312
604
605 #define YYTRANSLATE(YYX) \
606 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
607
608 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
609 static const yytype_uint8 yytranslate[] =
610 {
611 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
612 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
613 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
614 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
615 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
616 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
617 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
618 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
619 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
620 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
621 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
622 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
623 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
624 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
625 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
626 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
627 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
628 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
629 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
630 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
631 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
632 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
633 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
634 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
635 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
636 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
637 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
638 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
639 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
640 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
641 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
642 55, 56, 57
643 };
644
645 #if GRAM_DEBUG
646 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
647 YYRHS. */
648 static const yytype_uint16 yyprhs[] =
649 {
650 0, 0, 3, 8, 9, 12, 14, 16, 18, 22,
651 24, 27, 29, 32, 35, 38, 42, 44, 47, 50,
652 53, 55, 58, 62, 64, 66, 69, 73, 76, 78,
653 81, 84, 86, 88, 90, 92, 94, 96, 99, 103,
654 107, 109, 111, 114, 118, 119, 121, 125, 126, 130,
655 131, 135, 139, 143, 145, 147, 149, 150, 152, 154,
656 157, 159, 162, 164, 167, 169, 172, 174, 176, 178,
657 180, 182, 184, 187, 190, 194, 196, 199, 201, 204,
658 206, 209, 212, 213, 218, 220, 224, 227, 228, 232,
659 236, 240, 244, 248, 249, 251, 253, 255, 256, 258,
660 260, 262, 264, 266, 268, 270, 272, 274, 275
661 };
662
663 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
664 static const yytype_int8 yyrhs[] =
665 {
666 59, 0, -1, 60, 50, 77, 91, -1, -1, 60,
667 61, -1, 62, -1, 52, -1, 17, -1, 19, 84,
668 85, -1, 20, -1, 20, 3, -1, 21, -1, 22,
669 4, -1, 23, 4, -1, 24, 3, -1, 24, 47,
670 3, -1, 25, -1, 26, 43, -1, 27, 3, -1,
671 28, 43, -1, 29, -1, 30, 3, -1, 30, 47,
672 3, -1, 32, -1, 33, -1, 34, 3, -1, 34,
673 47, 3, -1, 35, 43, -1, 36, -1, 37, 3,
674 -1, 38, 3, -1, 40, -1, 41, -1, 42, -1,
675 53, -1, 67, -1, 64, -1, 39, 89, -1, 8,
676 43, 73, -1, 9, 43, 73, -1, 18, -1, 31,
677 -1, 16, 86, -1, 16, 48, 86, -1, -1, 48,
678 -1, 57, 63, 86, -1, -1, 6, 65, 76, -1,
679 -1, 5, 66, 76, -1, 7, 54, 72, -1, 68,
680 69, 70, -1, 10, -1, 11, -1, 12, -1, -1,
681 54, -1, 71, -1, 70, 71, -1, 89, -1, 89,
682 4, -1, 89, -1, 72, 89, -1, 74, -1, 73,
683 74, -1, 89, -1, 54, -1, 55, -1, 56, -1,
684 54, -1, 87, -1, 87, 4, -1, 87, 90, -1,
685 87, 4, 90, -1, 75, -1, 76, 75, -1, 78,
686 -1, 77, 78, -1, 79, -1, 62, 53, -1, 1,
687 53, -1, -1, 88, 83, 80, 81, -1, 82, -1,
688 81, 51, 82, -1, 81, 53, -1, -1, 82, 89,
689 83, -1, 82, 43, 83, -1, 82, 13, 89, -1,
690 82, 14, 4, -1, 82, 15, 54, -1, -1, 44,
691 -1, 48, -1, 3, -1, -1, 48, -1, 3, -1,
692 43, -1, 48, -1, 45, -1, 49, -1, 87, -1,
693 90, -1, 3, -1, -1, 50, 46, -1
694 };
695
696 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
697 static const yytype_uint16 yyrline[] =
698 {
699 0, 230, 230, 238, 240, 244, 245, 255, 256, 261,
700 262, 267, 268, 269, 270, 271, 272, 277, 286, 287,
701 288, 289, 290, 291, 292, 293, 294, 295, 296, 311,
702 312, 336, 337, 338, 339, 343, 344, 345, 349, 361,
703 373, 377, 381, 388, 403, 404, 408, 420, 420, 425,
704 425, 430, 441, 456, 457, 458, 462, 463, 468, 470,
705 475, 476, 481, 483, 488, 489, 493, 494, 495, 496,
706 501, 506, 511, 517, 523, 534, 535, 544, 545, 551,
707 552, 553, 560, 560, 568, 569, 570, 575, 577, 579,
708 581, 583, 585, 590, 592, 603, 604, 609, 610, 611,
709 620, 640, 642, 651, 656, 657, 662, 669, 671
710 };
711 #endif
712
713 #if GRAM_DEBUG || YYERROR_VERBOSE || 1
714 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
715 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
716 static const char *const yytname[] =
717 {
718 "\"end of file\"", "error", "$undefined", "\"string\"", "\"integer\"",
719 "\"%token\"", "\"%nterm\"", "\"%type\"", "\"%destructor\"",
720 "\"%printer\"", "\"%left\"", "\"%right\"", "\"%nonassoc\"", "\"%prec\"",
721 "\"%dprec\"", "\"%merge\"", "\"%code\"", "\"%debug\"",
722 "\"%default-prec\"", "\"%define\"", "\"%defines\"", "\"%error-verbose\"",
723 "\"%expect\"", "\"%expect-rr\"", "\"%file-prefix\"", "\"%glr-parser\"",
724 "\"%initial-action\"", "\"%language\"", "\"%lex-param\"",
725 "\"%locations\"", "\"%name-prefix\"", "\"%no-default-prec\"",
726 "\"%no-lines\"", "\"%nondeterministic-parser\"", "\"%output\"",
727 "\"%parse-param\"", "\"%pure-parser\"", "\"%require\"", "\"%skeleton\"",
728 "\"%start\"", "\"%token-table\"", "\"%verbose\"", "\"%yacc\"",
729 "\"{...}\"", "\"[identifier]\"", "\"char\"", "\"epilogue\"", "\"=\"",
730 "\"identifier\"", "\"identifier:\"", "\"%%\"", "\"|\"", "\"%{...%}\"",
731 "\";\"", "\"type\"", "\"<*>\"", "\"<>\"", "\"%union\"", "$accept",
732 "input", "prologue_declarations", "prologue_declaration",
733 "grammar_declaration", "union_name", "symbol_declaration", "$@1", "$@2",
734 "precedence_declaration", "precedence_declarator", "type.opt",
735 "symbols.prec", "symbol.prec", "symbols.1", "generic_symlist",
736 "generic_symlist_item", "symbol_def", "symbol_defs.1", "grammar",
737 "rules_or_grammar_declaration", "rules", "$@3", "rhses.1", "rhs",
738 "named_ref.opt", "variable", "content.opt", "braceless", "id",
739 "id_colon", "symbol", "string_as_id", "epilogue.opt", YY_NULL
740 };
741 #endif
742
743 # ifdef YYPRINT
744 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
745 token YYLEX-NUM. */
746 static const yytype_uint16 yytoknum[] =
747 {
748 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
749 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
750 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
751 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
752 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
753 305, 306, 307, 308, 309, 310, 311, 312
754 };
755 # endif
756
757 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
758 static const yytype_uint8 yyr1[] =
759 {
760 0, 58, 59, 60, 60, 61, 61, 61, 61, 61,
761 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
762 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
763 61, 61, 61, 61, 61, 62, 62, 62, 62, 62,
764 62, 62, 62, 62, 63, 63, 62, 65, 64, 66,
765 64, 64, 67, 68, 68, 68, 69, 69, 70, 70,
766 71, 71, 72, 72, 73, 73, 74, 74, 74, 74,
767 75, 75, 75, 75, 75, 76, 76, 77, 77, 78,
768 78, 78, 80, 79, 81, 81, 81, 82, 82, 82,
769 82, 82, 82, 83, 83, 84, 84, 85, 85, 85,
770 86, 87, 87, 88, 89, 89, 90, 91, 91
771 };
772
773 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
774 static const yytype_uint8 yyr2[] =
775 {
776 0, 2, 4, 0, 2, 1, 1, 1, 3, 1,
777 2, 1, 2, 2, 2, 3, 1, 2, 2, 2,
778 1, 2, 3, 1, 1, 2, 3, 2, 1, 2,
779 2, 1, 1, 1, 1, 1, 1, 2, 3, 3,
780 1, 1, 2, 3, 0, 1, 3, 0, 3, 0,
781 3, 3, 3, 1, 1, 1, 0, 1, 1, 2,
782 1, 2, 1, 2, 1, 2, 1, 1, 1, 1,
783 1, 1, 2, 2, 3, 1, 2, 1, 2, 1,
784 2, 2, 0, 4, 1, 3, 2, 0, 3, 3,
785 3, 3, 3, 0, 1, 1, 1, 0, 1, 1,
786 1, 1, 1, 1, 1, 1, 1, 0, 2
787 };
788
789 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
790 Performed when YYTABLE doesn't specify something else to do. Zero
791 means the default is an error. */
792 static const yytype_uint8 yydefact[] =
793 {
794 3, 0, 0, 1, 49, 47, 0, 0, 0, 53,
795 54, 55, 0, 7, 40, 0, 9, 11, 0, 0,
796 0, 16, 0, 0, 0, 20, 0, 41, 23, 24,
797 0, 0, 28, 0, 0, 0, 31, 32, 33, 0,
798 6, 34, 44, 4, 5, 36, 35, 56, 0, 0,
799 0, 0, 0, 100, 0, 42, 96, 95, 97, 10,
800 12, 13, 14, 0, 17, 18, 19, 21, 0, 25,
801 0, 27, 29, 30, 106, 102, 101, 104, 37, 105,
802 0, 103, 0, 0, 77, 79, 93, 45, 0, 57,
803 0, 70, 75, 50, 71, 48, 51, 62, 67, 68,
804 69, 38, 64, 66, 39, 43, 99, 98, 8, 15,
805 22, 26, 81, 80, 0, 78, 2, 94, 82, 46,
806 52, 58, 60, 76, 72, 73, 63, 65, 108, 87,
807 59, 61, 74, 83, 84, 87, 86, 0, 0, 0,
808 93, 93, 85, 90, 91, 92, 89, 88
809 };
810
811 /* YYDEFGOTO[NTERM-NUM]. */
812 static const yytype_int16 yydefgoto[] =
813 {
814 -1, 1, 2, 43, 82, 88, 45, 49, 48, 46,
815 47, 90, 120, 121, 96, 101, 102, 92, 93, 83,
816 84, 85, 129, 133, 134, 118, 58, 108, 55, 77,
817 86, 103, 79, 116
818 };
819
820 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
821 STATE-NUM. */
822 #define YYPACT_NINF -91
823 static const yytype_int16 yypact[] =
824 {
825 -91, 3, 103, -91, -91, -91, -36, 2, 10, -91,
826 -91, -91, 9, -91, -91, 32, 60, -91, 65, 67,
827 27, -91, 41, 73, 51, -91, 39, -91, -91, -91,
828 40, 52, -91, 93, 95, 33, -91, -91, -91, 15,
829 -91, -91, 53, -91, -91, -91, -91, 46, 43, 43,
830 33, 11, 11, -91, 61, -91, -91, -91, 35, -91,
831 -91, -91, -91, 100, -91, -91, -91, -91, 102, -91,
832 113, -91, -91, -91, -91, -91, -91, -91, -91, -91,
833 64, -91, 94, 1, -91, -91, 62, -91, 61, -91,
834 33, -91, -91, 43, 86, 43, 33, -91, -91, -91,
835 -91, 11, -91, -91, 11, -91, -91, -91, -91, -91,
836 -91, -91, -91, -91, 72, -91, -91, -91, -91, -91,
837 33, -91, 142, -91, 145, -91, -91, -91, -91, -91,
838 -91, -91, -91, 17, 34, -91, -91, 33, 146, 97,
839 62, 62, 34, -91, -91, -91, -91, -91
840 };
841
842 /* YYPGOTO[NTERM-NUM]. */
843 static const yytype_int16 yypgoto[] =
844 {
845 -91, -91, -91, -91, 147, -91, -91, -91, -91, -91,
846 -91, -91, -91, 37, -91, 106, -60, -33, 105, -91,
847 69, -91, -91, -91, 24, -48, -91, -91, -49, -20,
848 -91, -35, -90, -91
849 };
850
851 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
852 positive, shift that token. If negative, reduce the rule which
853 number is the opposite. If YYTABLE_NINF, syntax error. */
854 #define YYTABLE_NINF -108
855 static const yytype_int16 yytable[] =
856 {
857 78, -107, 80, 3, 125, 105, 4, 5, 6, 7,
858 8, 9, 10, 11, 74, 97, 80, 12, 50, 14,
859 4, 5, 6, 7, 8, 9, 10, 11, 94, 94,
860 62, 12, 27, 14, 132, 56, 74, 74, 106, 119,
861 35, 127, 67, 69, 127, 51, 27, 137, 138, 139,
862 81, 114, 53, 52, 35, 122, 75, 54, 42, 76,
863 123, 126, 123, 59, 81, 98, 99, 100, 135, 60,
864 136, 61, 42, 94, 63, 94, 65, 140, 75, 75,
865 57, 76, 76, 107, 64, 122, 68, 70, 75, 74,
866 124, 76, 146, 147, 66, 71, 72, 91, 73, 141,
867 89, 87, 143, 109, 53, 110, 117, 141, 4, 5,
868 6, 7, 8, 9, 10, 11, 111, 112, 128, 12,
869 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
870 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
871 33, 34, 35, 36, 37, 38, 131, 113, 74, 44,
872 144, 145, 115, 39, 95, 40, 41, 130, 104, 142,
873 42
874 };
875
876 #define yypact_value_is_default(Yystate) \
877 (!!((Yystate) == (-91)))
878
879 #define yytable_value_is_error(Yytable_value) \
880 YYID (0)
881
882 static const yytype_uint8 yycheck[] =
883 {
884 35, 0, 1, 0, 94, 54, 5, 6, 7, 8,
885 9, 10, 11, 12, 3, 50, 1, 16, 54, 18,
886 5, 6, 7, 8, 9, 10, 11, 12, 48, 49,
887 3, 16, 31, 18, 124, 3, 3, 3, 3, 88,
888 39, 101, 3, 3, 104, 43, 31, 13, 14, 15,
889 49, 50, 43, 43, 39, 90, 45, 48, 57, 48,
890 93, 96, 95, 3, 49, 54, 55, 56, 51, 4,
891 53, 4, 57, 93, 47, 95, 3, 43, 45, 45,
892 48, 48, 48, 48, 43, 120, 47, 47, 45, 3,
893 4, 48, 140, 141, 43, 43, 3, 54, 3, 134,
894 54, 48, 137, 3, 43, 3, 44, 142, 5, 6,
895 7, 8, 9, 10, 11, 12, 3, 53, 46, 16,
896 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
897 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
898 37, 38, 39, 40, 41, 42, 4, 53, 3, 2,
899 4, 54, 83, 50, 49, 52, 53, 120, 52, 135,
900 57
901 };
902
903 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
904 symbol of state STATE-NUM. */
905 static const yytype_uint8 yystos[] =
906 {
907 0, 59, 60, 0, 5, 6, 7, 8, 9, 10,
908 11, 12, 16, 17, 18, 19, 20, 21, 22, 23,
909 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
910 34, 35, 36, 37, 38, 39, 40, 41, 42, 50,
911 52, 53, 57, 61, 62, 64, 67, 68, 66, 65,
912 54, 43, 43, 43, 48, 86, 3, 48, 84, 3,
913 4, 4, 3, 47, 43, 3, 43, 3, 47, 3,
914 47, 43, 3, 3, 3, 45, 48, 87, 89, 90,
915 1, 49, 62, 77, 78, 79, 88, 48, 63, 54,
916 69, 54, 75, 76, 87, 76, 72, 89, 54, 55,
917 56, 73, 74, 89, 73, 86, 3, 48, 85, 3,
918 3, 3, 53, 53, 50, 78, 91, 44, 83, 86,
919 70, 71, 89, 75, 4, 90, 89, 74, 46, 80,
920 71, 4, 90, 81, 82, 51, 53, 13, 14, 15,
921 43, 89, 82, 89, 4, 54, 83, 83
922 };
923
924 #define yyerrok (yyerrstatus = 0)
925 #define yyclearin (yychar = YYEMPTY)
926 #define YYEMPTY (-2)
927 #define YYEOF 0
928
929 #define YYACCEPT goto yyacceptlab
930 #define YYABORT goto yyabortlab
931 #define YYERROR goto yyerrorlab
932
933
934 /* Like YYERROR except do call yyerror. This remains here temporarily
935 to ease the transition to the new meaning of YYERROR, for GCC.
936 Once GCC version 2 has supplanted version 1, this can go. However,
937 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
938 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
939 discussed. */
940
941 #define YYFAIL goto yyerrlab
942 #if defined YYFAIL
943 /* This is here to suppress warnings from the GCC cpp's
944 -Wunused-macros. Normally we don't worry about that warning, but
945 some users do, and we want to make it easy for users to remove
946 YYFAIL uses, which will produce warnings from Bison 2.5. */
947 #endif
948
949 #define YYRECOVERING() (!!yyerrstatus)
950
951 #define YYBACKUP(Token, Value) \
952 do \
953 if (yychar == YYEMPTY) \
954 { \
955 yychar = (Token); \
956 yylval = (Value); \
957 YYPOPSTACK (yylen); \
958 yystate = *yyssp; \
959 YY_LAC_DISCARD ("YYBACKUP"); \
960 goto yybackup; \
961 } \
962 else \
963 { \
964 yyerror (YY_("syntax error: cannot back up")); \
965 YYERROR; \
966 } \
967 while (YYID (0))
968
969 /* Error token number */
970 #define YYTERROR 1
971 #define YYERRCODE 256
972
973
974 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
975 If N is 0, then set CURRENT to the empty location which ends
976 the previous symbol: RHS[0] (always defined). */
977
978 #ifndef YYLLOC_DEFAULT
979 # define YYLLOC_DEFAULT(Current, Rhs, N) \
980 do \
981 if (YYID (N)) \
982 { \
983 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
984 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
985 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
986 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
987 } \
988 else \
989 { \
990 (Current).first_line = (Current).last_line = \
991 YYRHSLOC (Rhs, 0).last_line; \
992 (Current).first_column = (Current).last_column = \
993 YYRHSLOC (Rhs, 0).last_column; \
994 } \
995 while (YYID (0))
996 #endif
997
998 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
999
1000
1001 /* YY_LOCATION_PRINT -- Print the location on the stream.
1002 This macro was not mandated originally: define only if we know
1003 we won't break user code: when these are the locations we know. */
1004
1005 #ifndef YY_LOCATION_PRINT
1006 # if defined GRAM_LTYPE_IS_TRIVIAL && GRAM_LTYPE_IS_TRIVIAL
1007 # define YY_LOCATION_PRINT(File, Loc) \
1008 do { \
1009 fprintf (File, "%d.%d", (Loc).first_line, (Loc).first_column); \
1010 if ((Loc).first_line < (Loc).last_line) \
1011 fprintf (File, "-%d.%d", (Loc).last_line, (Loc).last_column - 1); \
1012 else if ((Loc).first_column < (Loc).last_column - 1) \
1013 fprintf (File, "-%d", (Loc).last_column - 1); \
1014 } while (0)
1015 # else
1016 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1017 # endif
1018 #endif
1019
1020
1021 /* YYLEX -- calling `yylex' with the right arguments. */
1022 #ifdef YYLEX_PARAM
1023 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
1024 #else
1025 # define YYLEX yylex (&yylval, &yylloc)
1026 #endif
1027
1028 /* Enable debugging if requested. */
1029 #if GRAM_DEBUG
1030
1031 # ifndef YYFPRINTF
1032 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1033 # define YYFPRINTF fprintf
1034 # endif
1035
1036 # define YYDPRINTF(Args) \
1037 do { \
1038 if (yydebug) \
1039 YYFPRINTF Args; \
1040 } while (YYID (0))
1041
1042 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1043 do { \
1044 if (yydebug) \
1045 { \
1046 YYFPRINTF (stderr, "%s ", Title); \
1047 yy_symbol_print (stderr, \
1048 Type, Value, Location); \
1049 YYFPRINTF (stderr, "\n"); \
1050 } \
1051 } while (YYID (0))
1052
1053
1054 /*--------------------------------.
1055 | Print this symbol on YYOUTPUT. |
1056 `--------------------------------*/
1057
1058 /*ARGSUSED*/
1059 #if (defined __STDC__ || defined __C99__FUNC__ \
1060 || defined __cplusplus || defined _MSC_VER)
1061 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,YYLTYPE const * const yylocationp)1062 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
1063 #else
1064 static void
1065 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp)
1066 FILE *yyoutput;
1067 int yytype;
1068 YYSTYPE const * const yyvaluep;
1069 YYLTYPE const * const yylocationp;
1070 #endif
1071 {
1072 FILE *yyo = yyoutput;
1073 YYUSE (yyo);
1074 if (!yyvaluep)
1075 return;
1076 YYUSE (yylocationp);
1077 # ifdef YYPRINT
1078 if (yytype < YYNTOKENS)
1079 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1080 # else
1081 YYUSE (yyoutput);
1082 # endif
1083 switch (yytype)
1084 {
1085 case 3: /* "string" */
1086 /* Line 812 of yacc.c */
1087 #line 205 "parse-gram.y"
1088 { fputs (quotearg_style (c_quoting_style, ((*yyvaluep).chars)), stderr); };
1089 /* Line 812 of yacc.c */
1090 #line 1091 "parse-gram.c"
1091 break;
1092 case 4: /* "integer" */
1093 /* Line 812 of yacc.c */
1094 #line 217 "parse-gram.y"
1095 { fprintf (stderr, "%d", ((*yyvaluep).integer)); };
1096 /* Line 812 of yacc.c */
1097 #line 1098 "parse-gram.c"
1098 break;
1099 case 43: /* "{...}" */
1100 /* Line 812 of yacc.c */
1101 #line 207 "parse-gram.y"
1102 { fprintf (stderr, "{\n%s\n}", ((*yyvaluep).code)); };
1103 /* Line 812 of yacc.c */
1104 #line 1105 "parse-gram.c"
1105 break;
1106 case 44: /* "[identifier]" */
1107 /* Line 812 of yacc.c */
1108 #line 212 "parse-gram.y"
1109 { fprintf (stderr, "[%s]", ((*yyvaluep).uniqstr)); };
1110 /* Line 812 of yacc.c */
1111 #line 1112 "parse-gram.c"
1112 break;
1113 case 45: /* "char" */
1114 /* Line 812 of yacc.c */
1115 #line 199 "parse-gram.y"
1116 { fputs (char_name (((*yyvaluep).character)), stderr); };
1117 /* Line 812 of yacc.c */
1118 #line 1119 "parse-gram.c"
1119 break;
1120 case 46: /* "epilogue" */
1121 /* Line 812 of yacc.c */
1122 #line 207 "parse-gram.y"
1123 { fprintf (stderr, "{\n%s\n}", ((*yyvaluep).chars)); };
1124 /* Line 812 of yacc.c */
1125 #line 1126 "parse-gram.c"
1126 break;
1127 case 48: /* "identifier" */
1128 /* Line 812 of yacc.c */
1129 #line 211 "parse-gram.y"
1130 { fputs (((*yyvaluep).uniqstr), stderr); };
1131 /* Line 812 of yacc.c */
1132 #line 1133 "parse-gram.c"
1133 break;
1134 case 49: /* "identifier:" */
1135 /* Line 812 of yacc.c */
1136 #line 213 "parse-gram.y"
1137 { fprintf (stderr, "%s:", ((*yyvaluep).uniqstr)); };
1138 /* Line 812 of yacc.c */
1139 #line 1140 "parse-gram.c"
1140 break;
1141 case 52: /* "%{...%}" */
1142 /* Line 812 of yacc.c */
1143 #line 207 "parse-gram.y"
1144 { fprintf (stderr, "{\n%s\n}", ((*yyvaluep).chars)); };
1145 /* Line 812 of yacc.c */
1146 #line 1147 "parse-gram.c"
1147 break;
1148 case 54: /* "type" */
1149 /* Line 812 of yacc.c */
1150 #line 214 "parse-gram.y"
1151 { fprintf (stderr, "<%s>", ((*yyvaluep).uniqstr)); };
1152 /* Line 812 of yacc.c */
1153 #line 1154 "parse-gram.c"
1154 break;
1155 case 71: /* symbol.prec */
1156 /* Line 812 of yacc.c */
1157 #line 220 "parse-gram.y"
1158 { fprintf (stderr, "%s", ((*yyvaluep).symbol)->tag); };
1159 /* Line 812 of yacc.c */
1160 #line 1161 "parse-gram.c"
1161 break;
1162 case 84: /* variable */
1163 /* Line 812 of yacc.c */
1164 #line 211 "parse-gram.y"
1165 { fputs (((*yyvaluep).uniqstr), stderr); };
1166 /* Line 812 of yacc.c */
1167 #line 1168 "parse-gram.c"
1168 break;
1169 case 85: /* content.opt */
1170 /* Line 812 of yacc.c */
1171 #line 207 "parse-gram.y"
1172 { fprintf (stderr, "{\n%s\n}", ((*yyvaluep).chars)); };
1173 /* Line 812 of yacc.c */
1174 #line 1175 "parse-gram.c"
1175 break;
1176 case 86: /* braceless */
1177 /* Line 812 of yacc.c */
1178 #line 207 "parse-gram.y"
1179 { fprintf (stderr, "{\n%s\n}", ((*yyvaluep).chars)); };
1180 /* Line 812 of yacc.c */
1181 #line 1182 "parse-gram.c"
1182 break;
1183 case 87: /* id */
1184 /* Line 812 of yacc.c */
1185 #line 220 "parse-gram.y"
1186 { fprintf (stderr, "%s", ((*yyvaluep).symbol)->tag); };
1187 /* Line 812 of yacc.c */
1188 #line 1189 "parse-gram.c"
1189 break;
1190 case 88: /* id_colon */
1191 /* Line 812 of yacc.c */
1192 #line 221 "parse-gram.y"
1193 { fprintf (stderr, "%s:", ((*yyvaluep).symbol)->tag); };
1194 /* Line 812 of yacc.c */
1195 #line 1196 "parse-gram.c"
1196 break;
1197 case 89: /* symbol */
1198 /* Line 812 of yacc.c */
1199 #line 220 "parse-gram.y"
1200 { fprintf (stderr, "%s", ((*yyvaluep).symbol)->tag); };
1201 /* Line 812 of yacc.c */
1202 #line 1203 "parse-gram.c"
1203 break;
1204 case 90: /* string_as_id */
1205 /* Line 812 of yacc.c */
1206 #line 220 "parse-gram.y"
1207 { fprintf (stderr, "%s", ((*yyvaluep).symbol)->tag); };
1208 /* Line 812 of yacc.c */
1209 #line 1210 "parse-gram.c"
1210 break;
1211 default:
1212 break;
1213 }
1214 }
1215
1216
1217 /*--------------------------------.
1218 | Print this symbol on YYOUTPUT. |
1219 `--------------------------------*/
1220
1221 #if (defined __STDC__ || defined __C99__FUNC__ \
1222 || defined __cplusplus || defined _MSC_VER)
1223 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep,YYLTYPE const * const yylocationp)1224 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
1225 #else
1226 static void
1227 yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp)
1228 FILE *yyoutput;
1229 int yytype;
1230 YYSTYPE const * const yyvaluep;
1231 YYLTYPE const * const yylocationp;
1232 #endif
1233 {
1234 if (yytype < YYNTOKENS)
1235 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1236 else
1237 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1238
1239 YY_LOCATION_PRINT (yyoutput, *yylocationp);
1240 YYFPRINTF (yyoutput, ": ");
1241 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp);
1242 YYFPRINTF (yyoutput, ")");
1243 }
1244
1245 /*------------------------------------------------------------------.
1246 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1247 | TOP (included). |
1248 `------------------------------------------------------------------*/
1249
1250 #if (defined __STDC__ || defined __C99__FUNC__ \
1251 || defined __cplusplus || defined _MSC_VER)
1252 static void
yy_stack_print(yytype_int16 * yybottom,yytype_int16 * yytop)1253 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1254 #else
1255 static void
1256 yy_stack_print (yybottom, yytop)
1257 yytype_int16 *yybottom;
1258 yytype_int16 *yytop;
1259 #endif
1260 {
1261 YYFPRINTF (stderr, "Stack now");
1262 for (; yybottom <= yytop; yybottom++)
1263 {
1264 int yybot = *yybottom;
1265 YYFPRINTF (stderr, " %d", yybot);
1266 }
1267 YYFPRINTF (stderr, "\n");
1268 }
1269
1270 # define YY_STACK_PRINT(Bottom, Top) \
1271 do { \
1272 if (yydebug) \
1273 yy_stack_print ((Bottom), (Top)); \
1274 } while (YYID (0))
1275
1276
1277 /*------------------------------------------------.
1278 | Report that the YYRULE is going to be reduced. |
1279 `------------------------------------------------*/
1280
1281 #if (defined __STDC__ || defined __C99__FUNC__ \
1282 || defined __cplusplus || defined _MSC_VER)
1283 static void
yy_reduce_print(YYSTYPE * yyvsp,YYLTYPE * yylsp,int yyrule)1284 yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule)
1285 #else
1286 static void
1287 yy_reduce_print (yyvsp, yylsp, yyrule)
1288 YYSTYPE *yyvsp;
1289 YYLTYPE *yylsp;
1290 int yyrule;
1291 #endif
1292 {
1293 int yynrhs = yyr2[yyrule];
1294 int yyi;
1295 unsigned long int yylno = yyrline[yyrule];
1296 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1297 yyrule - 1, yylno);
1298 /* The symbols being reduced. */
1299 for (yyi = 0; yyi < yynrhs; yyi++)
1300 {
1301 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1302 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1303 &(yyvsp[(yyi + 1) - (yynrhs)])
1304 , &(yylsp[(yyi + 1) - (yynrhs)]) );
1305 YYFPRINTF (stderr, "\n");
1306 }
1307 }
1308
1309 # define YY_REDUCE_PRINT(Rule) \
1310 do { \
1311 if (yydebug) \
1312 yy_reduce_print (yyvsp, yylsp, Rule); \
1313 } while (YYID (0))
1314
1315 /* Nonzero means print parse trace. It is left uninitialized so that
1316 multiple parsers can coexist. */
1317 int yydebug;
1318 #else /* !GRAM_DEBUG */
1319 # define YYDPRINTF(Args)
1320 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1321 # define YY_STACK_PRINT(Bottom, Top)
1322 # define YY_REDUCE_PRINT(Rule)
1323 #endif /* !GRAM_DEBUG */
1324
1325
1326 /* YYINITDEPTH -- initial size of the parser's stacks. */
1327 #ifndef YYINITDEPTH
1328 # define YYINITDEPTH 200
1329 #endif
1330
1331 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1332 if the built-in stack extension method is used).
1333
1334 Do not make this value too large; the results are undefined if
1335 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1336 evaluated with infinite-precision integer arithmetic. */
1337
1338 #ifndef YYMAXDEPTH
1339 # define YYMAXDEPTH 10000
1340 #endif
1341
1342 /* Given a state stack such that *YYBOTTOM is its bottom, such that
1343 *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty
1344 stack, and such that *YYCAPACITY is the maximum number of elements it
1345 can hold without a reallocation, make sure there is enough room to
1346 store YYADD more elements. If not, allocate a new stack using
1347 YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM,
1348 *YYTOP, and *YYCAPACITY to reflect the new capacity and memory
1349 location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack
1350 using YYSTACK_FREE. Return 0 if successful or if no reallocation is
1351 required. Return 1 if memory is exhausted. */
1352 static int
yy_lac_stack_realloc(YYSIZE_T * yycapacity,YYSIZE_T yyadd,char const * yydebug_prefix,char const * yydebug_suffix,yytype_int16 ** yybottom,yytype_int16 * yybottom_no_free,yytype_int16 ** yytop,yytype_int16 * yytop_empty)1353 yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd,
1354 #if GRAM_DEBUG
1355 char const *yydebug_prefix,
1356 char const *yydebug_suffix,
1357 #endif
1358 yytype_int16 **yybottom,
1359 yytype_int16 *yybottom_no_free,
1360 yytype_int16 **yytop, yytype_int16 *yytop_empty)
1361 {
1362 YYSIZE_T yysize_old =
1363 *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1;
1364 YYSIZE_T yysize_new = yysize_old + yyadd;
1365 if (*yycapacity < yysize_new)
1366 {
1367 YYSIZE_T yyalloc = 2 * yysize_new;
1368 yytype_int16 *yybottom_new;
1369 /* Use YYMAXDEPTH for maximum stack size given that the stack
1370 should never need to grow larger than the main state stack
1371 needs to grow without LAC. */
1372 if (YYMAXDEPTH < yysize_new)
1373 {
1374 YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix,
1375 yydebug_suffix));
1376 return 1;
1377 }
1378 if (YYMAXDEPTH < yyalloc)
1379 yyalloc = YYMAXDEPTH;
1380 yybottom_new =
1381 (yytype_int16*) YYSTACK_ALLOC (yyalloc * sizeof *yybottom_new);
1382 if (!yybottom_new)
1383 {
1384 YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix,
1385 yydebug_suffix));
1386 return 1;
1387 }
1388 if (*yytop != yytop_empty)
1389 {
1390 YYCOPY (yybottom_new, *yybottom, yysize_old);
1391 *yytop = yybottom_new + (yysize_old - 1);
1392 }
1393 if (*yybottom != yybottom_no_free)
1394 YYSTACK_FREE (*yybottom);
1395 *yybottom = yybottom_new;
1396 *yycapacity = yyalloc;
1397 }
1398 return 0;
1399 }
1400
1401 /* Establish the initial context for the current lookahead if no initial
1402 context is currently established.
1403
1404 We define a context as a snapshot of the parser stacks. We define
1405 the initial context for a lookahead as the context in which the
1406 parser initially examines that lookahead in order to select a
1407 syntactic action. Thus, if the lookahead eventually proves
1408 syntactically unacceptable (possibly in a later context reached via a
1409 series of reductions), the initial context can be used to determine
1410 the exact set of tokens that would be syntactically acceptable in the
1411 lookahead's place. Moreover, it is the context after which any
1412 further semantic actions would be erroneous because they would be
1413 determined by a syntactically unacceptable token.
1414
1415 YY_LAC_ESTABLISH should be invoked when a reduction is about to be
1416 performed in an inconsistent state (which, for the purposes of LAC,
1417 includes consistent states that don't know they're consistent because
1418 their default reductions have been disabled). Iff there is a
1419 lookahead token, it should also be invoked before reporting a syntax
1420 error. This latter case is for the sake of the debugging output.
1421
1422 For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as
1423 follows. If no initial context is currently established for the
1424 current lookahead, then check if that lookahead can eventually be
1425 shifted if syntactic actions continue from the current context.
1426 Report a syntax error if it cannot. */
1427 #define YY_LAC_ESTABLISH \
1428 do { \
1429 if (!yy_lac_established) \
1430 { \
1431 YYDPRINTF ((stderr, \
1432 "LAC: initial context established for %s\n", \
1433 yytname[yytoken])); \
1434 yy_lac_established = 1; \
1435 { \
1436 int yy_lac_status = \
1437 yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \
1438 if (yy_lac_status == 2) \
1439 goto yyexhaustedlab; \
1440 if (yy_lac_status == 1) \
1441 goto yyerrlab; \
1442 } \
1443 } \
1444 } while (YYID (0))
1445
1446 /* Discard any previous initial lookahead context because of Event,
1447 which may be a lookahead change or an invalidation of the currently
1448 established initial context for the current lookahead.
1449
1450 The most common example of a lookahead change is a shift. An example
1451 of both cases is syntax error recovery. That is, a syntax error
1452 occurs when the lookahead is syntactically erroneous for the
1453 currently established initial context, so error recovery manipulates
1454 the parser stacks to try to find a new initial context in which the
1455 current lookahead is syntactically acceptable. If it fails to find
1456 such a context, it discards the lookahead. */
1457 #if GRAM_DEBUG
1458 # define YY_LAC_DISCARD(Event) \
1459 do { \
1460 if (yy_lac_established) \
1461 { \
1462 if (yydebug) \
1463 YYFPRINTF (stderr, "LAC: initial context discarded due to " \
1464 Event "\n"); \
1465 yy_lac_established = 0; \
1466 } \
1467 } while (YYID (0))
1468 #else
1469 # define YY_LAC_DISCARD(Event) yy_lac_established = 0
1470 #endif
1471
1472 /* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can
1473 eventually (after perhaps some reductions) be shifted, return 1 if
1474 not, or return 2 if memory is exhausted. As preconditions and
1475 postconditions: *YYES_CAPACITY is the allocated size of the array to
1476 which *YYES points, and either *YYES = YYESA or *YYES points to an
1477 array allocated with YYSTACK_ALLOC. yy_lac may overwrite the
1478 contents of either array, alter *YYES and *YYES_CAPACITY, and free
1479 any old *YYES other than YYESA. */
1480 static int
yy_lac(yytype_int16 * yyesa,yytype_int16 ** yyes,YYSIZE_T * yyes_capacity,yytype_int16 * yyssp,int yytoken)1481 yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes,
1482 YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken)
1483 {
1484 yytype_int16 *yyes_prev = yyssp;
1485 yytype_int16 *yyesp = yyes_prev;
1486 YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yytname[yytoken]));
1487 if (yytoken == YYUNDEFTOK)
1488 {
1489 YYDPRINTF ((stderr, " Always Err\n"));
1490 return 1;
1491 }
1492 while (1)
1493 {
1494 int yyrule = yypact[*yyesp];
1495 if (yypact_value_is_default (yyrule)
1496 || (yyrule += yytoken) < 0 || YYLAST < yyrule
1497 || yycheck[yyrule] != yytoken)
1498 {
1499 yyrule = yydefact[*yyesp];
1500 if (yyrule == 0)
1501 {
1502 YYDPRINTF ((stderr, " Err\n"));
1503 return 1;
1504 }
1505 }
1506 else
1507 {
1508 yyrule = yytable[yyrule];
1509 if (yytable_value_is_error (yyrule))
1510 {
1511 YYDPRINTF ((stderr, " Err\n"));
1512 return 1;
1513 }
1514 if (0 < yyrule)
1515 {
1516 YYDPRINTF ((stderr, " S%d\n", yyrule));
1517 return 0;
1518 }
1519 yyrule = -yyrule;
1520 }
1521 {
1522 YYSIZE_T yylen = yyr2[yyrule];
1523 YYDPRINTF ((stderr, " R%d", yyrule - 1));
1524 if (yyesp != yyes_prev)
1525 {
1526 YYSIZE_T yysize = yyesp - *yyes + 1;
1527 if (yylen < yysize)
1528 {
1529 yyesp -= yylen;
1530 yylen = 0;
1531 }
1532 else
1533 {
1534 yylen -= yysize;
1535 yyesp = yyes_prev;
1536 }
1537 }
1538 if (yylen)
1539 yyesp = yyes_prev -= yylen;
1540 }
1541 {
1542 int yystate;
1543 {
1544 int yylhs = yyr1[yyrule] - YYNTOKENS;
1545 yystate = yypgoto[yylhs] + *yyesp;
1546 if (yystate < 0 || YYLAST < yystate
1547 || yycheck[yystate] != *yyesp)
1548 yystate = yydefgoto[yylhs];
1549 else
1550 yystate = yytable[yystate];
1551 }
1552 if (yyesp == yyes_prev)
1553 {
1554 yyesp = *yyes;
1555 *yyesp = yystate;
1556 }
1557 else
1558 {
1559 if (yy_lac_stack_realloc (yyes_capacity, 1,
1560 #if GRAM_DEBUG
1561 " (", ")",
1562 #endif
1563 yyes, yyesa, &yyesp, yyes_prev))
1564 {
1565 YYDPRINTF ((stderr, "\n"));
1566 return 2;
1567 }
1568 *++yyesp = yystate;
1569 }
1570 YYDPRINTF ((stderr, " G%d", yystate));
1571 }
1572 }
1573 }
1574
1575
1576 #if YYERROR_VERBOSE
1577
1578 # ifndef yystrlen
1579 # if defined __GLIBC__ && defined _STRING_H
1580 # define yystrlen strlen
1581 # else
1582 /* Return the length of YYSTR. */
1583 #if (defined __STDC__ || defined __C99__FUNC__ \
1584 || defined __cplusplus || defined _MSC_VER)
1585 static YYSIZE_T
yystrlen(const char * yystr)1586 yystrlen (const char *yystr)
1587 #else
1588 static YYSIZE_T
1589 yystrlen (yystr)
1590 const char *yystr;
1591 #endif
1592 {
1593 YYSIZE_T yylen;
1594 for (yylen = 0; yystr[yylen]; yylen++)
1595 continue;
1596 return yylen;
1597 }
1598 # endif
1599 # endif
1600
1601 # ifndef yystpcpy
1602 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1603 # define yystpcpy stpcpy
1604 # else
1605 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1606 YYDEST. */
1607 #if (defined __STDC__ || defined __C99__FUNC__ \
1608 || defined __cplusplus || defined _MSC_VER)
1609 static char *
yystpcpy(char * yydest,const char * yysrc)1610 yystpcpy (char *yydest, const char *yysrc)
1611 #else
1612 static char *
1613 yystpcpy (yydest, yysrc)
1614 char *yydest;
1615 const char *yysrc;
1616 #endif
1617 {
1618 char *yyd = yydest;
1619 const char *yys = yysrc;
1620
1621 while ((*yyd++ = *yys++) != '\0')
1622 continue;
1623
1624 return yyd - 1;
1625 }
1626 # endif
1627 # endif
1628
1629 # ifndef yytnamerr
1630 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1631 quotes and backslashes, so that it's suitable for yyerror. The
1632 heuristic is that double-quoting is unnecessary unless the string
1633 contains an apostrophe, a comma, or backslash (other than
1634 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1635 null, do not copy; instead, return the length of what the result
1636 would have been. */
1637 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)1638 yytnamerr (char *yyres, const char *yystr)
1639 {
1640 if (*yystr == '"')
1641 {
1642 YYSIZE_T yyn = 0;
1643 char const *yyp = yystr;
1644
1645 for (;;)
1646 switch (*++yyp)
1647 {
1648 case '\'':
1649 case ',':
1650 goto do_not_strip_quotes;
1651
1652 case '\\':
1653 if (*++yyp != '\\')
1654 goto do_not_strip_quotes;
1655 /* Fall through. */
1656 default:
1657 if (yyres)
1658 yyres[yyn] = *yyp;
1659 yyn++;
1660 break;
1661
1662 case '"':
1663 if (yyres)
1664 yyres[yyn] = '\0';
1665 return yyn;
1666 }
1667 do_not_strip_quotes: ;
1668 }
1669
1670 if (! yyres)
1671 return yystrlen (yystr);
1672
1673 return yystpcpy (yyres, yystr) - yyres;
1674 }
1675 # endif
1676
1677 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1678 about the unexpected token YYTOKEN for the state stack whose top is
1679 YYSSP. In order to see if a particular token T is a
1680 valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).
1681
1682 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1683 not large enough to hold the message. In that case, also set
1684 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1685 required number of bytes is too large to store or if
1686 yy_lac returned 2. */
1687 static int
yysyntax_error(YYSIZE_T * yymsg_alloc,char ** yymsg,yytype_int16 * yyesa,yytype_int16 ** yyes,YYSIZE_T * yyes_capacity,yytype_int16 * yyssp,int yytoken)1688 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1689 yytype_int16 *yyesa, yytype_int16 **yyes,
1690 YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken)
1691 {
1692 YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1693 YYSIZE_T yysize = yysize0;
1694 YYSIZE_T yysize1;
1695 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1696 /* Internationalized format string. */
1697 const char *yyformat = YY_NULL;
1698 /* Arguments of yyformat. */
1699 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1700 /* Number of reported tokens (one for the "unexpected", one per
1701 "expected"). */
1702 int yycount = 0;
1703
1704 /* There are many possibilities here to consider:
1705 - Assume YYFAIL is not used. It's too flawed to consider. See
1706 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1707 for details. YYERROR is fine as it does not invoke this
1708 function.
1709 - If this state is a consistent state with a default action, then
1710 the only way this function was invoked is if the default action
1711 is an error action. In that case, don't check for expected
1712 tokens because there are none.
1713 - The only way there can be no lookahead present (in yychar) is if
1714 this state is a consistent state with a default action. Thus,
1715 detecting the absence of a lookahead is sufficient to determine
1716 that there is no unexpected or expected token to report. In that
1717 case, just report a simple "syntax error".
1718 - Don't assume there isn't a lookahead just because this state is a
1719 consistent state with a default action. There might have been a
1720 previous inconsistent state, consistent state with a non-default
1721 action, or user semantic action that manipulated yychar.
1722 In the first two cases, it might appear that the current syntax
1723 error should have been detected in the previous state when yy_lac
1724 was invoked. However, at that time, there might have been a
1725 different syntax error that discarded a different initial context
1726 during error recovery, leaving behind the current lookahead.
1727 */
1728 if (yytoken != YYEMPTY)
1729 {
1730 int yyn = yypact[*yyssp];
1731 YYDPRINTF ((stderr, "Constructing syntax error message\n"));
1732 yyarg[yycount++] = yytname[yytoken];
1733 if (!yypact_value_is_default (yyn))
1734 {
1735 int yyx;
1736
1737 for (yyx = 0; yyx < YYNTOKENS; ++yyx)
1738 if (yyx != YYTERROR && yyx != YYUNDEFTOK)
1739 {
1740 {
1741 int yy_lac_status = yy_lac (yyesa, yyes, yyes_capacity,
1742 yyssp, yyx);
1743 if (yy_lac_status == 2)
1744 return 2;
1745 if (yy_lac_status == 1)
1746 continue;
1747 }
1748 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1749 {
1750 yycount = 1;
1751 yysize = yysize0;
1752 break;
1753 }
1754 yyarg[yycount++] = yytname[yyx];
1755 yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
1756 if (! (yysize <= yysize1
1757 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1758 return 2;
1759 yysize = yysize1;
1760 }
1761 }
1762 # if GRAM_DEBUG
1763 else if (yydebug)
1764 YYFPRINTF (stderr, "No expected tokens.\n");
1765 # endif
1766 }
1767
1768 switch (yycount)
1769 {
1770 # define YYCASE_(N, S) \
1771 case N: \
1772 yyformat = S; \
1773 break
1774 YYCASE_(0, YY_("syntax error"));
1775 YYCASE_(1, YY_("syntax error, unexpected %s"));
1776 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1777 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1778 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1779 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1780 # undef YYCASE_
1781 }
1782
1783 yysize1 = yysize + yystrlen (yyformat);
1784 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1785 return 2;
1786 yysize = yysize1;
1787
1788 if (*yymsg_alloc < yysize)
1789 {
1790 *yymsg_alloc = 2 * yysize;
1791 if (! (yysize <= *yymsg_alloc
1792 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1793 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1794 return 1;
1795 }
1796
1797 /* Avoid sprintf, as that infringes on the user's name space.
1798 Don't have undefined behavior even if the translation
1799 produced a string with the wrong number of "%s"s. */
1800 {
1801 char *yyp = *yymsg;
1802 int yyi = 0;
1803 while ((*yyp = *yyformat) != '\0')
1804 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1805 {
1806 yyp += yytnamerr (yyp, yyarg[yyi++]);
1807 yyformat += 2;
1808 }
1809 else
1810 {
1811 yyp++;
1812 yyformat++;
1813 }
1814 }
1815 return 0;
1816 }
1817 #endif /* YYERROR_VERBOSE */
1818
1819 /*-----------------------------------------------.
1820 | Release the memory associated to this symbol. |
1821 `-----------------------------------------------*/
1822
1823 /*ARGSUSED*/
1824 #if (defined __STDC__ || defined __C99__FUNC__ \
1825 || defined __cplusplus || defined _MSC_VER)
1826 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep,YYLTYPE * yylocationp)1827 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1828 #else
1829 static void
1830 yydestruct (yymsg, yytype, yyvaluep, yylocationp)
1831 const char *yymsg;
1832 int yytype;
1833 YYSTYPE *yyvaluep;
1834 YYLTYPE *yylocationp;
1835 #endif
1836 {
1837 YYUSE (yyvaluep);
1838 YYUSE (yylocationp);
1839
1840 if (!yymsg)
1841 yymsg = "Deleting";
1842 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1843
1844 switch (yytype)
1845 {
1846
1847 default:
1848 break;
1849 }
1850 }
1851
1852
1853
1854
1855 /*----------.
1856 | yyparse. |
1857 `----------*/
1858
1859 #ifdef YYPARSE_PARAM
1860 #if (defined __STDC__ || defined __C99__FUNC__ \
1861 || defined __cplusplus || defined _MSC_VER)
1862 int
yyparse(void * YYPARSE_PARAM)1863 yyparse (void *YYPARSE_PARAM)
1864 #else
1865 int
1866 yyparse (YYPARSE_PARAM)
1867 void *YYPARSE_PARAM;
1868 #endif
1869 #else /* ! YYPARSE_PARAM */
1870 #if (defined __STDC__ || defined __C99__FUNC__ \
1871 || defined __cplusplus || defined _MSC_VER)
1872 int
1873 yyparse (void)
1874 #else
1875 int
1876 yyparse ()
1877
1878 #endif
1879 #endif
1880 {
1881 /* The lookahead symbol. */
1882 int yychar;
1883
1884
1885 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
1886 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
1887 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
1888 _Pragma ("GCC diagnostic push") \
1889 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
1890 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
1891 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
1892 _Pragma ("GCC diagnostic pop")
1893 #else
1894 /* Default value used for initialization, for pacifying older GCCs
1895 or non-GCC compilers. */
1896 static YYSTYPE yyval_default;
1897 # define YY_INITIAL_VALUE(Value) = Value
1898 #endif
1899 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1900 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1901 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
1902 #endif
1903 #ifndef YY_INITIAL_VALUE
1904 # define YY_INITIAL_VALUE(Value) /* Nothing. */
1905 #endif
1906
1907 /* The semantic value of the lookahead symbol. */
1908 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
1909
1910 /* Location data for the lookahead symbol. */
1911 YYLTYPE yylloc
1912 # if defined GRAM_LTYPE_IS_TRIVIAL && GRAM_LTYPE_IS_TRIVIAL
1913 = { 1, 1, 1, 1 }
1914 # endif
1915 ;
1916
1917
1918 /* Number of syntax errors so far. */
1919 int yynerrs;
1920
1921 int yystate;
1922 /* Number of tokens to shift before error messages enabled. */
1923 int yyerrstatus;
1924
1925 /* The stacks and their tools:
1926 `yyss': related to states.
1927 `yyvs': related to semantic values.
1928 `yyls': related to locations.
1929
1930 Refer to the stacks through separate pointers, to allow yyoverflow
1931 to reallocate them elsewhere. */
1932
1933 /* The state stack. */
1934 yytype_int16 yyssa[YYINITDEPTH];
1935 yytype_int16 *yyss;
1936 yytype_int16 *yyssp;
1937
1938 /* The semantic value stack. */
1939 YYSTYPE yyvsa[YYINITDEPTH];
1940 YYSTYPE *yyvs;
1941 YYSTYPE *yyvsp;
1942
1943 /* The location stack. */
1944 YYLTYPE yylsa[YYINITDEPTH];
1945 YYLTYPE *yyls;
1946 YYLTYPE *yylsp;
1947
1948 /* The locations where the error started and ended. */
1949 YYLTYPE yyerror_range[3];
1950
1951 YYSIZE_T yystacksize;
1952
1953 yytype_int16 yyesa[20];
1954 yytype_int16 *yyes;
1955 YYSIZE_T yyes_capacity;
1956
1957 int yy_lac_established = 0;
1958 int yyn;
1959 int yyresult;
1960 /* Lookahead token as an internal (translated) token number. */
1961 int yytoken = 0;
1962 /* The variables used to return semantic value and location from the
1963 action routines. */
1964 YYSTYPE yyval;
1965 YYLTYPE yyloc;
1966
1967 #if YYERROR_VERBOSE
1968 /* Buffer for error messages, and its allocated size. */
1969 char yymsgbuf[128];
1970 char *yymsg = yymsgbuf;
1971 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1972 #endif
1973
1974 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1975
1976 /* The number of symbols on the RHS of the reduced rule.
1977 Keep to zero when no symbol should be popped. */
1978 int yylen = 0;
1979
1980 yyssp = yyss = yyssa;
1981 yyvsp = yyvs = yyvsa;
1982 yylsp = yyls = yylsa;
1983 yystacksize = YYINITDEPTH;
1984
1985 yyes = yyesa;
1986 yyes_capacity = sizeof yyesa / sizeof *yyes;
1987 if (YYMAXDEPTH < yyes_capacity)
1988 yyes_capacity = YYMAXDEPTH;
1989
1990 YYDPRINTF ((stderr, "Starting parse\n"));
1991
1992 yystate = 0;
1993 yyerrstatus = 0;
1994 yynerrs = 0;
1995 yychar = YYEMPTY; /* Cause a token to be read. */
1996
1997 /* User initialization code. */
1998 /* Line 1560 of yacc.c */
1999 #line 107 "parse-gram.y"
2000 {
2001 /* Bison's grammar can initial empty locations, hence a default
2002 location is needed. */
2003 boundary_set (&yylloc.start, current_file, 1, 1);
2004 boundary_set (&yylloc.end, current_file, 1, 1);
2005 }
2006 /* Line 1560 of yacc.c */
2007 #line 2008 "parse-gram.c"
2008 yylsp[0] = yylloc;
2009 goto yysetstate;
2010
2011 /*------------------------------------------------------------.
2012 | yynewstate -- Push a new state, which is found in yystate. |
2013 `------------------------------------------------------------*/
2014 yynewstate:
2015 /* In all cases, when you get here, the value and location stacks
2016 have just been pushed. So pushing a state here evens the stacks. */
2017 yyssp++;
2018
2019 yysetstate:
2020 *yyssp = yystate;
2021
2022 if (yyss + yystacksize - 1 <= yyssp)
2023 {
2024 /* Get the current used size of the three stacks, in elements. */
2025 YYSIZE_T yysize = yyssp - yyss + 1;
2026
2027 #ifdef yyoverflow
2028 {
2029 /* Give user a chance to reallocate the stack. Use copies of
2030 these so that the &'s don't force the real ones into
2031 memory. */
2032 YYSTYPE *yyvs1 = yyvs;
2033 yytype_int16 *yyss1 = yyss;
2034 YYLTYPE *yyls1 = yyls;
2035
2036 /* Each stack pointer address is followed by the size of the
2037 data in use in that stack, in bytes. This used to be a
2038 conditional around just the two extra args, but that might
2039 be undefined if yyoverflow is a macro. */
2040 yyoverflow (YY_("memory exhausted"),
2041 &yyss1, yysize * sizeof (*yyssp),
2042 &yyvs1, yysize * sizeof (*yyvsp),
2043 &yyls1, yysize * sizeof (*yylsp),
2044 &yystacksize);
2045
2046 yyls = yyls1;
2047 yyss = yyss1;
2048 yyvs = yyvs1;
2049 }
2050 #else /* no yyoverflow */
2051 # ifndef YYSTACK_RELOCATE
2052 goto yyexhaustedlab;
2053 # else
2054 /* Extend the stack our own way. */
2055 if (YYMAXDEPTH <= yystacksize)
2056 goto yyexhaustedlab;
2057 yystacksize *= 2;
2058 if (YYMAXDEPTH < yystacksize)
2059 yystacksize = YYMAXDEPTH;
2060
2061 {
2062 yytype_int16 *yyss1 = yyss;
2063 union yyalloc *yyptr =
2064 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2065 if (! yyptr)
2066 goto yyexhaustedlab;
2067 YYSTACK_RELOCATE (yyss_alloc, yyss);
2068 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2069 YYSTACK_RELOCATE (yyls_alloc, yyls);
2070 # undef YYSTACK_RELOCATE
2071 if (yyss1 != yyssa)
2072 YYSTACK_FREE (yyss1);
2073 }
2074 # endif
2075 #endif /* no yyoverflow */
2076
2077 yyssp = yyss + yysize - 1;
2078 yyvsp = yyvs + yysize - 1;
2079 yylsp = yyls + yysize - 1;
2080
2081 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2082 (unsigned long int) yystacksize));
2083
2084 if (yyss + yystacksize - 1 <= yyssp)
2085 YYABORT;
2086 }
2087
2088 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2089
2090 if (yystate == YYFINAL)
2091 YYACCEPT;
2092
2093 goto yybackup;
2094
2095 /*-----------.
2096 | yybackup. |
2097 `-----------*/
2098 yybackup:
2099
2100 /* Do appropriate processing given the current state. Read a
2101 lookahead token if we need one and don't already have one. */
2102
2103 /* First try to decide what to do without reference to lookahead token. */
2104 yyn = yypact[yystate];
2105 if (yypact_value_is_default (yyn))
2106 goto yydefault;
2107
2108 /* Not known => get a lookahead token if don't already have one. */
2109
2110 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2111 if (yychar == YYEMPTY)
2112 {
2113 YYDPRINTF ((stderr, "Reading a token: "));
2114 yychar = YYLEX;
2115 }
2116
2117 if (yychar <= YYEOF)
2118 {
2119 yychar = yytoken = YYEOF;
2120 YYDPRINTF ((stderr, "Now at end of input.\n"));
2121 }
2122 else
2123 {
2124 yytoken = YYTRANSLATE (yychar);
2125 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2126 }
2127
2128 /* If the proper action on seeing token YYTOKEN is to reduce or to
2129 detect an error, take that action. */
2130 yyn += yytoken;
2131 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2132 {
2133 YY_LAC_ESTABLISH;
2134 goto yydefault;
2135 }
2136 yyn = yytable[yyn];
2137 if (yyn <= 0)
2138 {
2139 if (yytable_value_is_error (yyn))
2140 goto yyerrlab;
2141 YY_LAC_ESTABLISH;
2142 yyn = -yyn;
2143 goto yyreduce;
2144 }
2145
2146 /* Count tokens shifted since error; after three, turn off error
2147 status. */
2148 if (yyerrstatus)
2149 yyerrstatus--;
2150
2151 /* Shift the lookahead token. */
2152 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2153
2154 /* Discard the shifted token. */
2155 yychar = YYEMPTY;
2156 YY_LAC_DISCARD ("shift");
2157
2158 yystate = yyn;
2159 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2160 *++yyvsp = yylval;
2161 YY_IGNORE_MAYBE_UNINITIALIZED_END
2162 *++yylsp = yylloc;
2163 goto yynewstate;
2164
2165
2166 /*-----------------------------------------------------------.
2167 | yydefault -- do the default action for the current state. |
2168 `-----------------------------------------------------------*/
2169 yydefault:
2170 yyn = yydefact[yystate];
2171 if (yyn == 0)
2172 goto yyerrlab;
2173 goto yyreduce;
2174
2175
2176 /*-----------------------------.
2177 | yyreduce -- Do a reduction. |
2178 `-----------------------------*/
2179 yyreduce:
2180 /* yyn is the number of a rule to reduce with. */
2181 yylen = yyr2[yyn];
2182
2183 /* If YYLEN is nonzero, implement the default value of the action:
2184 `$$ = $1'.
2185
2186 Otherwise, the following line sets YYVAL to garbage.
2187 This behavior is undocumented and Bison
2188 users should not rely upon it. Assigning to YYVAL
2189 unconditionally makes the parser a bit smaller, and it avoids a
2190 GCC warning that YYVAL may be used uninitialized. */
2191 yyval = yyvsp[1-yylen];
2192
2193 /* Default location. */
2194 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
2195 YY_REDUCE_PRINT (yyn);
2196 {
2197 int yychar_backup = yychar;
2198 switch (yyn)
2199 {
2200 case 6:
2201 /* Line 1778 of yacc.c */
2202 #line 246 "parse-gram.y"
2203 {
2204 code_props plain_code;
2205 code_props_plain_init (&plain_code, (yyvsp[(1) - (1)].chars), (yylsp[(1) - (1)]));
2206 code_props_translate_code (&plain_code);
2207 gram_scanner_last_string_free ();
2208 muscle_code_grow (union_seen ? "post_prologue" : "pre_prologue",
2209 plain_code.code, (yylsp[(1) - (1)]));
2210 code_scanner_last_string_free ();
2211 }
2212 break;
2213
2214 case 7:
2215 /* Line 1778 of yacc.c */
2216 #line 255 "parse-gram.y"
2217 { debug = true; }
2218 break;
2219
2220 case 8:
2221 /* Line 1778 of yacc.c */
2222 #line 257 "parse-gram.y"
2223 {
2224 muscle_percent_define_insert ((yyvsp[(2) - (3)].uniqstr), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].chars),
2225 MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
2226 }
2227 break;
2228
2229 case 9:
2230 /* Line 1778 of yacc.c */
2231 #line 261 "parse-gram.y"
2232 { defines_flag = true; }
2233 break;
2234
2235 case 10:
2236 /* Line 1778 of yacc.c */
2237 #line 263 "parse-gram.y"
2238 {
2239 defines_flag = true;
2240 spec_defines_file = xstrdup ((yyvsp[(2) - (2)].chars));
2241 }
2242 break;
2243
2244 case 11:
2245 /* Line 1778 of yacc.c */
2246 #line 267 "parse-gram.y"
2247 { error_verbose = true; }
2248 break;
2249
2250 case 12:
2251 /* Line 1778 of yacc.c */
2252 #line 268 "parse-gram.y"
2253 { expected_sr_conflicts = (yyvsp[(2) - (2)].integer); }
2254 break;
2255
2256 case 13:
2257 /* Line 1778 of yacc.c */
2258 #line 269 "parse-gram.y"
2259 { expected_rr_conflicts = (yyvsp[(2) - (2)].integer); }
2260 break;
2261
2262 case 14:
2263 /* Line 1778 of yacc.c */
2264 #line 270 "parse-gram.y"
2265 { spec_file_prefix = (yyvsp[(2) - (2)].chars); }
2266 break;
2267
2268 case 15:
2269 /* Line 1778 of yacc.c */
2270 #line 271 "parse-gram.y"
2271 { spec_file_prefix = (yyvsp[(3) - (3)].chars); }
2272 break;
2273
2274 case 16:
2275 /* Line 1778 of yacc.c */
2276 #line 273 "parse-gram.y"
2277 {
2278 nondeterministic_parser = true;
2279 glr_parser = true;
2280 }
2281 break;
2282
2283 case 17:
2284 /* Line 1778 of yacc.c */
2285 #line 278 "parse-gram.y"
2286 {
2287 code_props action;
2288 code_props_symbol_action_init (&action, (yyvsp[(2) - (2)].code), (yylsp[(2) - (2)]));
2289 code_props_translate_code (&action);
2290 gram_scanner_last_string_free ();
2291 muscle_code_grow ("initial_action", action.code, (yylsp[(2) - (2)]));
2292 code_scanner_last_string_free ();
2293 }
2294 break;
2295
2296 case 18:
2297 /* Line 1778 of yacc.c */
2298 #line 286 "parse-gram.y"
2299 { language_argmatch ((yyvsp[(2) - (2)].chars), grammar_prio, (yylsp[(1) - (2)])); }
2300 break;
2301
2302 case 19:
2303 /* Line 1778 of yacc.c */
2304 #line 287 "parse-gram.y"
2305 { add_param ("lex_param", (yyvsp[(2) - (2)].code), (yylsp[(2) - (2)])); }
2306 break;
2307
2308 case 20:
2309 /* Line 1778 of yacc.c */
2310 #line 288 "parse-gram.y"
2311 { locations_flag = true; }
2312 break;
2313
2314 case 21:
2315 /* Line 1778 of yacc.c */
2316 #line 289 "parse-gram.y"
2317 { spec_name_prefix = (yyvsp[(2) - (2)].chars); }
2318 break;
2319
2320 case 22:
2321 /* Line 1778 of yacc.c */
2322 #line 290 "parse-gram.y"
2323 { spec_name_prefix = (yyvsp[(3) - (3)].chars); }
2324 break;
2325
2326 case 23:
2327 /* Line 1778 of yacc.c */
2328 #line 291 "parse-gram.y"
2329 { no_lines_flag = true; }
2330 break;
2331
2332 case 24:
2333 /* Line 1778 of yacc.c */
2334 #line 292 "parse-gram.y"
2335 { nondeterministic_parser = true; }
2336 break;
2337
2338 case 25:
2339 /* Line 1778 of yacc.c */
2340 #line 293 "parse-gram.y"
2341 { spec_outfile = (yyvsp[(2) - (2)].chars); }
2342 break;
2343
2344 case 26:
2345 /* Line 1778 of yacc.c */
2346 #line 294 "parse-gram.y"
2347 { spec_outfile = (yyvsp[(3) - (3)].chars); }
2348 break;
2349
2350 case 27:
2351 /* Line 1778 of yacc.c */
2352 #line 295 "parse-gram.y"
2353 { add_param ("parse_param", (yyvsp[(2) - (2)].code), (yylsp[(2) - (2)])); }
2354 break;
2355
2356 case 28:
2357 /* Line 1778 of yacc.c */
2358 #line 297 "parse-gram.y"
2359 {
2360 /* %pure-parser is deprecated in favor of `%define api.pure', so use
2361 `%define api.pure' in a backward-compatible manner here. First, don't
2362 complain if %pure-parser is specified multiple times. */
2363 if (!muscle_find_const ("percent_define(api.pure)"))
2364 muscle_percent_define_insert ("api.pure", (yylsp[(1) - (1)]), "",
2365 MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
2366 /* In all cases, use api.pure now so that the backend doesn't complain if
2367 the skeleton ignores api.pure, but do warn now if there's a previous
2368 conflicting definition from an actual %define. */
2369 if (!muscle_percent_define_flag_if ("api.pure"))
2370 muscle_percent_define_insert ("api.pure", (yylsp[(1) - (1)]), "",
2371 MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE);
2372 }
2373 break;
2374
2375 case 29:
2376 /* Line 1778 of yacc.c */
2377 #line 311 "parse-gram.y"
2378 { version_check (&(yylsp[(2) - (2)]), (yyvsp[(2) - (2)].chars)); }
2379 break;
2380
2381 case 30:
2382 /* Line 1778 of yacc.c */
2383 #line 313 "parse-gram.y"
2384 {
2385 char const *skeleton_user = (yyvsp[(2) - (2)].chars);
2386 if (mbschr (skeleton_user, '/'))
2387 {
2388 size_t dir_length = strlen (current_file);
2389 char *skeleton_build;
2390 while (dir_length && current_file[dir_length - 1] != '/')
2391 --dir_length;
2392 while (dir_length && current_file[dir_length - 1] == '/')
2393 --dir_length;
2394 skeleton_build =
2395 xmalloc (dir_length + 1 + strlen (skeleton_user) + 1);
2396 if (dir_length > 0)
2397 {
2398 memcpy (skeleton_build, current_file, dir_length);
2399 skeleton_build[dir_length++] = '/';
2400 }
2401 strcpy (skeleton_build + dir_length, skeleton_user);
2402 skeleton_user = uniqstr_new (skeleton_build);
2403 free (skeleton_build);
2404 }
2405 skeleton_arg (skeleton_user, grammar_prio, (yylsp[(1) - (2)]));
2406 }
2407 break;
2408
2409 case 31:
2410 /* Line 1778 of yacc.c */
2411 #line 336 "parse-gram.y"
2412 { token_table_flag = true; }
2413 break;
2414
2415 case 32:
2416 /* Line 1778 of yacc.c */
2417 #line 337 "parse-gram.y"
2418 { report_flag |= report_states; }
2419 break;
2420
2421 case 33:
2422 /* Line 1778 of yacc.c */
2423 #line 338 "parse-gram.y"
2424 { yacc_flag = true; }
2425 break;
2426
2427 case 37:
2428 /* Line 1778 of yacc.c */
2429 #line 346 "parse-gram.y"
2430 {
2431 grammar_start_symbol_set ((yyvsp[(2) - (2)].symbol), (yylsp[(2) - (2)]));
2432 }
2433 break;
2434
2435 case 38:
2436 /* Line 1778 of yacc.c */
2437 #line 350 "parse-gram.y"
2438 {
2439 code_props code;
2440 code_props_symbol_action_init (&code, (yyvsp[(2) - (3)].code), (yylsp[(2) - (3)]));
2441 code_props_translate_code (&code);
2442 {
2443 symbol_list *list;
2444 for (list = (yyvsp[(3) - (3)].list); list; list = list->next)
2445 symbol_list_destructor_set (list, &code);
2446 symbol_list_free ((yyvsp[(3) - (3)].list));
2447 }
2448 }
2449 break;
2450
2451 case 39:
2452 /* Line 1778 of yacc.c */
2453 #line 362 "parse-gram.y"
2454 {
2455 code_props code;
2456 code_props_symbol_action_init (&code, (yyvsp[(2) - (3)].code), (yylsp[(2) - (3)]));
2457 code_props_translate_code (&code);
2458 {
2459 symbol_list *list;
2460 for (list = (yyvsp[(3) - (3)].list); list; list = list->next)
2461 symbol_list_printer_set (list, &code);
2462 symbol_list_free ((yyvsp[(3) - (3)].list));
2463 }
2464 }
2465 break;
2466
2467 case 40:
2468 /* Line 1778 of yacc.c */
2469 #line 374 "parse-gram.y"
2470 {
2471 default_prec = true;
2472 }
2473 break;
2474
2475 case 41:
2476 /* Line 1778 of yacc.c */
2477 #line 378 "parse-gram.y"
2478 {
2479 default_prec = false;
2480 }
2481 break;
2482
2483 case 42:
2484 /* Line 1778 of yacc.c */
2485 #line 382 "parse-gram.y"
2486 {
2487 /* Do not invoke muscle_percent_code_grow here since it invokes
2488 muscle_user_name_list_grow. */
2489 muscle_code_grow ("percent_code()", (yyvsp[(2) - (2)].chars), (yylsp[(2) - (2)]));
2490 code_scanner_last_string_free ();
2491 }
2492 break;
2493
2494 case 43:
2495 /* Line 1778 of yacc.c */
2496 #line 389 "parse-gram.y"
2497 {
2498 muscle_percent_code_grow ((yyvsp[(2) - (3)].uniqstr), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].chars), (yylsp[(3) - (3)]));
2499 code_scanner_last_string_free ();
2500 }
2501 break;
2502
2503 case 44:
2504 /* Line 1778 of yacc.c */
2505 #line 403 "parse-gram.y"
2506 {}
2507 break;
2508
2509 case 45:
2510 /* Line 1778 of yacc.c */
2511 #line 404 "parse-gram.y"
2512 { muscle_code_grow ("union_name", (yyvsp[(1) - (1)].uniqstr), (yylsp[(1) - (1)])); }
2513 break;
2514
2515 case 46:
2516 /* Line 1778 of yacc.c */
2517 #line 409 "parse-gram.y"
2518 {
2519 union_seen = true;
2520 muscle_code_grow ("stype", (yyvsp[(3) - (3)].chars), (yylsp[(3) - (3)]));
2521 code_scanner_last_string_free ();
2522 }
2523 break;
2524
2525 case 47:
2526 /* Line 1778 of yacc.c */
2527 #line 420 "parse-gram.y"
2528 { current_class = nterm_sym; }
2529 break;
2530
2531 case 48:
2532 /* Line 1778 of yacc.c */
2533 #line 421 "parse-gram.y"
2534 {
2535 current_class = unknown_sym;
2536 current_type = NULL;
2537 }
2538 break;
2539
2540 case 49:
2541 /* Line 1778 of yacc.c */
2542 #line 425 "parse-gram.y"
2543 { current_class = token_sym; }
2544 break;
2545
2546 case 50:
2547 /* Line 1778 of yacc.c */
2548 #line 426 "parse-gram.y"
2549 {
2550 current_class = unknown_sym;
2551 current_type = NULL;
2552 }
2553 break;
2554
2555 case 51:
2556 /* Line 1778 of yacc.c */
2557 #line 431 "parse-gram.y"
2558 {
2559 symbol_list *list;
2560 tag_seen = true;
2561 for (list = (yyvsp[(3) - (3)].list); list; list = list->next)
2562 symbol_type_set (list->content.sym, (yyvsp[(2) - (3)].uniqstr), (yylsp[(2) - (3)]));
2563 symbol_list_free ((yyvsp[(3) - (3)].list));
2564 }
2565 break;
2566
2567 case 52:
2568 /* Line 1778 of yacc.c */
2569 #line 442 "parse-gram.y"
2570 {
2571 symbol_list *list;
2572 ++current_prec;
2573 for (list = (yyvsp[(3) - (3)].list); list; list = list->next)
2574 {
2575 symbol_type_set (list->content.sym, current_type, (yylsp[(2) - (3)]));
2576 symbol_precedence_set (list->content.sym, current_prec, (yyvsp[(1) - (3)].assoc), (yylsp[(1) - (3)]));
2577 }
2578 symbol_list_free ((yyvsp[(3) - (3)].list));
2579 current_type = NULL;
2580 }
2581 break;
2582
2583 case 53:
2584 /* Line 1778 of yacc.c */
2585 #line 456 "parse-gram.y"
2586 { (yyval.assoc) = left_assoc; }
2587 break;
2588
2589 case 54:
2590 /* Line 1778 of yacc.c */
2591 #line 457 "parse-gram.y"
2592 { (yyval.assoc) = right_assoc; }
2593 break;
2594
2595 case 55:
2596 /* Line 1778 of yacc.c */
2597 #line 458 "parse-gram.y"
2598 { (yyval.assoc) = non_assoc; }
2599 break;
2600
2601 case 56:
2602 /* Line 1778 of yacc.c */
2603 #line 462 "parse-gram.y"
2604 { current_type = NULL; }
2605 break;
2606
2607 case 57:
2608 /* Line 1778 of yacc.c */
2609 #line 463 "parse-gram.y"
2610 { current_type = (yyvsp[(1) - (1)].uniqstr); tag_seen = true; }
2611 break;
2612
2613 case 58:
2614 /* Line 1778 of yacc.c */
2615 #line 469 "parse-gram.y"
2616 { (yyval.list) = symbol_list_sym_new ((yyvsp[(1) - (1)].symbol), (yylsp[(1) - (1)])); }
2617 break;
2618
2619 case 59:
2620 /* Line 1778 of yacc.c */
2621 #line 471 "parse-gram.y"
2622 { (yyval.list) = symbol_list_prepend ((yyvsp[(1) - (2)].list), symbol_list_sym_new ((yyvsp[(2) - (2)].symbol), (yylsp[(2) - (2)]))); }
2623 break;
2624
2625 case 60:
2626 /* Line 1778 of yacc.c */
2627 #line 475 "parse-gram.y"
2628 { (yyval.symbol) = (yyvsp[(1) - (1)].symbol); }
2629 break;
2630
2631 case 61:
2632 /* Line 1778 of yacc.c */
2633 #line 476 "parse-gram.y"
2634 { (yyval.symbol) = (yyvsp[(1) - (2)].symbol); symbol_user_token_number_set ((yyvsp[(1) - (2)].symbol), (yyvsp[(2) - (2)].integer), (yylsp[(2) - (2)])); }
2635 break;
2636
2637 case 62:
2638 /* Line 1778 of yacc.c */
2639 #line 482 "parse-gram.y"
2640 { (yyval.list) = symbol_list_sym_new ((yyvsp[(1) - (1)].symbol), (yylsp[(1) - (1)])); }
2641 break;
2642
2643 case 63:
2644 /* Line 1778 of yacc.c */
2645 #line 484 "parse-gram.y"
2646 { (yyval.list) = symbol_list_prepend ((yyvsp[(1) - (2)].list), symbol_list_sym_new ((yyvsp[(2) - (2)].symbol), (yylsp[(2) - (2)]))); }
2647 break;
2648
2649 case 64:
2650 /* Line 1778 of yacc.c */
2651 #line 488 "parse-gram.y"
2652 { (yyval.list) = (yyvsp[(1) - (1)].list); }
2653 break;
2654
2655 case 65:
2656 /* Line 1778 of yacc.c */
2657 #line 489 "parse-gram.y"
2658 { (yyval.list) = symbol_list_prepend ((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].list)); }
2659 break;
2660
2661 case 66:
2662 /* Line 1778 of yacc.c */
2663 #line 493 "parse-gram.y"
2664 { (yyval.list) = symbol_list_sym_new ((yyvsp[(1) - (1)].symbol), (yylsp[(1) - (1)])); }
2665 break;
2666
2667 case 67:
2668 /* Line 1778 of yacc.c */
2669 #line 494 "parse-gram.y"
2670 { (yyval.list) = symbol_list_type_new ((yyvsp[(1) - (1)].uniqstr), (yylsp[(1) - (1)])); }
2671 break;
2672
2673 case 68:
2674 /* Line 1778 of yacc.c */
2675 #line 495 "parse-gram.y"
2676 { (yyval.list) = symbol_list_default_tagged_new ((yylsp[(1) - (1)])); }
2677 break;
2678
2679 case 69:
2680 /* Line 1778 of yacc.c */
2681 #line 496 "parse-gram.y"
2682 { (yyval.list) = symbol_list_default_tagless_new ((yylsp[(1) - (1)])); }
2683 break;
2684
2685 case 70:
2686 /* Line 1778 of yacc.c */
2687 #line 502 "parse-gram.y"
2688 {
2689 current_type = (yyvsp[(1) - (1)].uniqstr);
2690 tag_seen = true;
2691 }
2692 break;
2693
2694 case 71:
2695 /* Line 1778 of yacc.c */
2696 #line 507 "parse-gram.y"
2697 {
2698 symbol_class_set ((yyvsp[(1) - (1)].symbol), current_class, (yylsp[(1) - (1)]), true);
2699 symbol_type_set ((yyvsp[(1) - (1)].symbol), current_type, (yylsp[(1) - (1)]));
2700 }
2701 break;
2702
2703 case 72:
2704 /* Line 1778 of yacc.c */
2705 #line 512 "parse-gram.y"
2706 {
2707 symbol_class_set ((yyvsp[(1) - (2)].symbol), current_class, (yylsp[(1) - (2)]), true);
2708 symbol_type_set ((yyvsp[(1) - (2)].symbol), current_type, (yylsp[(1) - (2)]));
2709 symbol_user_token_number_set ((yyvsp[(1) - (2)].symbol), (yyvsp[(2) - (2)].integer), (yylsp[(2) - (2)]));
2710 }
2711 break;
2712
2713 case 73:
2714 /* Line 1778 of yacc.c */
2715 #line 518 "parse-gram.y"
2716 {
2717 symbol_class_set ((yyvsp[(1) - (2)].symbol), current_class, (yylsp[(1) - (2)]), true);
2718 symbol_type_set ((yyvsp[(1) - (2)].symbol), current_type, (yylsp[(1) - (2)]));
2719 symbol_make_alias ((yyvsp[(1) - (2)].symbol), (yyvsp[(2) - (2)].symbol), (yyloc));
2720 }
2721 break;
2722
2723 case 74:
2724 /* Line 1778 of yacc.c */
2725 #line 524 "parse-gram.y"
2726 {
2727 symbol_class_set ((yyvsp[(1) - (3)].symbol), current_class, (yylsp[(1) - (3)]), true);
2728 symbol_type_set ((yyvsp[(1) - (3)].symbol), current_type, (yylsp[(1) - (3)]));
2729 symbol_user_token_number_set ((yyvsp[(1) - (3)].symbol), (yyvsp[(2) - (3)].integer), (yylsp[(2) - (3)]));
2730 symbol_make_alias ((yyvsp[(1) - (3)].symbol), (yyvsp[(3) - (3)].symbol), (yyloc));
2731 }
2732 break;
2733
2734 case 81:
2735 /* Line 1778 of yacc.c */
2736 #line 554 "parse-gram.y"
2737 {
2738 yyerrok;
2739 }
2740 break;
2741
2742 case 82:
2743 /* Line 1778 of yacc.c */
2744 #line 560 "parse-gram.y"
2745 { current_lhs ((yyvsp[(1) - (2)].symbol), (yylsp[(1) - (2)]), (yyvsp[(2) - (2)].named_ref)); }
2746 break;
2747
2748 case 83:
2749 /* Line 1778 of yacc.c */
2750 #line 561 "parse-gram.y"
2751 {
2752 /* Free the current lhs. */
2753 current_lhs (0, (yylsp[(1) - (4)]), 0);
2754 }
2755 break;
2756
2757 case 84:
2758 /* Line 1778 of yacc.c */
2759 #line 568 "parse-gram.y"
2760 { grammar_current_rule_end ((yylsp[(1) - (1)])); }
2761 break;
2762
2763 case 85:
2764 /* Line 1778 of yacc.c */
2765 #line 569 "parse-gram.y"
2766 { grammar_current_rule_end ((yylsp[(3) - (3)])); }
2767 break;
2768
2769 case 87:
2770 /* Line 1778 of yacc.c */
2771 #line 575 "parse-gram.y"
2772 { grammar_current_rule_begin (current_lhs_symbol, current_lhs_location,
2773 current_lhs_named_ref); }
2774 break;
2775
2776 case 88:
2777 /* Line 1778 of yacc.c */
2778 #line 578 "parse-gram.y"
2779 { grammar_current_rule_symbol_append ((yyvsp[(2) - (3)].symbol), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].named_ref)); }
2780 break;
2781
2782 case 89:
2783 /* Line 1778 of yacc.c */
2784 #line 580 "parse-gram.y"
2785 { grammar_current_rule_action_append ((yyvsp[(2) - (3)].code), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].named_ref)); }
2786 break;
2787
2788 case 90:
2789 /* Line 1778 of yacc.c */
2790 #line 582 "parse-gram.y"
2791 { grammar_current_rule_prec_set ((yyvsp[(3) - (3)].symbol), (yylsp[(3) - (3)])); }
2792 break;
2793
2794 case 91:
2795 /* Line 1778 of yacc.c */
2796 #line 584 "parse-gram.y"
2797 { grammar_current_rule_dprec_set ((yyvsp[(3) - (3)].integer), (yylsp[(3) - (3)])); }
2798 break;
2799
2800 case 92:
2801 /* Line 1778 of yacc.c */
2802 #line 586 "parse-gram.y"
2803 { grammar_current_rule_merge_set ((yyvsp[(3) - (3)].uniqstr), (yylsp[(3) - (3)])); }
2804 break;
2805
2806 case 93:
2807 /* Line 1778 of yacc.c */
2808 #line 590 "parse-gram.y"
2809 { (yyval.named_ref) = 0; }
2810 break;
2811
2812 case 94:
2813 /* Line 1778 of yacc.c */
2814 #line 592 "parse-gram.y"
2815 { (yyval.named_ref) = named_ref_new((yyvsp[(1) - (1)].uniqstr), (yylsp[(1) - (1)])); }
2816 break;
2817
2818 case 96:
2819 /* Line 1778 of yacc.c */
2820 #line 604 "parse-gram.y"
2821 { (yyval.uniqstr) = uniqstr_new ((yyvsp[(1) - (1)].chars)); }
2822 break;
2823
2824 case 97:
2825 /* Line 1778 of yacc.c */
2826 #line 609 "parse-gram.y"
2827 { (yyval.chars) = ""; }
2828 break;
2829
2830 case 98:
2831 /* Line 1778 of yacc.c */
2832 #line 610 "parse-gram.y"
2833 { (yyval.chars) = (yyvsp[(1) - (1)].uniqstr); }
2834 break;
2835
2836 case 100:
2837 /* Line 1778 of yacc.c */
2838 #line 621 "parse-gram.y"
2839 {
2840 code_props plain_code;
2841 (yyvsp[(1) - (1)].code)[strlen ((yyvsp[(1) - (1)].code)) - 1] = '\n';
2842 code_props_plain_init (&plain_code, (yyvsp[(1) - (1)].code)+1, (yylsp[(1) - (1)]));
2843 code_props_translate_code (&plain_code);
2844 gram_scanner_last_string_free ();
2845 (yyval.chars) = plain_code.code;
2846 }
2847 break;
2848
2849 case 101:
2850 /* Line 1778 of yacc.c */
2851 #line 641 "parse-gram.y"
2852 { (yyval.symbol) = symbol_from_uniqstr ((yyvsp[(1) - (1)].uniqstr), (yylsp[(1) - (1)])); }
2853 break;
2854
2855 case 102:
2856 /* Line 1778 of yacc.c */
2857 #line 643 "parse-gram.y"
2858 {
2859 (yyval.symbol) = symbol_get (char_name ((yyvsp[(1) - (1)].character)), (yylsp[(1) - (1)]));
2860 symbol_class_set ((yyval.symbol), token_sym, (yylsp[(1) - (1)]), false);
2861 symbol_user_token_number_set ((yyval.symbol), (yyvsp[(1) - (1)].character), (yylsp[(1) - (1)]));
2862 }
2863 break;
2864
2865 case 103:
2866 /* Line 1778 of yacc.c */
2867 #line 651 "parse-gram.y"
2868 { (yyval.symbol) = symbol_from_uniqstr ((yyvsp[(1) - (1)].uniqstr), (yylsp[(1) - (1)])); }
2869 break;
2870
2871 case 106:
2872 /* Line 1778 of yacc.c */
2873 #line 663 "parse-gram.y"
2874 {
2875 (yyval.symbol) = symbol_get (quotearg_style (c_quoting_style, (yyvsp[(1) - (1)].chars)), (yylsp[(1) - (1)]));
2876 symbol_class_set ((yyval.symbol), token_sym, (yylsp[(1) - (1)]), false);
2877 }
2878 break;
2879
2880 case 108:
2881 /* Line 1778 of yacc.c */
2882 #line 672 "parse-gram.y"
2883 {
2884 code_props plain_code;
2885 code_props_plain_init (&plain_code, (yyvsp[(2) - (2)].chars), (yylsp[(2) - (2)]));
2886 code_props_translate_code (&plain_code);
2887 gram_scanner_last_string_free ();
2888 muscle_code_grow ("epilogue", plain_code.code, (yylsp[(2) - (2)]));
2889 code_scanner_last_string_free ();
2890 }
2891 break;
2892
2893
2894 /* Line 1778 of yacc.c */
2895 #line 2896 "parse-gram.c"
2896 default: break;
2897 }
2898 if (yychar_backup != yychar)
2899 YY_LAC_DISCARD ("yychar change");
2900 }
2901 /* User semantic actions sometimes alter yychar, and that requires
2902 that yytoken be updated with the new translation. We take the
2903 approach of translating immediately before every use of yytoken.
2904 One alternative is translating here after every semantic action,
2905 but that translation would be missed if the semantic action invokes
2906 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2907 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2908 incorrect destructor might then be invoked immediately. In the
2909 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2910 to an incorrect destructor call or verbose syntax error message
2911 before the lookahead is translated. */
2912 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2913
2914 YYPOPSTACK (yylen);
2915 yylen = 0;
2916 YY_STACK_PRINT (yyss, yyssp);
2917
2918 *++yyvsp = yyval;
2919 *++yylsp = yyloc;
2920
2921 /* Now `shift' the result of the reduction. Determine what state
2922 that goes to, based on the state we popped back to and the rule
2923 number reduced by. */
2924
2925 yyn = yyr1[yyn];
2926
2927 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2928 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2929 yystate = yytable[yystate];
2930 else
2931 yystate = yydefgoto[yyn - YYNTOKENS];
2932
2933 goto yynewstate;
2934
2935
2936 /*------------------------------------.
2937 | yyerrlab -- here on detecting error |
2938 `------------------------------------*/
2939 yyerrlab:
2940 /* Make sure we have latest lookahead translation. See comments at
2941 user semantic actions for why this is necessary. */
2942 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2943
2944 /* If not already recovering from an error, report this error. */
2945 if (!yyerrstatus)
2946 {
2947 ++yynerrs;
2948 #if ! YYERROR_VERBOSE
2949 yyerror (YY_("syntax error"));
2950 #else
2951 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2952 yyesa, &yyes, &yyes_capacity, \
2953 yyssp, yytoken)
2954 {
2955 char const *yymsgp = YY_("syntax error");
2956 int yysyntax_error_status;
2957 if (yychar != YYEMPTY)
2958 YY_LAC_ESTABLISH;
2959 yysyntax_error_status = YYSYNTAX_ERROR;
2960 if (yysyntax_error_status == 0)
2961 yymsgp = yymsg;
2962 else if (yysyntax_error_status == 1)
2963 {
2964 if (yymsg != yymsgbuf)
2965 YYSTACK_FREE (yymsg);
2966 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2967 if (!yymsg)
2968 {
2969 yymsg = yymsgbuf;
2970 yymsg_alloc = sizeof yymsgbuf;
2971 yysyntax_error_status = 2;
2972 }
2973 else
2974 {
2975 yysyntax_error_status = YYSYNTAX_ERROR;
2976 yymsgp = yymsg;
2977 }
2978 }
2979 yyerror (yymsgp);
2980 if (yysyntax_error_status == 2)
2981 goto yyexhaustedlab;
2982 }
2983 # undef YYSYNTAX_ERROR
2984 #endif
2985 }
2986
2987 yyerror_range[1] = yylloc;
2988
2989 if (yyerrstatus == 3)
2990 {
2991 /* If just tried and failed to reuse lookahead token after an
2992 error, discard it. */
2993
2994 if (yychar <= YYEOF)
2995 {
2996 /* Return failure if at end of input. */
2997 if (yychar == YYEOF)
2998 YYABORT;
2999 }
3000 else
3001 {
3002 yydestruct ("Error: discarding",
3003 yytoken, &yylval, &yylloc);
3004 yychar = YYEMPTY;
3005 }
3006 }
3007
3008 /* Else will try to reuse lookahead token after shifting the error
3009 token. */
3010 goto yyerrlab1;
3011
3012
3013 /*---------------------------------------------------.
3014 | yyerrorlab -- error raised explicitly by YYERROR. |
3015 `---------------------------------------------------*/
3016 yyerrorlab:
3017
3018 /* Pacify compilers like GCC when the user code never invokes
3019 YYERROR and the label yyerrorlab therefore never appears in user
3020 code. */
3021 if (/*CONSTCOND*/ 0)
3022 goto yyerrorlab;
3023
3024 yyerror_range[1] = yylsp[1-yylen];
3025 /* Do not reclaim the symbols of the rule which action triggered
3026 this YYERROR. */
3027 YYPOPSTACK (yylen);
3028 yylen = 0;
3029 YY_STACK_PRINT (yyss, yyssp);
3030 yystate = *yyssp;
3031 goto yyerrlab1;
3032
3033
3034 /*-------------------------------------------------------------.
3035 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3036 `-------------------------------------------------------------*/
3037 yyerrlab1:
3038 yyerrstatus = 3; /* Each real token shifted decrements this. */
3039
3040 for (;;)
3041 {
3042 yyn = yypact[yystate];
3043 if (!yypact_value_is_default (yyn))
3044 {
3045 yyn += YYTERROR;
3046 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3047 {
3048 yyn = yytable[yyn];
3049 if (0 < yyn)
3050 break;
3051 }
3052 }
3053
3054 /* Pop the current state because it cannot handle the error token. */
3055 if (yyssp == yyss)
3056 YYABORT;
3057
3058 yyerror_range[1] = *yylsp;
3059 yydestruct ("Error: popping",
3060 yystos[yystate], yyvsp, yylsp);
3061 YYPOPSTACK (1);
3062 yystate = *yyssp;
3063 YY_STACK_PRINT (yyss, yyssp);
3064 }
3065
3066 /* If the stack popping above didn't lose the initial context for the
3067 current lookahead token, the shift below will for sure. */
3068 YY_LAC_DISCARD ("error recovery");
3069
3070 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3071 *++yyvsp = yylval;
3072 YY_IGNORE_MAYBE_UNINITIALIZED_END
3073
3074 yyerror_range[2] = yylloc;
3075 /* Using YYLLOC is tempting, but would change the location of
3076 the lookahead. YYLOC is available though. */
3077 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
3078 *++yylsp = yyloc;
3079
3080 /* Shift the error token. */
3081 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3082
3083 yystate = yyn;
3084 goto yynewstate;
3085
3086
3087 /*-------------------------------------.
3088 | yyacceptlab -- YYACCEPT comes here. |
3089 `-------------------------------------*/
3090 yyacceptlab:
3091 yyresult = 0;
3092 goto yyreturn;
3093
3094 /*-----------------------------------.
3095 | yyabortlab -- YYABORT comes here. |
3096 `-----------------------------------*/
3097 yyabortlab:
3098 yyresult = 1;
3099 goto yyreturn;
3100
3101 #if 1
3102 /*-------------------------------------------------.
3103 | yyexhaustedlab -- memory exhaustion comes here. |
3104 `-------------------------------------------------*/
3105 yyexhaustedlab:
3106 yyerror (YY_("memory exhausted"));
3107 yyresult = 2;
3108 /* Fall through. */
3109 #endif
3110
3111 yyreturn:
3112 if (yychar != YYEMPTY)
3113 {
3114 /* Make sure we have latest lookahead translation. See comments at
3115 user semantic actions for why this is necessary. */
3116 yytoken = YYTRANSLATE (yychar);
3117 yydestruct ("Cleanup: discarding lookahead",
3118 yytoken, &yylval, &yylloc);
3119 }
3120 /* Do not reclaim the symbols of the rule which action triggered
3121 this YYABORT or YYACCEPT. */
3122 YYPOPSTACK (yylen);
3123 YY_STACK_PRINT (yyss, yyssp);
3124 while (yyssp != yyss)
3125 {
3126 yydestruct ("Cleanup: popping",
3127 yystos[*yyssp], yyvsp, yylsp);
3128 YYPOPSTACK (1);
3129 }
3130 #ifndef yyoverflow
3131 if (yyss != yyssa)
3132 YYSTACK_FREE (yyss);
3133 #endif
3134 if (yyes != yyesa)
3135 YYSTACK_FREE (yyes);
3136 #if YYERROR_VERBOSE
3137 if (yymsg != yymsgbuf)
3138 YYSTACK_FREE (yymsg);
3139 #endif
3140 /* Make sure YYID is used. */
3141 return YYID (yyresult);
3142 }
3143
3144
3145 /* Line 2041 of yacc.c */
3146 #line 682 "parse-gram.y"
3147
3148
3149
3150 /* Return the location of the left-hand side of a rule whose
3151 right-hand side is RHS[1] ... RHS[N]. Ignore empty nonterminals in
3152 the right-hand side, and return an empty location equal to the end
3153 boundary of RHS[0] if the right-hand side is empty. */
3154
3155 static YYLTYPE
lloc_default(YYLTYPE const * rhs,int n)3156 lloc_default (YYLTYPE const *rhs, int n)
3157 {
3158 int i;
3159 YYLTYPE loc;
3160
3161 /* SGI MIPSpro 7.4.1m miscompiles "loc.start = loc.end = rhs[n].end;".
3162 The bug is fixed in 7.4.2m, but play it safe for now. */
3163 loc.start = rhs[n].end;
3164 loc.end = rhs[n].end;
3165
3166 /* Ignore empty nonterminals the start of the right-hand side.
3167 Do not bother to ignore them at the end of the right-hand side,
3168 since empty nonterminals have the same end as their predecessors. */
3169 for (i = 1; i <= n; i++)
3170 if (! equal_boundaries (rhs[i].start, rhs[i].end))
3171 {
3172 loc.start = rhs[i].start;
3173 break;
3174 }
3175
3176 return loc;
3177 }
3178
3179
3180 /* Add a lex-param or a parse-param (depending on TYPE) with
3181 declaration DECL and location LOC. */
3182
3183 static void
add_param(char const * type,char * decl,location loc)3184 add_param (char const *type, char *decl, location loc)
3185 {
3186 static char const alphanum[26 + 26 + 1 + 10] =
3187 "abcdefghijklmnopqrstuvwxyz"
3188 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
3189 "_"
3190 "0123456789";
3191 char const *name_start = NULL;
3192 char *p;
3193
3194 /* Stop on last actual character. */
3195 for (p = decl; p[1]; p++)
3196 if ((p == decl
3197 || ! memchr (alphanum, p[-1], sizeof alphanum))
3198 && memchr (alphanum, p[0], sizeof alphanum - 10))
3199 name_start = p;
3200
3201 /* Strip the surrounding '{' and '}', and any blanks just inside
3202 the braces. */
3203 --p;
3204 while (c_isspace ((unsigned char) *p))
3205 --p;
3206 p[1] = '\0';
3207 ++decl;
3208 while (c_isspace ((unsigned char) *decl))
3209 ++decl;
3210
3211 if (! name_start)
3212 complain_at (loc, _("missing identifier in parameter declaration"));
3213 else
3214 {
3215 char *name = xmemdup0 (name_start, strspn (name_start, alphanum));
3216 muscle_pair_list_grow (type, decl, name);
3217 free (name);
3218 }
3219
3220 gram_scanner_last_string_free ();
3221 }
3222
3223
3224 static void
version_check(location const * loc,char const * version)3225 version_check (location const *loc, char const *version)
3226 {
3227 if (strverscmp (version, PACKAGE_VERSION) > 0)
3228 {
3229 complain_at (*loc, "require bison %s, but have %s",
3230 version, PACKAGE_VERSION);
3231 exit (EX_MISMATCH);
3232 }
3233 }
3234
3235 static void
gram_error(location const * loc,char const * msg)3236 gram_error (location const *loc, char const *msg)
3237 {
3238 complain_at (*loc, "%s", msg);
3239 }
3240
3241 char const *
token_name(int type)3242 token_name (int type)
3243 {
3244 return yytname[YYTRANSLATE (type)];
3245 }
3246
3247 static char const *
char_name(char c)3248 char_name (char c)
3249 {
3250 if (c == '\'')
3251 return "'\\''";
3252 else
3253 {
3254 char buf[4];
3255 buf[0] = '\''; buf[1] = c; buf[2] = '\''; buf[3] = '\0';
3256 return quotearg_style (escape_quoting_style, buf);
3257 }
3258 }
3259