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