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