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