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