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