src/parse-gram.c

   1 /* A Bison parser, made from parse-gram.y
   2    by GNU bison 1.35.  */
   3
   4 #define YYBISON 1  /* Identify Bison output.  */
   5
   6 #define yyparse gram_parse
   7 #define yylex gram_lex
   8 #define yyerror gram_error
   9 #define yylval gram_lval
  10 #define yychar gram_char
  11 #define yydebug gram_debug
  12 #define yynerrs gram_nerrs
  13 #define YYLSP_NEEDED 1
  14
  15 # define        GRAM_EOF        0
  16 # define        STRING  257
  17 # define        CHARACTER       258
  18 # define        INT     259
  19 # define        PERCENT_TOKEN   260
  20 # define        PERCENT_NTERM   261
  21 # define        PERCENT_TYPE    262
  22 # define        PERCENT_UNION   263
  23 # define        PERCENT_EXPECT  264
  24 # define        PERCENT_START   265
  25 # define        PERCENT_LEFT    266
  26 # define        PERCENT_RIGHT   267
  27 # define        PERCENT_NONASSOC        268
  28 # define        PERCENT_PREC    269
  29 # define        PERCENT_VERBOSE 270
  30 # define        PERCENT_ERROR_VERBOSE   271
  31 # define        PERCENT_OUTPUT  272
  32 # define        PERCENT_FILE_PREFIX     273
  33 # define        PERCENT_NAME_PREFIX     274
  34 # define        PERCENT_DEFINE  275
  35 # define        PERCENT_PURE_PARSER     276
  36 # define        PERCENT_DEFINES 277
  37 # define        PERCENT_YACC    278
  38 # define        PERCENT_DEBUG   279
  39 # define        PERCENT_LOCATIONS       280
  40 # define        PERCENT_NO_LINES        281
  41 # define        PERCENT_SKELETON        282
  42 # define        PERCENT_TOKEN_TABLE     283
  43 # define        TYPE    284
  44 # define        EQUAL   285
  45 # define        SEMICOLON       286
  46 # define        COLON   287
  47 # define        PIPE    288
  48 # define        ID      289
  49 # define        PERCENT_PERCENT 290
  50 # define        PROLOGUE        291
  51 # define        EPILOGUE        292
  52 # define        BRACED_CODE     293
  53
  54 #line 31 "parse-gram.y"
  55
  56 #include "system.h"
  57 #include "muscle_tab.h"
  58 #include "files.h"
  59 #include "getargs.h"
  60 #include "output.h"
  61 #include "gram.h"
  62 #include "reader.h"
  63 #include "conflicts.h"
  64
  65 #define YYERROR_VERBOSE 1
  66
  67 /* Pass the control structure to YYPARSE and YYLEX. */
  68 #define YYPARSE_PARAM gram_control
  69 #define YYLEX_PARAM gram_control
  70 /* YYPARSE receives GRAM_CONTROL as a void *.  Provide a
  71    correctly typed access to it.  */
  72 #define yycontrol ((gram_control_t *) gram_control)
  73
  74 /* Request detailed parse error messages, and pass them to
  75    GRAM_ERROR. */
  76 #undef  yyerror
  77 #define yyerror(Msg) \
  78         gram_error (yycontrol, &yylloc, Msg)
  79
  80 /* When debugging our pure parser, we want to see values and locations
  81    of the tokens.  */
  82 #define YYPRINT(File, Type, Value) \
  83         yyprint (File, &yylloc, Type, &Value)
  84 static void yyprint (FILE *file, const yyltype *loc,
  85                      int type, const yystype *value);
  86
  87 symbol_class current_class = unknown_sym;
  88 char *current_type = 0;
  89 symbol_t *current_lhs;
  90 associativity current_assoc;
  91 int current_prec = 0;
  92
  93 #line 72 "parse-gram.y"
  94 #ifndef YYSTYPE
  95 typedef union
  96 {
  97   symbol_t *symbol;
  98   int integer;
  99   char *string;
 100   associativity assoc;
 101 } yystype;
 102 # define YYSTYPE yystype
 103 # define YYSTYPE_IS_TRIVIAL 1
 104 #endif
 105
 106 #ifndef YYLTYPE
 107 typedef struct yyltype
 108 {
 109   int first_line;
 110   int first_column;
 111
 112   int last_line;
 113   int last_column;
 114 } yyltype;
 115
 116 # define YYLTYPE yyltype
 117 # define YYLTYPE_IS_TRIVIAL 1
 118 #endif
 119
 120 #ifndef YYDEBUG
 121 # define YYDEBUG 1
 122 #endif
 123
 124
 125
 126 #define YYFINAL         94
 127 #define YYFLAG          -32768
 128 #define YYNTBASE        41
 129
 130 /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
 131 #define YYTRANSLATE(x) ((unsigned)(x) <= 293 ? yytranslate[x] : 68)
 132
 133 /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
 134 static const char yytranslate[] =
 135 {
 136        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 137        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 138        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 139        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 140        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 141        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 142        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 143        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 144        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 145        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 146        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 147        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 148        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 149        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 150        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 151        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 152        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 153        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 154        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 155        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 156        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 157        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 158        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 159        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 160        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 161        2,     2,     2,     2,     2,     2,     1,     4,     5,     6,
 162        7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 163       17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
 164       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
 165       37,    38,    39,    40
 166 };
 167
 168 #if YYDEBUG
 169 static const short yyprhs[] =
 170 {
 171        0,     0,     1,     7,     8,    11,    13,    15,    17,    21,
 172       23,    25,    28,    32,    34,    38,    40,    44,    46,    49,
 173       51,    53,    55,    57,    58,    62,    65,    66,    70,    71,
 174       76,    80,    81,    86,    88,    90,    92,    93,    95,    97,
 175      100,   102,   105,   107,   109,   112,   115,   119,   121,   124,
 176      126,   129,   130,   136,   138,   142,   143,   146,   149,   153,
 177      155,   157,   159,   161,   163,   165,   166,   169,   170
 178 };
 179 static const short yyrhs[] =
 180 {
 181       -1,    42,    43,    37,    57,    66,     0,     0,    43,    44,
 182        0,    45,     0,    38,     0,    26,     0,    22,    65,    65,
 183        0,    24,     0,    18,     0,    11,     6,     0,    20,    32,
 184       65,     0,    27,     0,    21,    32,    65,     0,    28,     0,
 185       19,    32,    65,     0,    23,     0,    29,    65,     0,    30,
 186        0,    17,     0,    25,     0,    49,     0,     0,     8,    46,
 187       56,     0,    12,    62,     0,     0,     7,    47,    56,     0,
 188        0,     9,    31,    48,    53,     0,    10,    40,    67,     0,
 189        0,    51,    52,    50,    54,     0,    13,     0,    14,     0,
 190       15,     0,     0,    31,     0,    36,     0,    53,    36,     0,
 191       62,     0,    54,    62,     0,    31,     0,    36,     0,    36,
 192        6,     0,    36,    64,     0,    36,     6,    64,     0,    55,
 193        0,    56,    55,     0,    58,     0,    57,    58,     0,     0,
 194       36,    34,    59,    60,    33,     0,    61,     0,    60,    35,
 195       61,     0,     0,    61,    62,     0,    61,    63,     0,    61,
 196       16,    62,     0,    36,     0,    64,     0,     5,     0,    40,
 197        0,     4,     0,     4,     0,     0,    37,    39,     0,     0,
 198       33,     0
 199 };
 200
 201 #endif
 202
 203 #if YYDEBUG
 204 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
 205 static const short yyrline[] =
 206 {
 207        0,   131,   131,   139,   141,   144,   146,   150,   151,   152,
 208      153,   154,   155,   156,   157,   158,   159,   160,   161,   162,
 209      163,   164,   167,   169,   169,   174,   178,   178,   183,   183,
 210      187,   195,   195,   202,   204,   205,   208,   210,   214,   216,
 211      220,   226,   235,   240,   245,   251,   257,   267,   270,   274,
 212      276,   279,   279,   284,   286,   289,   292,   294,   296,   300,
 213      302,   303,   306,   312,   321,   329,   334,   340,   342
 214 };
 215 #endif
 216
 217
 218 #if (YYDEBUG) || defined YYERROR_VERBOSE
 219
 220 /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
 221 static const char *const yytname[] =
 222 {
 223   "$", "error", "$undefined.", "\"end of string\"", "STRING", "CHARACTER",
 224   "INT", "\"%token\"", "\"%nterm\"", "\"%type\"", "\"%union\"",
 225   "\"%expect\"", "\"%start\"", "\"%left\"", "\"%right\"", "\"%nonassoc\"",
 226   "\"%prec\"", "\"%verbose\"", "\"%error-verbose\"", "\"%output\"",
 227   "\"%file-prefix\"", "\"%name-prefix\"", "\"%define\"",
 228   "\"%pure-parser\"", "\"%defines\"", "\"%yacc\"", "\"%debug\"",
 229   "\"%locations\"", "\"%no-lines\"", "\"%skeleton\"", "\"%token-table\"",
 230   "TYPE", "\"=\"", "\";\"", "\":\"", "\"|\"", "\"identifier\"", "\"%%\"",
 231   "PROLOGUE", "EPILOGUE", "BRACED_CODE", "input", "@1", "directives",
 232   "directive", "grammar_directives", "@2", "@3", "@4",
 233   "precedence_directives", "@5", "precedence_directive", "type.opt",
 234   "nterms_to_type.1", "terms_to_prec.1", "symbol_def", "symbol_defs.1",
 235   "gram", "rules", "@6", "rhses.1", "rhs", "symbol", "action",
 236   "string_as_id", "string_content", "epilogue.opt", "semi_colon_opt", 0
 237 };
 238 #endif
 239
 240 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
 241 static const short yyr1[] =
 242 {
 243        0,    42,    41,    43,    43,    44,    44,    44,    44,    44,
 244       44,    44,    44,    44,    44,    44,    44,    44,    44,    44,
 245       44,    44,    45,    46,    45,    45,    47,    45,    48,    45,
 246       45,    50,    49,    51,    51,    51,    52,    52,    53,    53,
 247       54,    54,    55,    55,    55,    55,    55,    56,    56,    57,
 248       57,    59,    58,    60,    60,    61,    61,    61,    61,    62,
 249       62,    62,    63,    64,    65,    66,    66,    67,    67
 250 };
 251
 252 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
 253 static const short yyr2[] =
 254 {
 255        0,     0,     5,     0,     2,     1,     1,     1,     3,     1,
 256        1,     2,     3,     1,     3,     1,     3,     1,     2,     1,
 257        1,     1,     1,     0,     3,     2,     0,     3,     0,     4,
 258        3,     0,     4,     1,     1,     1,     0,     1,     1,     2,
 259        1,     2,     1,     1,     2,     2,     3,     1,     2,     1,
 260        2,     0,     5,     1,     3,     0,     2,     2,     3,     1,
 261        1,     1,     1,     1,     1,     0,     2,     0,     1
 262 };
 263
 264 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
 265    doesn't specify something else to do.  Zero means the default is an
 266    error. */
 267 static const short yydefact[] =
 268 {
 269        1,     3,     0,    26,    23,     0,     0,     0,     0,    33,
 270       34,    35,    20,    10,     0,     0,     0,     0,    17,     9,
 271       21,     7,    13,    15,     0,    19,     0,     6,     4,     5,
 272       22,    36,     0,     0,    28,    67,    11,    63,    61,    59,
 273       25,    60,     0,     0,     0,    64,     0,    18,     0,    65,
 274       49,    37,    31,    42,    43,    47,    27,    24,     0,    68,
 275       30,    16,    12,    14,     8,    51,     0,    50,     2,     0,
 276       44,    45,    48,    38,    29,    55,    66,    32,    40,    46,
 277       39,     0,    53,    41,    52,    55,     0,    62,    56,    57,
 278       54,    58,     0,     0,     0
 279 };
 280
 281 static const short yydefgoto[] =
 282 {
 283       92,     1,     2,    28,    29,    33,    32,    58,    30,    69,
 284       31,    52,    74,    77,    55,    56,    49,    50,    75,    81,
 285       82,    88,    89,    41,    46,    68,    60
 286 };
 287
 288 static const short yypact[] =
 289 {
 290   -32768,-32768,    72,-32768,-32768,   -22,   -29,     8,    -1,-32768,
 291   -32768,-32768,-32768,-32768,   -16,   -14,   -11,    22,-32768,-32768,
 292   -32768,-32768,-32768,-32768,    22,-32768,    -6,-32768,-32768,-32768,
 293   -32768,     0,   -24,   -24,-32768,     1,-32768,-32768,-32768,-32768,
 294   -32768,-32768,    22,    22,    22,-32768,    22,-32768,    -2,   -17,
 295   -32768,-32768,-32768,-32768,     4,-32768,   -24,   -24,     2,-32768,
 296   -32768,-32768,-32768,-32768,-32768,-32768,     3,-32768,-32768,    -1,
 297       32,-32768,-32768,-32768,     5,-32768,-32768,    -1,-32768,-32768,
 298   -32768,   -18,    -3,-32768,-32768,-32768,    -1,-32768,-32768,-32768,
 299       -3,-32768,    39,    40,-32768
 300 };
 301
 302 static const short yypgoto[] =
 303 {
 304   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
 305   -32768,-32768,-32768,-32768,   -28,    10,-32768,    -5,-32768,-32768,
 306      -40,    -8,-32768,   -48,   -19,-32768,-32768
 307 };
 308
 309
 310 #define YYLAST          110
 311
 312
 313 static const short yytable[] =
 314 {
 315       40,    37,    38,    37,    38,    47,    71,    53,    37,    34,
 316       70,    35,    54,    86,    36,    84,    42,    85,    43,    48,
 317       66,    44,    79,    61,    62,    63,    45,    64,    72,    72,
 318       48,    51,    65,    39,    59,    39,    37,    87,    73,    93,
 319       94,    80,    76,    57,    67,    90,     0,     0,     0,     0,
 320        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 321        0,    78,     0,     0,     0,     0,     0,     0,     0,    83,
 322        0,     0,     0,     0,     0,     0,     0,     0,    91,     3,
 323        4,     5,     6,     7,     8,     9,    10,    11,     0,    12,
 324       13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
 325       23,    24,    25,     0,     0,     0,     0,     0,     0,    26,
 326       27
 327 };
 328
 329 static const short yycheck[] =
 330 {
 331        8,     4,     5,     4,     5,    24,    54,    31,     4,    31,
 332        6,    40,    36,    16,     6,    33,    32,    35,    32,    36,
 333       37,    32,    70,    42,    43,    44,     4,    46,    56,    57,
 334       36,    31,    34,    36,    33,    36,     4,    40,    36,     0,
 335        0,    36,    39,    33,    49,    85,    -1,    -1,    -1,    -1,
 336       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 337       -1,    69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    77,
 338       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    86,     7,
 339        8,     9,    10,    11,    12,    13,    14,    15,    -1,    17,
 340       18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
 341       28,    29,    30,    -1,    -1,    -1,    -1,    -1,    -1,    37,
 342       38
 343 };
 344 #define YYPURE 1
 345
 346 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 347 #line 3 "/usr/share/bison/bison.simple"
 348
 349 /* Skeleton output parser for bison,
 350
 351    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
 352    Foundation, Inc.
 353
 354    This program is free software; you can redistribute it and/or modify
 355    it under the terms of the GNU General Public License as published by
 356    the Free Software Foundation; either version 2, or (at your option)
 357    any later version.
 358
 359    This program is distributed in the hope that it will be useful,
 360    but WITHOUT ANY WARRANTY; without even the implied warranty of
 361    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 362    GNU General Public License for more details.
 363
 364    You should have received a copy of the GNU General Public License
 365    along with this program; if not, write to the Free Software
 366    Foundation, Inc., 59 Temple Place - Suite 330,
 367    Boston, MA 02111-1307, USA.  */
 368
 369 /* As a special exception, when this file is copied by Bison into a
 370    Bison output file, you may use that output file without restriction.
 371    This special exception was added by the Free Software Foundation
 372    in version 1.24 of Bison.  */
 373
 374 /* This is the parser code that is written into each bison parser when
 375    the %semantic_parser declaration is not specified in the grammar.
 376    It was written by Richard Stallman by simplifying the hairy parser
 377    used when %semantic_parser is specified.  */
 378
 379 /* All symbols defined below should begin with yy or YY, to avoid
 380    infringing on user name space.  This should be done even for local
 381    variables, as they might otherwise be expanded by user macros.
 382    There are some unavoidable exceptions within include files to
 383    define necessary library symbols; they are noted "INFRINGES ON
 384    USER NAME SPACE" below.  */
 385
 386 #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
 387
 388 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 389
 390 # if YYSTACK_USE_ALLOCA
 391 #  define YYSTACK_ALLOC alloca
 392 # else
 393 #  ifndef YYSTACK_USE_ALLOCA
 394 #   if defined (alloca) || defined (_ALLOCA_H)
 395 #    define YYSTACK_ALLOC alloca
 396 #   else
 397 #    ifdef __GNUC__
 398 #     define YYSTACK_ALLOC __builtin_alloca
 399 #    endif
 400 #   endif
 401 #  endif
 402 # endif
 403
 404 # ifdef YYSTACK_ALLOC
 405    /* Pacify GCC's `empty if-body' warning. */
 406 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 407 # else
 408 #  if defined (__STDC__) || defined (__cplusplus)
 409 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 410 #   define YYSIZE_T size_t
 411 #  endif
 412 #  define YYSTACK_ALLOC malloc
 413 #  define YYSTACK_FREE free
 414 # endif
 415 #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
 416
 417
 418 #if (! defined (yyoverflow) \
 419      && (! defined (__cplusplus) \
 420          || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 421
 422 /* A type that is properly aligned for any stack member.  */
 423 union yyalloc
 424 {
 425   short yyss;
 426   YYSTYPE yyvs;
 427 # if YYLSP_NEEDED
 428   YYLTYPE yyls;
 429 # endif
 430 };
 431
 432 /* The size of the maximum gap between one aligned stack and the next.  */
 433 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
 434
 435 /* The size of an array large to enough to hold all stacks, each with
 436    N elements.  */
 437 # if YYLSP_NEEDED
 438 #  define YYSTACK_BYTES(N) \
 439      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
 440       + 2 * YYSTACK_GAP_MAX)
 441 # else
 442 #  define YYSTACK_BYTES(N) \
 443      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
 444       + YYSTACK_GAP_MAX)
 445 # endif
 446
 447 /* Copy COUNT objects from FROM to TO.  The source and destination do
 448    not overlap.  */
 449 # ifndef YYCOPY
 450 #  if 1 < __GNUC__
 451 #   define YYCOPY(To, From, Count) \
 452       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 453 #  else
 454 #   define YYCOPY(To, From, Count)              \
 455       do                                        \
 456         {                                       \
 457           register YYSIZE_T yyi;                \
 458           for (yyi = 0; yyi < (Count); yyi++)   \
 459             (To)[yyi] = (From)[yyi];            \
 460         }                                       \
 461       while (0)
 462 #  endif
 463 # endif
 464
 465 /* Relocate STACK from its old location to the new one.  The
 466    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 467    elements in the stack, and YYPTR gives the new location of the
 468    stack.  Advance YYPTR to a properly aligned location for the next
 469    stack.  */
 470 # define YYSTACK_RELOCATE(Stack)                                        \
 471     do                                                                  \
 472       {                                                                 \
 473         YYSIZE_T yynewbytes;                                            \
 474         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 475         Stack = &yyptr->Stack;                                          \
 476         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
 477         yyptr += yynewbytes / sizeof (*yyptr);                          \
 478       }                                                                 \
 479     while (0)
 480
 481 #endif
 482
 483
 484 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 485 # define YYSIZE_T __SIZE_TYPE__
 486 #endif
 487 #if ! defined (YYSIZE_T) && defined (size_t)
 488 # define YYSIZE_T size_t
 489 #endif
 490 #if ! defined (YYSIZE_T)
 491 # if defined (__STDC__) || defined (__cplusplus)
 492 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 493 #  define YYSIZE_T size_t
 494 # endif
 495 #endif
 496 #if ! defined (YYSIZE_T)
 497 # define YYSIZE_T unsigned int
 498 #endif
 499
 500 #define yyerrok         (yyerrstatus = 0)
 501 #define yyclearin       (yychar = YYEMPTY)
 502 #define YYEMPTY         -2
 503 #define YYEOF           0
 504 #define YYACCEPT        goto yyacceptlab
 505 #define YYABORT         goto yyabortlab
 506 #define YYERROR         goto yyerrlab1
 507 /* Like YYERROR except do call yyerror.  This remains here temporarily
 508    to ease the transition to the new meaning of YYERROR, for GCC.
 509    Once GCC version 2 has supplanted version 1, this can go.  */
 510 #define YYFAIL          goto yyerrlab
 511 #define YYRECOVERING()  (!!yyerrstatus)
 512 #define YYBACKUP(Token, Value)                                  \
 513 do                                                              \
 514   if (yychar == YYEMPTY && yylen == 1)                          \
 515     {                                                           \
 516       yychar = (Token);                                         \
 517       yylval = (Value);                                         \
 518       yychar1 = YYTRANSLATE (yychar);                           \
 519       YYPOPSTACK;                                               \
 520       goto yybackup;                                            \
 521     }                                                           \
 522   else                                                          \
 523     {                                                           \
 524       yyerror ("syntax error: cannot back up");                 \
 525       YYERROR;                                                  \
 526     }                                                           \
 527 while (0)
 528
 529 #define YYTERROR        1
 530 #define YYERRCODE       256
 531
 532
 533 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 534    are run).
 535
 536    When YYLLOC_DEFAULT is run, CURRENT is set the location of the
 537    first token.  By default, to implement support for ranges, extend
 538    its range to the last symbol.  */
 539
 540 #ifndef YYLLOC_DEFAULT
 541 # define YYLLOC_DEFAULT(Current, Rhs, N)        \
 542    Current.last_line   = Rhs[N].last_line;      \
 543    Current.last_column = Rhs[N].last_column;
 544 #endif
 545
 546
 547 /* YYLEX -- calling `yylex' with the right arguments.  */
 548
 549 #if YYPURE
 550 # if YYLSP_NEEDED
 551 #  ifdef YYLEX_PARAM
 552 #   define YYLEX                yylex (&yylval, &yylloc, YYLEX_PARAM)
 553 #  else
 554 #   define YYLEX                yylex (&yylval, &yylloc)
 555 #  endif
 556 # else /* !YYLSP_NEEDED */
 557 #  ifdef YYLEX_PARAM
 558 #   define YYLEX                yylex (&yylval, YYLEX_PARAM)
 559 #  else
 560 #   define YYLEX                yylex (&yylval)
 561 #  endif
 562 # endif /* !YYLSP_NEEDED */
 563 #else /* !YYPURE */
 564 # define YYLEX                  yylex ()
 565 #endif /* !YYPURE */
 566
 567
 568 /* Enable debugging if requested.  */
 569 #if YYDEBUG
 570
 571 # ifndef YYFPRINTF
 572 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 573 #  define YYFPRINTF fprintf
 574 # endif
 575
 576 # define YYDPRINTF(Args)                        \
 577 do {                                            \
 578   if (yydebug)                                  \
 579     YYFPRINTF Args;                             \
 580 } while (0)
 581 /* Nonzero means print parse trace.  It is left uninitialized so that
 582    multiple parsers can coexist.  */
 583 int yydebug;
 584 #else /* !YYDEBUG */
 585 # define YYDPRINTF(Args)
 586 #endif /* !YYDEBUG */
 587
 588 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 589 #ifndef YYINITDEPTH
 590 # define YYINITDEPTH 200
 591 #endif
 592
 593 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 594    if the built-in stack extension method is used).
 595
 596    Do not make this value too large; the results are undefined if
 597    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
 598    evaluated with infinite-precision integer arithmetic.  */
 599
 600 #if YYMAXDEPTH == 0
 601 # undef YYMAXDEPTH
 602 #endif
 603
 604 #ifndef YYMAXDEPTH
 605 # define YYMAXDEPTH 10000
 606 #endif
 607 \f
 608 #ifdef YYERROR_VERBOSE
 609
 610 # ifndef yystrlen
 611 #  if defined (__GLIBC__) && defined (_STRING_H)
 612 #   define yystrlen strlen
 613 #  else
 614 /* Return the length of YYSTR.  */
 615 static YYSIZE_T
 616 #   if defined (__STDC__) || defined (__cplusplus)
 617 yystrlen (const char *yystr)
 618 #   else
 619 yystrlen (yystr)
 620      const char *yystr;
 621 #   endif
 622 {
 623   register const char *yys = yystr;
 624
 625   while (*yys++ != '\0')
 626     continue;
 627
 628   return yys - yystr - 1;
 629 }
 630 #  endif
 631 # endif
 632
 633 # ifndef yystpcpy
 634 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
 635 #   define yystpcpy stpcpy
 636 #  else
 637 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 638    YYDEST.  */
 639 static char *
 640 #   if defined (__STDC__) || defined (__cplusplus)
 641 yystpcpy (char *yydest, const char *yysrc)
 642 #   else
 643 yystpcpy (yydest, yysrc)
 644      char *yydest;
 645      const char *yysrc;
 646 #   endif
 647 {
 648   register char *yyd = yydest;
 649   register const char *yys = yysrc;
 650
 651   while ((*yyd++ = *yys++) != '\0')
 652     continue;
 653
 654   return yyd - 1;
 655 }
 656 #  endif
 657 # endif
 658 #endif
 659 \f
 660 #line 315 "/usr/share/bison/bison.simple"
 661
 662
 663 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 664    into yyparse.  The argument should have type void *.
 665    It should actually point to an object.
 666    Grammar actions can access the variable by casting it
 667    to the proper pointer type.  */
 668
 669 #ifdef YYPARSE_PARAM
 670 # if defined (__STDC__) || defined (__cplusplus)
 671 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 672 #  define YYPARSE_PARAM_DECL
 673 # else
 674 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 675 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 676 # endif
 677 #else /* !YYPARSE_PARAM */
 678 # define YYPARSE_PARAM_ARG
 679 # define YYPARSE_PARAM_DECL
 680 #endif /* !YYPARSE_PARAM */
 681
 682 /* Prevent warning if -Wstrict-prototypes.  */
 683 #ifdef __GNUC__
 684 # ifdef YYPARSE_PARAM
 685 int yyparse (void *);
 686 # else
 687 int yyparse (void);
 688 # endif
 689 #endif
 690
 691 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
 692    variables are global, or local to YYPARSE.  */
 693
 694 #define YY_DECL_NON_LSP_VARIABLES                       \
 695 /* The lookahead symbol.  */                            \
 696 int yychar;                                             \
 697                                                         \
 698 /* The semantic value of the lookahead symbol. */       \
 699 YYSTYPE yylval;                                         \
 700                                                         \
 701 /* Number of parse errors so far.  */                   \
 702 int yynerrs;
 703
 704 #if YYLSP_NEEDED
 705 # define YY_DECL_VARIABLES                      \
 706 YY_DECL_NON_LSP_VARIABLES                       \
 707                                                 \
 708 /* Location data for the lookahead symbol.  */  \
 709 YYLTYPE yylloc;
 710 #else
 711 # define YY_DECL_VARIABLES                      \
 712 YY_DECL_NON_LSP_VARIABLES
 713 #endif
 714
 715
 716 /* If nonreentrant, generate the variables here. */
 717
 718 #if !YYPURE
 719 YY_DECL_VARIABLES
 720 #endif  /* !YYPURE */
 721
 722 int
 723 yyparse (YYPARSE_PARAM_ARG)
 724      YYPARSE_PARAM_DECL
 725 {
 726   /* If reentrant, generate the variables here. */
 727 #if YYPURE
 728   YY_DECL_VARIABLES
 729 #endif  /* !YYPURE */
 730
 731   register int yystate;
 732   register int yyn;
 733   int yyresult;
 734   /* Number of tokens to shift before error messages enabled.  */
 735   int yyerrstatus;
 736   /* Lookahead token as an internal (translated) token number.  */
 737   int yychar1 = 0;
 738
 739   /* Three stacks and their tools:
 740      `yyss': related to states,
 741      `yyvs': related to semantic values,
 742      `yyls': related to locations.
 743
 744      Refer to the stacks thru separate pointers, to allow yyoverflow
 745      to reallocate them elsewhere.  */
 746
 747   /* The state stack. */
 748   short yyssa[YYINITDEPTH];
 749   short *yyss = yyssa;
 750   register short *yyssp;
 751
 752   /* The semantic value stack.  */
 753   YYSTYPE yyvsa[YYINITDEPTH];
 754   YYSTYPE *yyvs = yyvsa;
 755   register YYSTYPE *yyvsp;
 756
 757 #if YYLSP_NEEDED
 758   /* The location stack.  */
 759   YYLTYPE yylsa[YYINITDEPTH];
 760   YYLTYPE *yyls = yylsa;
 761   YYLTYPE *yylsp;
 762 #endif
 763
 764 #if YYLSP_NEEDED
 765 # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 766 #else
 767 # define YYPOPSTACK   (yyvsp--, yyssp--)
 768 #endif
 769
 770   YYSIZE_T yystacksize = YYINITDEPTH;
 771
 772
 773   /* The variables used to return semantic value and location from the
 774      action routines.  */
 775   YYSTYPE yyval;
 776 #if YYLSP_NEEDED
 777   YYLTYPE yyloc;
 778 #endif
 779
 780   /* When reducing, the number of symbols on the RHS of the reduced
 781      rule. */
 782   int yylen;
 783
 784   YYDPRINTF ((stderr, "Starting parse\n"));
 785
 786   yystate = 0;
 787   yyerrstatus = 0;
 788   yynerrs = 0;
 789   yychar = YYEMPTY;             /* Cause a token to be read.  */
 790
 791   /* Initialize stack pointers.
 792      Waste one element of value and location stack
 793      so that they stay on the same level as the state stack.
 794      The wasted elements are never initialized.  */
 795
 796   yyssp = yyss;
 797   yyvsp = yyvs;
 798 #if YYLSP_NEEDED
 799   yylsp = yyls;
 800 #endif
 801   goto yysetstate;
 802
 803 /*------------------------------------------------------------.
 804 | yynewstate -- Push a new state, which is found in yystate.  |
 805 `------------------------------------------------------------*/
 806  yynewstate:
 807   /* In all cases, when you get here, the value and location stacks
 808      have just been pushed. so pushing a state here evens the stacks.
 809      */
 810   yyssp++;
 811
 812  yysetstate:
 813   *yyssp = yystate;
 814
 815   if (yyssp >= yyss + yystacksize - 1)
 816     {
 817       /* Get the current used size of the three stacks, in elements.  */
 818       YYSIZE_T yysize = yyssp - yyss + 1;
 819
 820 #ifdef yyoverflow
 821       {
 822         /* Give user a chance to reallocate the stack. Use copies of
 823            these so that the &'s don't force the real ones into
 824            memory.  */
 825         YYSTYPE *yyvs1 = yyvs;
 826         short *yyss1 = yyss;
 827
 828         /* Each stack pointer address is followed by the size of the
 829            data in use in that stack, in bytes.  */
 830 # if YYLSP_NEEDED
 831         YYLTYPE *yyls1 = yyls;
 832         /* This used to be a conditional around just the two extra args,
 833            but that might be undefined if yyoverflow is a macro.  */
 834         yyoverflow ("parser stack overflow",
 835                     &yyss1, yysize * sizeof (*yyssp),
 836                     &yyvs1, yysize * sizeof (*yyvsp),
 837                     &yyls1, yysize * sizeof (*yylsp),
 838                     &yystacksize);
 839         yyls = yyls1;
 840 # else
 841         yyoverflow ("parser stack overflow",
 842                     &yyss1, yysize * sizeof (*yyssp),
 843                     &yyvs1, yysize * sizeof (*yyvsp),
 844                     &yystacksize);
 845 # endif
 846         yyss = yyss1;
 847         yyvs = yyvs1;
 848       }
 849 #else /* no yyoverflow */
 850 # ifndef YYSTACK_RELOCATE
 851       goto yyoverflowlab;
 852 # else
 853       /* Extend the stack our own way.  */
 854       if (yystacksize >= YYMAXDEPTH)
 855         goto yyoverflowlab;
 856       yystacksize *= 2;
 857       if (yystacksize > YYMAXDEPTH)
 858         yystacksize = YYMAXDEPTH;
 859
 860       {
 861         short *yyss1 = yyss;
 862         union yyalloc *yyptr =
 863           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
 864         if (! yyptr)
 865           goto yyoverflowlab;
 866         YYSTACK_RELOCATE (yyss);
 867         YYSTACK_RELOCATE (yyvs);
 868 # if YYLSP_NEEDED
 869         YYSTACK_RELOCATE (yyls);
 870 # endif
 871 # undef YYSTACK_RELOCATE
 872         if (yyss1 != yyssa)
 873           YYSTACK_FREE (yyss1);
 874       }
 875 # endif
 876 #endif /* no yyoverflow */
 877
 878       yyssp = yyss + yysize - 1;
 879       yyvsp = yyvs + yysize - 1;
 880 #if YYLSP_NEEDED
 881       yylsp = yyls + yysize - 1;
 882 #endif
 883
 884       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
 885                   (unsigned long int) yystacksize));
 886
 887       if (yyssp >= yyss + yystacksize - 1)
 888         YYABORT;
 889     }
 890
 891   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 892
 893   goto yybackup;
 894
 895
 896 /*-----------.
 897 | yybackup.  |
 898 `-----------*/
 899 yybackup:
 900
 901 /* Do appropriate processing given the current state.  */
 902 /* Read a lookahead token if we need one and don't already have one.  */
 903 /* yyresume: */
 904
 905   /* First try to decide what to do without reference to lookahead token.  */
 906
 907   yyn = yypact[yystate];
 908   if (yyn == YYFLAG)
 909     goto yydefault;
 910
 911   /* Not known => get a lookahead token if don't already have one.  */
 912
 913   /* yychar is either YYEMPTY or YYEOF
 914      or a valid token in external form.  */
 915
 916   if (yychar == YYEMPTY)
 917     {
 918       YYDPRINTF ((stderr, "Reading a token: "));
 919       yychar = YYLEX;
 920     }
 921
 922   /* Convert token to internal form (in yychar1) for indexing tables with */
 923
 924   if (yychar <= 0)              /* This means end of input. */
 925     {
 926       yychar1 = 0;
 927       yychar = YYEOF;           /* Don't call YYLEX any more */
 928
 929       YYDPRINTF ((stderr, "Now at end of input.\n"));
 930     }
 931   else
 932     {
 933       yychar1 = YYTRANSLATE (yychar);
 934
 935 #if YYDEBUG
 936      /* We have to keep this `#if YYDEBUG', since we use variables
 937         which are defined only if `YYDEBUG' is set.  */
 938       if (yydebug)
 939         {
 940           YYFPRINTF (stderr, "Next token is %d (%s",
 941                      yychar, yytname[yychar1]);
 942           /* Give the individual parser a way to print the precise
 943              meaning of a token, for further debugging info.  */
 944 # ifdef YYPRINT
 945           YYPRINT (stderr, yychar, yylval);
 946 # endif
 947           YYFPRINTF (stderr, ")\n");
 948         }
 949 #endif
 950     }
 951
 952   yyn += yychar1;
 953   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 954     goto yydefault;
 955
 956   yyn = yytable[yyn];
 957
 958   /* yyn is what to do for this token type in this state.
 959      Negative => reduce, -yyn is rule number.
 960      Positive => shift, yyn is new state.
 961        New state is final state => don't bother to shift,
 962        just return success.
 963      0, or most negative number => error.  */
 964
 965   if (yyn < 0)
 966     {
 967       if (yyn == YYFLAG)
 968         goto yyerrlab;
 969       yyn = -yyn;
 970       goto yyreduce;
 971     }
 972   else if (yyn == 0)
 973     goto yyerrlab;
 974
 975   if (yyn == YYFINAL)
 976     YYACCEPT;
 977
 978   /* Shift the lookahead token.  */
 979   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
 980               yychar, yytname[yychar1]));
 981
 982   /* Discard the token being shifted unless it is eof.  */
 983   if (yychar != YYEOF)
 984     yychar = YYEMPTY;
 985
 986   *++yyvsp = yylval;
 987 #if YYLSP_NEEDED
 988   *++yylsp = yylloc;
 989 #endif
 990
 991   /* Count tokens shifted since error; after three, turn off error
 992      status.  */
 993   if (yyerrstatus)
 994     yyerrstatus--;
 995
 996   yystate = yyn;
 997   goto yynewstate;
 998
 999
1000 /*-----------------------------------------------------------.
1001 | yydefault -- do the default action for the current state.  |
1002 `-----------------------------------------------------------*/
1003 yydefault:
1004   yyn = yydefact[yystate];
1005   if (yyn == 0)
1006     goto yyerrlab;
1007   goto yyreduce;
1008
1009
1010 /*-----------------------------.
1011 | yyreduce -- Do a reduction.  |
1012 `-----------------------------*/
1013 yyreduce:
1014   /* yyn is the number of a rule to reduce with.  */
1015   yylen = yyr2[yyn];
1016
1017   /* If YYLEN is nonzero, implement the default value of the action:
1018      `$$ = $1'.
1019
1020      Otherwise, the following line sets YYVAL to the semantic value of
1021      the lookahead token.  This behavior is undocumented and Bison
1022      users should not rely upon it.  Assigning to YYVAL
1023      unconditionally makes the parser a bit smaller, and it avoids a
1024      GCC warning that YYVAL may be used uninitialized.  */
1025   yyval = yyvsp[1-yylen];
1026
1027 #if YYLSP_NEEDED
1028   /* Similarly for the default location.  Let the user run additional
1029      commands if for instance locations are ranges.  */
1030   yyloc = yylsp[1-yylen];
1031   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
1032 #endif
1033
1034 #if YYDEBUG
1035   /* We have to keep this `#if YYDEBUG', since we use variables which
1036      are defined only if `YYDEBUG' is set.  */
1037   if (yydebug)
1038     {
1039       int yyi;
1040
1041       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
1042                  yyn, yyrline[yyn]);
1043
1044       /* Print the symbols being reduced, and their result.  */
1045       for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
1046         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1047       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1048     }
1049 #endif
1050
1051   switch (yyn) {
1052
1053 case 1:
1054 #line 131 "parse-gram.y"
1055 { LOCATION_RESET (yylloc); }
1056     break;
1057 case 2:
1058 #line 133 "parse-gram.y"
1059 {
1060       yycontrol->errcode = 0;
1061       epilogue_set (yyvsp[0].string, yylsp[0].first_line);
1062     }
1063     break;
1064 case 6:
1065 #line 147 "parse-gram.y"
1066 {
1067      prologue_augment (yyvsp[0].string, yylsp[0].first_line);
1068    }
1069     break;
1070 case 7:
1071 #line 150 "parse-gram.y"
1072 { debug_flag = 1; }
1073     break;
1074 case 8:
1075 #line 151 "parse-gram.y"
1076 { muscle_insert (yyvsp[-1].string, yyvsp[0].string); }
1077     break;
1078 case 9:
1079 #line 152 "parse-gram.y"
1080 { defines_flag = 1; }
1081     break;
1082 case 10:
1083 #line 153 "parse-gram.y"
1084 { error_verbose = 1; }
1085     break;
1086 case 11:
1087 #line 154 "parse-gram.y"
1088 { expected_conflicts = yyvsp[0].integer; }
1089     break;
1090 case 12:
1091 #line 155 "parse-gram.y"
1092 { spec_file_prefix = yyvsp[0].string; }
1093     break;
1094 case 13:
1095 #line 156 "parse-gram.y"
1096 { locations_flag = 1; }
1097     break;
1098 case 14:
1099 #line 157 "parse-gram.y"
1100 { spec_name_prefix = yyvsp[0].string; }
1101     break;
1102 case 15:
1103 #line 158 "parse-gram.y"
1104 { no_lines_flag = 1; }
1105     break;
1106 case 16:
1107 #line 159 "parse-gram.y"
1108 { spec_outfile = yyvsp[0].string; }
1109     break;
1110 case 17:
1111 #line 160 "parse-gram.y"
1112 { pure_parser = 1; }
1113     break;
1114 case 18:
1115 #line 161 "parse-gram.y"
1116 { skeleton = yyvsp[0].string; }
1117     break;
1118 case 19:
1119 #line 162 "parse-gram.y"
1120 { token_table_flag = 1; }
1121     break;
1122 case 20:
1123 #line 163 "parse-gram.y"
1124 { report_flag = 1; }
1125     break;
1126 case 21:
1127 #line 164 "parse-gram.y"
1128 { yacc_flag = 1; }
1129     break;
1130 case 23:
1131 #line 169 "parse-gram.y"
1132 { current_class = nterm_sym; }
1133     break;
1134 case 24:
1135 #line 170 "parse-gram.y"
1136 {
1137       current_class = unknown_sym;
1138       current_type = NULL;
1139     }
1140     break;
1141 case 25:
1142 #line 175 "parse-gram.y"
1143 {
1144       grammar_start_symbol_set (yyvsp[0].symbol);
1145     }
1146     break;
1147 case 26:
1148 #line 178 "parse-gram.y"
1149 { current_class = token_sym; }
1150     break;
1151 case 27:
1152 #line 179 "parse-gram.y"
1153 {
1154       current_class = unknown_sym;
1155       current_type = NULL;
1156     }
1157     break;
1158 case 28:
1159 #line 183 "parse-gram.y"
1160 {current_type = yyvsp[0].string; }
1161     break;
1162 case 29:
1163 #line 184 "parse-gram.y"
1164 {
1165       current_type = NULL;
1166     }
1167     break;
1168 case 30:
1169 #line 188 "parse-gram.y"
1170 {
1171       typed = 1;
1172       MUSCLE_INSERT_INT ("stype_line", yylsp[-1].first_line);
1173       muscle_insert ("stype", yyvsp[-1].string);
1174     }
1175     break;
1176 case 31:
1177 #line 197 "parse-gram.y"
1178 { current_assoc = yyvsp[-1].assoc; ++current_prec; }
1179     break;
1180 case 32:
1181 #line 199 "parse-gram.y"
1182 { current_assoc = non_assoc; current_type = NULL; }
1183     break;
1184 case 33:
1185 #line 203 "parse-gram.y"
1186 { yyval.assoc = left_assoc; }
1187     break;
1188 case 34:
1189 #line 204 "parse-gram.y"
1190 { yyval.assoc = right_assoc; }
1191     break;
1192 case 35:
1193 #line 205 "parse-gram.y"
1194 { yyval.assoc = non_assoc; }
1195     break;
1196 case 36:
1197 #line 209 "parse-gram.y"
1198 { current_type = NULL;}
1199     break;
1200 case 37:
1201 #line 210 "parse-gram.y"
1202 { current_type = yyvsp[0].string; }
1203     break;
1204 case 38:
1205 #line 215 "parse-gram.y"
1206 { symbol_type_set (yyvsp[0].symbol, current_type); }
1207     break;
1208 case 39:
1209 #line 216 "parse-gram.y"
1210 { symbol_type_set (yyvsp[0].symbol, current_type); }
1211     break;
1212 case 40:
1213 #line 222 "parse-gram.y"
1214 {
1215       symbol_type_set (yyvsp[0].symbol, current_type);
1216       symbol_precedence_set (yyvsp[0].symbol, current_prec, current_assoc);
1217     }
1218     break;
1219 case 41:
1220 #line 227 "parse-gram.y"
1221 {
1222       symbol_type_set (yyvsp[0].symbol, current_type);
1223       symbol_precedence_set (yyvsp[0].symbol, current_prec, current_assoc);
1224     }
1225     break;
1226 case 42:
1227 #line 237 "parse-gram.y"
1228 {
1229        current_type = yyvsp[0].string;
1230      }
1231     break;
1232 case 43:
1233 #line 241 "parse-gram.y"
1234 {
1235        symbol_class_set (yyvsp[0].symbol, current_class);
1236        symbol_type_set (yyvsp[0].symbol, current_type);
1237      }
1238     break;
1239 case 44:
1240 #line 246 "parse-gram.y"
1241 {
1242       symbol_class_set (yyvsp[-1].symbol, current_class);
1243       symbol_type_set (yyvsp[-1].symbol, current_type);
1244       symbol_user_token_number_set (yyvsp[-1].symbol, yyvsp[0].integer);
1245     }
1246     break;
1247 case 45:
1248 #line 252 "parse-gram.y"
1249 {
1250       symbol_class_set (yyvsp[-1].symbol, current_class);
1251       symbol_type_set (yyvsp[-1].symbol, current_type);
1252       symbol_make_alias (yyvsp[-1].symbol, yyvsp[0].symbol);
1253     }
1254     break;
1255 case 46:
1256 #line 258 "parse-gram.y"
1257 {
1258       symbol_class_set (yyvsp[-2].symbol, current_class);
1259       symbol_type_set (yyvsp[-2].symbol, current_type);
1260       symbol_user_token_number_set (yyvsp[-2].symbol, yyvsp[-1].integer);
1261       symbol_make_alias (yyvsp[-2].symbol, yyvsp[0].symbol);
1262     }
1263     break;
1264 case 47:
1265 #line 269 "parse-gram.y"
1266 {;}
1267     break;
1268 case 48:
1269 #line 271 "parse-gram.y"
1270 {;}
1271     break;
1272 case 51:
1273 #line 280 "parse-gram.y"
1274 { current_lhs = yyvsp[-1].symbol; }
1275     break;
1276 case 52:
1277 #line 281 "parse-gram.y"
1278 {;}
1279     break;
1280 case 53:
1281 #line 285 "parse-gram.y"
1282 { grammar_rule_end (); }
1283     break;
1284 case 54:
1285 #line 286 "parse-gram.y"
1286 { grammar_rule_end (); }
1287     break;
1288 case 55:
1289 #line 291 "parse-gram.y"
1290 { grammar_rule_begin (current_lhs); }
1291     break;
1292 case 56:
1293 #line 293 "parse-gram.y"
1294 { grammar_current_rule_symbol_append (yyvsp[0].symbol); }
1295     break;
1296 case 57:
1297 #line 295 "parse-gram.y"
1298 { grammar_current_rule_action_append (yyvsp[0].string, yylsp[0].first_line); }
1299     break;
1300 case 58:
1301 #line 297 "parse-gram.y"
1302 { grammar_current_rule_prec_set (yyvsp[0].symbol); }
1303     break;
1304 case 59:
1305 #line 301 "parse-gram.y"
1306 { yyval.symbol = yyvsp[0].symbol; }
1307     break;
1308 case 60:
1309 #line 302 "parse-gram.y"
1310 { yyval.symbol = yyvsp[0].symbol; }
1311     break;
1312 case 61:
1313 #line 303 "parse-gram.y"
1314 { yyval.symbol = getsym (yyvsp[0].string); }
1315     break;
1316 case 62:
1317 #line 308 "parse-gram.y"
1318 { yyval.string = yyvsp[0].string; }
1319     break;
1320 case 63:
1321 #line 314 "parse-gram.y"
1322 {
1323       yyval.symbol = getsym (yyvsp[0].string);
1324       symbol_class_set (yyval.symbol, token_sym);
1325     }
1326     break;
1327 case 64:
1328 #line 323 "parse-gram.y"
1329 {
1330       yyval.string = yyvsp[0].string + 1;
1331       yyval.string[strlen (yyval.string) - 1] = '\0';
1332     }
1333     break;
1334 case 65:
1335 #line 331 "parse-gram.y"
1336 {
1337       yyval.string = xstrdup ("");
1338     }
1339     break;
1340 case 66:
1341 #line 335 "parse-gram.y"
1342 {
1343       yyval.string = yyvsp[0].string;
1344     }
1345     break;
1346 }
1347
1348 #line 705 "/usr/share/bison/bison.simple"
1349
1350 \f
1351   yyvsp -= yylen;
1352   yyssp -= yylen;
1353 #if YYLSP_NEEDED
1354   yylsp -= yylen;
1355 #endif
1356
1357 #if YYDEBUG
1358   if (yydebug)
1359     {
1360       short *yyssp1 = yyss - 1;
1361       YYFPRINTF (stderr, "state stack now");
1362       while (yyssp1 != yyssp)
1363         YYFPRINTF (stderr, " %d", *++yyssp1);
1364       YYFPRINTF (stderr, "\n");
1365     }
1366 #endif
1367
1368   *++yyvsp = yyval;
1369 #if YYLSP_NEEDED
1370   *++yylsp = yyloc;
1371 #endif
1372
1373   /* Now `shift' the result of the reduction.  Determine what state
1374      that goes to, based on the state we popped back to and the rule
1375      number reduced by.  */
1376
1377   yyn = yyr1[yyn];
1378
1379   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1380   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1381     yystate = yytable[yystate];
1382   else
1383     yystate = yydefgoto[yyn - YYNTBASE];
1384
1385   goto yynewstate;
1386
1387
1388 /*------------------------------------.
1389 | yyerrlab -- here on detecting error |
1390 `------------------------------------*/
1391 yyerrlab:
1392   /* If not already recovering from an error, report this error.  */
1393   if (!yyerrstatus)
1394     {
1395       ++yynerrs;
1396
1397 #ifdef YYERROR_VERBOSE
1398       yyn = yypact[yystate];
1399
1400       if (yyn > YYFLAG && yyn < YYLAST)
1401         {
1402           YYSIZE_T yysize = 0;
1403           char *yymsg;
1404           int yyx, yycount;
1405
1406           yycount = 0;
1407           /* Start YYX at -YYN if negative to avoid negative indexes in
1408              YYCHECK.  */
1409           for (yyx = yyn < 0 ? -yyn : 0;
1410                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1411             if (yycheck[yyx + yyn] == yyx)
1412               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1413           yysize += yystrlen ("parse error, unexpected ") + 1;
1414           yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
1415           yymsg = (char *) YYSTACK_ALLOC (yysize);
1416           if (yymsg != 0)
1417             {
1418               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1419               yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
1420
1421               if (yycount < 5)
1422                 {
1423                   yycount = 0;
1424                   for (yyx = yyn < 0 ? -yyn : 0;
1425                        yyx < (int) (sizeof (yytname) / sizeof (char *));
1426                        yyx++)
1427                     if (yycheck[yyx + yyn] == yyx)
1428                       {
1429                         const char *yyq = ! yycount ? ", expecting " : " or ";
1430                         yyp = yystpcpy (yyp, yyq);
1431                         yyp = yystpcpy (yyp, yytname[yyx]);
1432                         yycount++;
1433                       }
1434                 }
1435               yyerror (yymsg);
1436               YYSTACK_FREE (yymsg);
1437             }
1438           else
1439             yyerror ("parse error; also virtual memory exhausted");
1440         }
1441       else
1442 #endif /* defined (YYERROR_VERBOSE) */
1443         yyerror ("parse error");
1444     }
1445   goto yyerrlab1;
1446
1447
1448 /*--------------------------------------------------.
1449 | yyerrlab1 -- error raised explicitly by an action |
1450 `--------------------------------------------------*/
1451 yyerrlab1:
1452   if (yyerrstatus == 3)
1453     {
1454       /* If just tried and failed to reuse lookahead token after an
1455          error, discard it.  */
1456
1457       /* return failure if at end of input */
1458       if (yychar == YYEOF)
1459         YYABORT;
1460       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1461                   yychar, yytname[yychar1]));
1462       yychar = YYEMPTY;
1463     }
1464
1465   /* Else will try to reuse lookahead token after shifting the error
1466      token.  */
1467
1468   yyerrstatus = 3;              /* Each real token shifted decrements this */
1469
1470   goto yyerrhandle;
1471
1472
1473 /*-------------------------------------------------------------------.
1474 | yyerrdefault -- current state does not do anything special for the |
1475 | error token.                                                       |
1476 `-------------------------------------------------------------------*/
1477 yyerrdefault:
1478 #if 0
1479   /* This is wrong; only states that explicitly want error tokens
1480      should shift them.  */
1481
1482   /* If its default is to accept any token, ok.  Otherwise pop it.  */
1483   yyn = yydefact[yystate];
1484   if (yyn)
1485     goto yydefault;
1486 #endif
1487
1488
1489 /*---------------------------------------------------------------.
1490 | yyerrpop -- pop the current state because it cannot handle the |
1491 | error token                                                    |
1492 `---------------------------------------------------------------*/
1493 yyerrpop:
1494   if (yyssp == yyss)
1495     YYABORT;
1496   yyvsp--;
1497   yystate = *--yyssp;
1498 #if YYLSP_NEEDED
1499   yylsp--;
1500 #endif
1501
1502 #if YYDEBUG
1503   if (yydebug)
1504     {
1505       short *yyssp1 = yyss - 1;
1506       YYFPRINTF (stderr, "Error: state stack now");
1507       while (yyssp1 != yyssp)
1508         YYFPRINTF (stderr, " %d", *++yyssp1);
1509       YYFPRINTF (stderr, "\n");
1510     }
1511 #endif
1512
1513 /*--------------.
1514 | yyerrhandle.  |
1515 `--------------*/
1516 yyerrhandle:
1517   yyn = yypact[yystate];
1518   if (yyn == YYFLAG)
1519     goto yyerrdefault;
1520
1521   yyn += YYTERROR;
1522   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1523     goto yyerrdefault;
1524
1525   yyn = yytable[yyn];
1526   if (yyn < 0)
1527     {
1528       if (yyn == YYFLAG)
1529         goto yyerrpop;
1530       yyn = -yyn;
1531       goto yyreduce;
1532     }
1533   else if (yyn == 0)
1534     goto yyerrpop;
1535
1536   if (yyn == YYFINAL)
1537     YYACCEPT;
1538
1539   YYDPRINTF ((stderr, "Shifting error token, "));
1540
1541   *++yyvsp = yylval;
1542 #if YYLSP_NEEDED
1543   *++yylsp = yylloc;
1544 #endif
1545
1546   yystate = yyn;
1547   goto yynewstate;
1548
1549
1550 /*-------------------------------------.
1551 | yyacceptlab -- YYACCEPT comes here.  |
1552 `-------------------------------------*/
1553 yyacceptlab:
1554   yyresult = 0;
1555   goto yyreturn;
1556
1557 /*-----------------------------------.
1558 | yyabortlab -- YYABORT comes here.  |
1559 `-----------------------------------*/
1560 yyabortlab:
1561   yyresult = 1;
1562   goto yyreturn;
1563
1564 /*---------------------------------------------.
1565 | yyoverflowab -- parser overflow comes here.  |
1566 `---------------------------------------------*/
1567 yyoverflowlab:
1568   yyerror ("parser stack overflow");
1569   yyresult = 2;
1570   /* Fall through.  */
1571
1572 yyreturn:
1573 #ifndef yyoverflow
1574   if (yyss != yyssa)
1575     YYSTACK_FREE (yyss);
1576 #endif
1577   return yyresult;
1578 }
1579 #line 344 "parse-gram.y"
1580
1581 /*------------------------------------------------------------------.
1582 | When debugging the parser, display tokens' locations and values.  |
1583 `------------------------------------------------------------------*/
1584
1585 static void
1586 yyprint (FILE *file,
1587          const yyltype *loc, int type, const yystype *value)
1588 {
1589   fputs (" (", file);
1590   LOCATION_PRINT (file, *loc);
1591   fputs (")", file);
1592   switch (type)
1593     {
1594     case CHARACTER:
1595       fprintf (file, " = '%s'", value->string);
1596       break;
1597
1598     case ID:
1599       fprintf (file, " = %s", value->symbol->tag);
1600       break;
1601
1602     case INT:
1603       fprintf (file, " = %d", value->integer);
1604       break;
1605
1606     case STRING:
1607       fprintf (file, " = \"%s\"", value->string);
1608       break;
1609
1610     case TYPE:
1611       fprintf (file, " = <%s>", value->string);
1612       break;
1613
1614     case BRACED_CODE:
1615     case PROLOGUE:
1616     case EPILOGUE:
1617       fprintf (file, " = {{ %s }}", value->string);
1618       break;
1619     }
1620 }
1621
1622 void
1623 gram_error (gram_control_t *control ATTRIBUTE_UNUSED,
1624             yyltype *yylloc, const char *msg)
1625 {
1626   LOCATION_PRINT (stderr, *yylloc);
1627   fprintf (stderr, ": %s\n", msg);
1628 }