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