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