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