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