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