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