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