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