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