contrib/amd/fsinfo/null_gram.c

   1 /* A Bison parser, made by GNU Bison 3.0.2.  */
   2
   3 /* Bison implementation for Yacc-like parsers in C
   4
   5    Copyright (C) 1984, 1989-1990, 2000-2013 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 "3.0.2"
  48
  49 /* Skeleton name.  */
  50 #define YYSKELETON_NAME "yacc.c"
  51
  52 /* Pure parsers.  */
  53 #define YYPURE 0
  54
  55 /* Push parsers.  */
  56 #define YYPUSH 0
  57
  58 /* Pull parsers.  */
  59 #define YYPULL 1
  60
  61
  62 /* Substitute the variable and function names.  */
  63 #define yyparse         null_parse
  64 #define yylex           null_lex
  65 #define yyerror         null_error
  66 #define yydebug         null_debug
  67 #define yynerrs         null_nerrs
  68
  69 #define yylval          null_lval
  70 #define yychar          null_char
  71
  72 /* Copy the first part of user declarations.  */
  73 #line 1 "../../fsinfo/null_gram.y" /* yacc.c:339  */
  74
  75 void yyerror(const char *fmt, ...);
  76 extern int yylex(void);
  77
  78 #line 79 "null_gram.c" /* yacc.c:339  */
  79
  80 # ifndef YY_NULLPTR
  81 #  if defined __cplusplus && 201103L <= __cplusplus
  82 #   define YY_NULLPTR nullptr
  83 #  else
  84 #   define YY_NULLPTR 0
  85 #  endif
  86 # endif
  87
  88 /* Enabling verbose error messages.  */
  89 #ifdef YYERROR_VERBOSE
  90 # undef YYERROR_VERBOSE
  91 # define YYERROR_VERBOSE 1
  92 #else
  93 # define YYERROR_VERBOSE 0
  94 #endif
  95
  96 /* In a future release of Bison, this section will be replaced
  97    by #include "y.tab.h".  */
  98 #ifndef YY_NULL_NULL_GRAM_H_INCLUDED
  99 # define YY_NULL_NULL_GRAM_H_INCLUDED
 100 /* Debug traces.  */
 101 #ifndef YYDEBUG
 102 # define YYDEBUG 0
 103 #endif
 104 #if YYDEBUG
 105 extern int null_debug;
 106 #endif
 107
 108
 109 /* Value type.  */
 110 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 111 typedef int YYSTYPE;
 112 # define YYSTYPE_IS_TRIVIAL 1
 113 # define YYSTYPE_IS_DECLARED 1
 114 #endif
 115
 116
 117 extern YYSTYPE null_lval;
 118
 119 int null_parse (void);
 120
 121 #endif /* !YY_NULL_NULL_GRAM_H_INCLUDED  */
 122
 123 /* Copy the second part of user declarations.  */
 124
 125 #line 126 "null_gram.c" /* yacc.c:358  */
 126
 127 #ifdef short
 128 # undef short
 129 #endif
 130
 131 #ifdef YYTYPE_UINT8
 132 typedef YYTYPE_UINT8 yytype_uint8;
 133 #else
 134 typedef unsigned char yytype_uint8;
 135 #endif
 136
 137 #ifdef YYTYPE_INT8
 138 typedef YYTYPE_INT8 yytype_int8;
 139 #else
 140 typedef signed char yytype_int8;
 141 #endif
 142
 143 #ifdef YYTYPE_UINT16
 144 typedef YYTYPE_UINT16 yytype_uint16;
 145 #else
 146 typedef unsigned short int yytype_uint16;
 147 #endif
 148
 149 #ifdef YYTYPE_INT16
 150 typedef YYTYPE_INT16 yytype_int16;
 151 #else
 152 typedef short int yytype_int16;
 153 #endif
 154
 155 #ifndef YYSIZE_T
 156 # ifdef __SIZE_TYPE__
 157 #  define YYSIZE_T __SIZE_TYPE__
 158 # elif defined size_t
 159 #  define YYSIZE_T size_t
 160 # elif ! defined YYSIZE_T
 161 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 162 #  define YYSIZE_T size_t
 163 # else
 164 #  define YYSIZE_T unsigned int
 165 # endif
 166 #endif
 167
 168 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 169
 170 #ifndef YY_
 171 # if defined YYENABLE_NLS && YYENABLE_NLS
 172 #  if ENABLE_NLS
 173 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 174 #   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
 175 #  endif
 176 # endif
 177 # ifndef YY_
 178 #  define YY_(Msgid) Msgid
 179 # endif
 180 #endif
 181
 182 #ifndef YY_ATTRIBUTE
 183 # if (defined __GNUC__                                               \
 184       && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)))  \
 185      || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
 186 #  define YY_ATTRIBUTE(Spec) __attribute__(Spec)
 187 # else
 188 #  define YY_ATTRIBUTE(Spec) /* empty */
 189 # endif
 190 #endif
 191
 192 #ifndef YY_ATTRIBUTE_PURE
 193 # define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
 194 #endif
 195
 196 #ifndef YY_ATTRIBUTE_UNUSED
 197 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
 198 #endif
 199
 200 #if !defined _Noreturn \
 201      && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
 202 # if defined _MSC_VER && 1200 <= _MSC_VER
 203 #  define _Noreturn __declspec (noreturn)
 204 # else
 205 #  define _Noreturn YY_ATTRIBUTE ((__noreturn__))
 206 # endif
 207 #endif
 208
 209 /* Suppress unused-variable warnings by "using" E.  */
 210 #if ! defined lint || defined __GNUC__
 211 # define YYUSE(E) ((void) (E))
 212 #else
 213 # define YYUSE(E) /* empty */
 214 #endif
 215
 216 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
 217 /* Suppress an incorrect diagnostic about yylval being uninitialized.  */
 218 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
 219     _Pragma ("GCC diagnostic push") \
 220     _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
 221     _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
 222 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
 223     _Pragma ("GCC diagnostic pop")
 224 #else
 225 # define YY_INITIAL_VALUE(Value) Value
 226 #endif
 227 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 228 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 229 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
 230 #endif
 231 #ifndef YY_INITIAL_VALUE
 232 # define YY_INITIAL_VALUE(Value) /* Nothing. */
 233 #endif
 234
 235
 236 #if ! defined yyoverflow || YYERROR_VERBOSE
 237
 238 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 239
 240 # ifdef YYSTACK_USE_ALLOCA
 241 #  if YYSTACK_USE_ALLOCA
 242 #   ifdef __GNUC__
 243 #    define YYSTACK_ALLOC __builtin_alloca
 244 #   elif defined __BUILTIN_VA_ARG_INCR
 245 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 246 #   elif defined _AIX
 247 #    define YYSTACK_ALLOC __alloca
 248 #   elif defined _MSC_VER
 249 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 250 #    define alloca _alloca
 251 #   else
 252 #    define YYSTACK_ALLOC alloca
 253 #    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
 254 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 255       /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
 256 #     ifndef EXIT_SUCCESS
 257 #      define EXIT_SUCCESS 0
 258 #     endif
 259 #    endif
 260 #   endif
 261 #  endif
 262 # endif
 263
 264 # ifdef YYSTACK_ALLOC
 265    /* Pacify GCC's 'empty if-body' warning.  */
 266 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 267 #  ifndef YYSTACK_ALLOC_MAXIMUM
 268     /* The OS might guarantee only one guard page at the bottom of the stack,
 269        and a page size can be as small as 4096 bytes.  So we cannot safely
 270        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 271        to allow for a few compiler-allocated temporary stack slots.  */
 272 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 273 #  endif
 274 # else
 275 #  define YYSTACK_ALLOC YYMALLOC
 276 #  define YYSTACK_FREE YYFREE
 277 #  ifndef YYSTACK_ALLOC_MAXIMUM
 278 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 279 #  endif
 280 #  if (defined __cplusplus && ! defined EXIT_SUCCESS \
 281        && ! ((defined YYMALLOC || defined malloc) \
 282              && (defined YYFREE || defined free)))
 283 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 284 #   ifndef EXIT_SUCCESS
 285 #    define EXIT_SUCCESS 0
 286 #   endif
 287 #  endif
 288 #  ifndef YYMALLOC
 289 #   define YYMALLOC malloc
 290 #   if ! defined malloc && ! defined EXIT_SUCCESS
 291 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 292 #   endif
 293 #  endif
 294 #  ifndef YYFREE
 295 #   define YYFREE free
 296 #   if ! defined free && ! defined EXIT_SUCCESS
 297 void free (void *); /* INFRINGES ON USER NAME SPACE */
 298 #   endif
 299 #  endif
 300 # endif
 301 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 302
 303
 304 #if (! defined yyoverflow \
 305      && (! defined __cplusplus \
 306          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 307
 308 /* A type that is properly aligned for any stack member.  */
 309 union yyalloc
 310 {
 311   yytype_int16 yyss_alloc;
 312   YYSTYPE yyvs_alloc;
 313 };
 314
 315 /* The size of the maximum gap between one aligned stack and the next.  */
 316 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 317
 318 /* The size of an array large to enough to hold all stacks, each with
 319    N elements.  */
 320 # define YYSTACK_BYTES(N) \
 321      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 322       + YYSTACK_GAP_MAXIMUM)
 323
 324 # define YYCOPY_NEEDED 1
 325
 326 /* Relocate STACK from its old location to the new one.  The
 327    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 328    elements in the stack, and YYPTR gives the new location of the
 329    stack.  Advance YYPTR to a properly aligned location for the next
 330    stack.  */
 331 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
 332     do                                                                  \
 333       {                                                                 \
 334         YYSIZE_T yynewbytes;                                            \
 335         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 336         Stack = &yyptr->Stack_alloc;                                    \
 337         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 338         yyptr += yynewbytes / sizeof (*yyptr);                          \
 339       }                                                                 \
 340     while (0)
 341
 342 #endif
 343
 344 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
 345 /* Copy COUNT objects from SRC to DST.  The source and destination do
 346    not overlap.  */
 347 # ifndef YYCOPY
 348 #  if defined __GNUC__ && 1 < __GNUC__
 349 #   define YYCOPY(Dst, Src, Count) \
 350       __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
 351 #  else
 352 #   define YYCOPY(Dst, Src, Count)              \
 353       do                                        \
 354         {                                       \
 355           YYSIZE_T yyi;                         \
 356           for (yyi = 0; yyi < (Count); yyi++)   \
 357             (Dst)[yyi] = (Src)[yyi];            \
 358         }                                       \
 359       while (0)
 360 #  endif
 361 # endif
 362 #endif /* !YYCOPY_NEEDED */
 363
 364 /* YYFINAL -- State number of the termination state.  */
 365 #define YYFINAL  2
 366 /* YYLAST -- Last index in YYTABLE.  */
 367 #define YYLAST   0
 368
 369 /* YYNTOKENS -- Number of terminals.  */
 370 #define YYNTOKENS  3
 371 /* YYNNTS -- Number of nonterminals.  */
 372 #define YYNNTS  2
 373 /* YYNRULES -- Number of rules.  */
 374 #define YYNRULES  2
 375 /* YYNSTATES -- Number of states.  */
 376 #define YYNSTATES  3
 377
 378 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
 379    by yylex, with out-of-bounds checking.  */
 380 #define YYUNDEFTOK  2
 381 #define YYMAXUTOK   257
 382
 383 #define YYTRANSLATE(YYX)                                                \
 384   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 385
 386 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
 387    as returned by yylex, without out-of-bounds checking.  */
 388 static const yytype_uint8 yytranslate[] =
 389 {
 390        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 391        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 392        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 393        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 394        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 395        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 396        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 397        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 398        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 399        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 400        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 401        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 402        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 403        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 404        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 405        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 406        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 407        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 408        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 409        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 410        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 411        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 412        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 413        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 414        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 415        2,     2,     2,     2,     2,     2,     1,     2
 416 };
 417
 418 #if YYDEBUG
 419   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 420 static const yytype_uint8 yyrline[] =
 421 {
 422        0,     8,     8
 423 };
 424 #endif
 425
 426 #if YYDEBUG || YYERROR_VERBOSE || 0
 427 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 428    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 429 static const char *const yytname[] =
 430 {
 431   "$end", "error", "$undefined", "$accept", "token", YY_NULLPTR
 432 };
 433 #endif
 434
 435 # ifdef YYPRINT
 436 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
 437    (internal) symbol number NUM (which must be that of a token).  */
 438 static const yytype_uint16 yytoknum[] =
 439 {
 440        0,   256,   257
 441 };
 442 # endif
 443
 444 #define YYPACT_NINF -1
 445
 446 #define yypact_value_is_default(Yystate) \
 447   (!!((Yystate) == (-1)))
 448
 449 #define YYTABLE_NINF -1
 450
 451 #define yytable_value_is_error(Yytable_value) \
 452   0
 453
 454   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 455      STATE-NUM.  */
 456 static const yytype_int8 yypact[] =
 457 {
 458       -1,     0,    -1
 459 };
 460
 461   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
 462      Performed when YYTABLE does not specify something else to do.  Zero
 463      means the default is an error.  */
 464 static const yytype_uint8 yydefact[] =
 465 {
 466        2,     0,     1
 467 };
 468
 469   /* YYPGOTO[NTERM-NUM].  */
 470 static const yytype_int8 yypgoto[] =
 471 {
 472       -1,    -1
 473 };
 474
 475   /* YYDEFGOTO[NTERM-NUM].  */
 476 static const yytype_int8 yydefgoto[] =
 477 {
 478       -1,     1
 479 };
 480
 481   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
 482      positive, shift that token.  If negative, reduce the rule whose
 483      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 484 static const yytype_uint8 yytable[] =
 485 {
 486        2
 487 };
 488
 489 static const yytype_uint8 yycheck[] =
 490 {
 491        0
 492 };
 493
 494   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 495      symbol of state STATE-NUM.  */
 496 static const yytype_uint8 yystos[] =
 497 {
 498        0,     4,     0
 499 };
 500
 501   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 502 static const yytype_uint8 yyr1[] =
 503 {
 504        0,     3,     4
 505 };
 506
 507   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
 508 static const yytype_uint8 yyr2[] =
 509 {
 510        0,     2,     0
 511 };
 512
 513
 514 #define yyerrok         (yyerrstatus = 0)
 515 #define yyclearin       (yychar = YYEMPTY)
 516 #define YYEMPTY         (-2)
 517 #define YYEOF           0
 518
 519 #define YYACCEPT        goto yyacceptlab
 520 #define YYABORT         goto yyabortlab
 521 #define YYERROR         goto yyerrorlab
 522
 523
 524 #define YYRECOVERING()  (!!yyerrstatus)
 525
 526 #define YYBACKUP(Token, Value)                                  \
 527 do                                                              \
 528   if (yychar == YYEMPTY)                                        \
 529     {                                                           \
 530       yychar = (Token);                                         \
 531       yylval = (Value);                                         \
 532       YYPOPSTACK (yylen);                                       \
 533       yystate = *yyssp;                                         \
 534       goto yybackup;                                            \
 535     }                                                           \
 536   else                                                          \
 537     {                                                           \
 538       yyerror (YY_("syntax error: cannot back up")); \
 539       YYERROR;                                                  \
 540     }                                                           \
 541 while (0)
 542
 543 /* Error token number */
 544 #define YYTERROR        1
 545 #define YYERRCODE       256
 546
 547
 548
 549 /* Enable debugging if requested.  */
 550 #if YYDEBUG
 551
 552 # ifndef YYFPRINTF
 553 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 554 #  define YYFPRINTF fprintf
 555 # endif
 556
 557 # define YYDPRINTF(Args)                        \
 558 do {                                            \
 559   if (yydebug)                                  \
 560     YYFPRINTF Args;                             \
 561 } while (0)
 562
 563 /* This macro is provided for backward compatibility. */
 564 #ifndef YY_LOCATION_PRINT
 565 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 566 #endif
 567
 568
 569 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
 570 do {                                                                      \
 571   if (yydebug)                                                            \
 572     {                                                                     \
 573       YYFPRINTF (stderr, "%s ", Title);                                   \
 574       yy_symbol_print (stderr,                                            \
 575                   Type, Value); \
 576       YYFPRINTF (stderr, "\n");                                           \
 577     }                                                                     \
 578 } while (0)
 579
 580
 581 /*----------------------------------------.
 582 | Print this symbol's value on YYOUTPUT.  |
 583 `----------------------------------------*/
 584
 585 static void
 586 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 587 {
 588   FILE *yyo = yyoutput;
 589   YYUSE (yyo);
 590   if (!yyvaluep)
 591     return;
 592 # ifdef YYPRINT
 593   if (yytype < YYNTOKENS)
 594     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 595 # endif
 596   YYUSE (yytype);
 597 }
 598
 599
 600 /*--------------------------------.
 601 | Print this symbol on YYOUTPUT.  |
 602 `--------------------------------*/
 603
 604 static void
 605 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
 606 {
 607   YYFPRINTF (yyoutput, "%s %s (",
 608              yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
 609
 610   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
 611   YYFPRINTF (yyoutput, ")");
 612 }
 613
 614 /*------------------------------------------------------------------.
 615 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
 616 | TOP (included).                                                   |
 617 `------------------------------------------------------------------*/
 618
 619 static void
 620 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
 621 {
 622   YYFPRINTF (stderr, "Stack now");
 623   for (; yybottom <= yytop; yybottom++)
 624     {
 625       int yybot = *yybottom;
 626       YYFPRINTF (stderr, " %d", yybot);
 627     }
 628   YYFPRINTF (stderr, "\n");
 629 }
 630
 631 # define YY_STACK_PRINT(Bottom, Top)                            \
 632 do {                                                            \
 633   if (yydebug)                                                  \
 634     yy_stack_print ((Bottom), (Top));                           \
 635 } while (0)
 636
 637
 638 /*------------------------------------------------.
 639 | Report that the YYRULE is going to be reduced.  |
 640 `------------------------------------------------*/
 641
 642 static void
 643 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
 644 {
 645   unsigned long int yylno = yyrline[yyrule];
 646   int yynrhs = yyr2[yyrule];
 647   int yyi;
 648   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 649              yyrule - 1, yylno);
 650   /* The symbols being reduced.  */
 651   for (yyi = 0; yyi < yynrhs; yyi++)
 652     {
 653       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
 654       yy_symbol_print (stderr,
 655                        yystos[yyssp[yyi + 1 - yynrhs]],
 656                        &(yyvsp[(yyi + 1) - (yynrhs)])
 657                                               );
 658       YYFPRINTF (stderr, "\n");
 659     }
 660 }
 661
 662 # define YY_REDUCE_PRINT(Rule)          \
 663 do {                                    \
 664   if (yydebug)                          \
 665     yy_reduce_print (yyssp, yyvsp, Rule); \
 666 } while (0)
 667
 668 /* Nonzero means print parse trace.  It is left uninitialized so that
 669    multiple parsers can coexist.  */
 670 int yydebug;
 671 #else /* !YYDEBUG */
 672 # define YYDPRINTF(Args)
 673 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 674 # define YY_STACK_PRINT(Bottom, Top)
 675 # define YY_REDUCE_PRINT(Rule)
 676 #endif /* !YYDEBUG */
 677
 678
 679 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 680 #ifndef YYINITDEPTH
 681 # define YYINITDEPTH 200
 682 #endif
 683
 684 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 685    if the built-in stack extension method is used).
 686
 687    Do not make this value too large; the results are undefined if
 688    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
 689    evaluated with infinite-precision integer arithmetic.  */
 690
 691 #ifndef YYMAXDEPTH
 692 # define YYMAXDEPTH 10000
 693 #endif
 694
 695
 696 #if YYERROR_VERBOSE
 697
 698 # ifndef yystrlen
 699 #  if defined __GLIBC__ && defined _STRING_H
 700 #   define yystrlen strlen
 701 #  else
 702 /* Return the length of YYSTR.  */
 703 static YYSIZE_T
 704 yystrlen (const char *yystr)
 705 {
 706   YYSIZE_T yylen;
 707   for (yylen = 0; yystr[yylen]; yylen++)
 708     continue;
 709   return yylen;
 710 }
 711 #  endif
 712 # endif
 713
 714 # ifndef yystpcpy
 715 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
 716 #   define yystpcpy stpcpy
 717 #  else
 718 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 719    YYDEST.  */
 720 static char *
 721 yystpcpy (char *yydest, const char *yysrc)
 722 {
 723   char *yyd = yydest;
 724   const char *yys = yysrc;
 725
 726   while ((*yyd++ = *yys++) != '\0')
 727     continue;
 728
 729   return yyd - 1;
 730 }
 731 #  endif
 732 # endif
 733
 734 # ifndef yytnamerr
 735 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
 736    quotes and backslashes, so that it's suitable for yyerror.  The
 737    heuristic is that double-quoting is unnecessary unless the string
 738    contains an apostrophe, a comma, or backslash (other than
 739    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
 740    null, do not copy; instead, return the length of what the result
 741    would have been.  */
 742 static YYSIZE_T
 743 yytnamerr (char *yyres, const char *yystr)
 744 {
 745   if (*yystr == '"')
 746     {
 747       YYSIZE_T yyn = 0;
 748       char const *yyp = yystr;
 749
 750       for (;;)
 751         switch (*++yyp)
 752           {
 753           case '\'':
 754           case ',':
 755             goto do_not_strip_quotes;
 756
 757           case '\\':
 758             if (*++yyp != '\\')
 759               goto do_not_strip_quotes;
 760             /* Fall through.  */
 761           default:
 762             if (yyres)
 763               yyres[yyn] = *yyp;
 764             yyn++;
 765             break;
 766
 767           case '"':
 768             if (yyres)
 769               yyres[yyn] = '\0';
 770             return yyn;
 771           }
 772     do_not_strip_quotes: ;
 773     }
 774
 775   if (! yyres)
 776     return yystrlen (yystr);
 777
 778   return yystpcpy (yyres, yystr) - yyres;
 779 }
 780 # endif
 781
 782 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
 783    about the unexpected token YYTOKEN for the state stack whose top is
 784    YYSSP.
 785
 786    Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
 787    not large enough to hold the message.  In that case, also set
 788    *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
 789    required number of bytes is too large to store.  */
 790 static int
 791 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 792                 yytype_int16 *yyssp, int yytoken)
 793 {
 794   YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
 795   YYSIZE_T yysize = yysize0;
 796   enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
 797   /* Internationalized format string. */
 798   const char *yyformat = YY_NULLPTR;
 799   /* Arguments of yyformat. */
 800   char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 801   /* Number of reported tokens (one for the "unexpected", one per
 802      "expected"). */
 803   int yycount = 0;
 804
 805   /* There are many possibilities here to consider:
 806      - If this state is a consistent state with a default action, then
 807        the only way this function was invoked is if the default action
 808        is an error action.  In that case, don't check for expected
 809        tokens because there are none.
 810      - The only way there can be no lookahead present (in yychar) is if
 811        this state is a consistent state with a default action.  Thus,
 812        detecting the absence of a lookahead is sufficient to determine
 813        that there is no unexpected or expected token to report.  In that
 814        case, just report a simple "syntax error".
 815      - Don't assume there isn't a lookahead just because this state is a
 816        consistent state with a default action.  There might have been a
 817        previous inconsistent state, consistent state with a non-default
 818        action, or user semantic action that manipulated yychar.
 819      - Of course, the expected token list depends on states to have
 820        correct lookahead information, and it depends on the parser not
 821        to perform extra reductions after fetching a lookahead from the
 822        scanner and before detecting a syntax error.  Thus, state merging
 823        (from LALR or IELR) and default reductions corrupt the expected
 824        token list.  However, the list is correct for canonical LR with
 825        one exception: it will still contain any token that will not be
 826        accepted due to an error action in a later state.
 827   */
 828   if (yytoken != YYEMPTY)
 829     {
 830       int yyn = yypact[*yyssp];
 831       yyarg[yycount++] = yytname[yytoken];
 832       if (!yypact_value_is_default (yyn))
 833         {
 834           /* Start YYX at -YYN if negative to avoid negative indexes in
 835              YYCHECK.  In other words, skip the first -YYN actions for
 836              this state because they are default actions.  */
 837           int yyxbegin = yyn < 0 ? -yyn : 0;
 838           /* Stay within bounds of both yycheck and yytname.  */
 839           int yychecklim = YYLAST - yyn + 1;
 840           int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
 841           int yyx;
 842
 843           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 844             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
 845                 && !yytable_value_is_error (yytable[yyx + yyn]))
 846               {
 847                 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
 848                   {
 849                     yycount = 1;
 850                     yysize = yysize0;
 851                     break;
 852                   }
 853                 yyarg[yycount++] = yytname[yyx];
 854                 {
 855                   YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
 856                   if (! (yysize <= yysize1
 857                          && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
 858                     return 2;
 859                   yysize = yysize1;
 860                 }
 861               }
 862         }
 863     }
 864
 865   switch (yycount)
 866     {
 867 # define YYCASE_(N, S)                      \
 868       case N:                               \
 869         yyformat = S;                       \
 870       break
 871       YYCASE_(0, YY_("syntax error"));
 872       YYCASE_(1, YY_("syntax error, unexpected %s"));
 873       YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
 874       YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
 875       YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
 876       YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
 877 # undef YYCASE_
 878     }
 879
 880   {
 881     YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
 882     if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
 883       return 2;
 884     yysize = yysize1;
 885   }
 886
 887   if (*yymsg_alloc < yysize)
 888     {
 889       *yymsg_alloc = 2 * yysize;
 890       if (! (yysize <= *yymsg_alloc
 891              && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
 892         *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
 893       return 1;
 894     }
 895
 896   /* Avoid sprintf, as that infringes on the user's name space.
 897      Don't have undefined behavior even if the translation
 898      produced a string with the wrong number of "%s"s.  */
 899   {
 900     char *yyp = *yymsg;
 901     int yyi = 0;
 902     while ((*yyp = *yyformat) != '\0')
 903       if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
 904         {
 905           yyp += yytnamerr (yyp, yyarg[yyi++]);
 906           yyformat += 2;
 907         }
 908       else
 909         {
 910           yyp++;
 911           yyformat++;
 912         }
 913   }
 914   return 0;
 915 }
 916 #endif /* YYERROR_VERBOSE */
 917
 918 /*-----------------------------------------------.
 919 | Release the memory associated to this symbol.  |
 920 `-----------------------------------------------*/
 921
 922 static void
 923 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
 924 {
 925   YYUSE (yyvaluep);
 926   if (!yymsg)
 927     yymsg = "Deleting";
 928   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 929
 930   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 931   YYUSE (yytype);
 932   YY_IGNORE_MAYBE_UNINITIALIZED_END
 933 }
 934
 935
 936
 937
 938 /* The lookahead symbol.  */
 939 int yychar;
 940
 941 /* The semantic value of the lookahead symbol.  */
 942 YYSTYPE yylval;
 943 /* Number of syntax errors so far.  */
 944 int yynerrs;
 945
 946
 947 /*----------.
 948 | yyparse.  |
 949 `----------*/
 950
 951 int
 952 yyparse (void)
 953 {
 954     int yystate;
 955     /* Number of tokens to shift before error messages enabled.  */
 956     int yyerrstatus;
 957
 958     /* The stacks and their tools:
 959        'yyss': related to states.
 960        'yyvs': related to semantic values.
 961
 962        Refer to the stacks through separate pointers, to allow yyoverflow
 963        to reallocate them elsewhere.  */
 964
 965     /* The state stack.  */
 966     yytype_int16 yyssa[YYINITDEPTH];
 967     yytype_int16 *yyss;
 968     yytype_int16 *yyssp;
 969
 970     /* The semantic value stack.  */
 971     YYSTYPE yyvsa[YYINITDEPTH];
 972     YYSTYPE *yyvs;
 973     YYSTYPE *yyvsp;
 974
 975     YYSIZE_T yystacksize;
 976
 977   int yyn;
 978   int yyresult;
 979   /* Lookahead token as an internal (translated) token number.  */
 980   int yytoken = 0;
 981   /* The variables used to return semantic value and location from the
 982      action routines.  */
 983   YYSTYPE yyval;
 984
 985 #if YYERROR_VERBOSE
 986   /* Buffer for error messages, and its allocated size.  */
 987   char yymsgbuf[128];
 988   char *yymsg = yymsgbuf;
 989   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 990 #endif
 991
 992 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
 993
 994   /* The number of symbols on the RHS of the reduced rule.
 995      Keep to zero when no symbol should be popped.  */
 996   int yylen = 0;
 997
 998   yyssp = yyss = yyssa;
 999   yyvsp = yyvs = yyvsa;
1000   yystacksize = YYINITDEPTH;
1001
1002   YYDPRINTF ((stderr, "Starting parse\n"));
1003
1004   yystate = 0;
1005   yyerrstatus = 0;
1006   yynerrs = 0;
1007   yychar = YYEMPTY; /* Cause a token to be read.  */
1008   goto yysetstate;
1009
1010 /*------------------------------------------------------------.
1011 | yynewstate -- Push a new state, which is found in yystate.  |
1012 `------------------------------------------------------------*/
1013  yynewstate:
1014   /* In all cases, when you get here, the value and location stacks
1015      have just been pushed.  So pushing a state here evens the stacks.  */
1016   yyssp++;
1017
1018  yysetstate:
1019   *yyssp = yystate;
1020
1021   if (yyss + yystacksize - 1 <= yyssp)
1022     {
1023       /* Get the current used size of the three stacks, in elements.  */
1024       YYSIZE_T yysize = yyssp - yyss + 1;
1025
1026 #ifdef yyoverflow
1027       {
1028         /* Give user a chance to reallocate the stack.  Use copies of
1029            these so that the &'s don't force the real ones into
1030            memory.  */
1031         YYSTYPE *yyvs1 = yyvs;
1032         yytype_int16 *yyss1 = yyss;
1033
1034         /* Each stack pointer address is followed by the size of the
1035            data in use in that stack, in bytes.  This used to be a
1036            conditional around just the two extra args, but that might
1037            be undefined if yyoverflow is a macro.  */
1038         yyoverflow (YY_("memory exhausted"),
1039                     &yyss1, yysize * sizeof (*yyssp),
1040                     &yyvs1, yysize * sizeof (*yyvsp),
1041                     &yystacksize);
1042
1043         yyss = yyss1;
1044         yyvs = yyvs1;
1045       }
1046 #else /* no yyoverflow */
1047 # ifndef YYSTACK_RELOCATE
1048       goto yyexhaustedlab;
1049 # else
1050       /* Extend the stack our own way.  */
1051       if (YYMAXDEPTH <= yystacksize)
1052         goto yyexhaustedlab;
1053       yystacksize *= 2;
1054       if (YYMAXDEPTH < yystacksize)
1055         yystacksize = YYMAXDEPTH;
1056
1057       {
1058         yytype_int16 *yyss1 = yyss;
1059         union yyalloc *yyptr =
1060           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1061         if (! yyptr)
1062           goto yyexhaustedlab;
1063         YYSTACK_RELOCATE (yyss_alloc, yyss);
1064         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1065 #  undef YYSTACK_RELOCATE
1066         if (yyss1 != yyssa)
1067           YYSTACK_FREE (yyss1);
1068       }
1069 # endif
1070 #endif /* no yyoverflow */
1071
1072       yyssp = yyss + yysize - 1;
1073       yyvsp = yyvs + yysize - 1;
1074
1075       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1076                   (unsigned long int) yystacksize));
1077
1078       if (yyss + yystacksize - 1 <= yyssp)
1079         YYABORT;
1080     }
1081
1082   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1083
1084   if (yystate == YYFINAL)
1085     YYACCEPT;
1086
1087   goto yybackup;
1088
1089 /*-----------.
1090 | yybackup.  |
1091 `-----------*/
1092 yybackup:
1093
1094   /* Do appropriate processing given the current state.  Read a
1095      lookahead token if we need one and don't already have one.  */
1096
1097   /* First try to decide what to do without reference to lookahead token.  */
1098   yyn = yypact[yystate];
1099   if (yypact_value_is_default (yyn))
1100     goto yydefault;
1101
1102   /* Not known => get a lookahead token if don't already have one.  */
1103
1104   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1105   if (yychar == YYEMPTY)
1106     {
1107       YYDPRINTF ((stderr, "Reading a token: "));
1108       yychar = yylex ();
1109     }
1110
1111   if (yychar <= YYEOF)
1112     {
1113       yychar = yytoken = YYEOF;
1114       YYDPRINTF ((stderr, "Now at end of input.\n"));
1115     }
1116   else
1117     {
1118       yytoken = YYTRANSLATE (yychar);
1119       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1120     }
1121
1122   /* If the proper action on seeing token YYTOKEN is to reduce or to
1123      detect an error, take that action.  */
1124   yyn += yytoken;
1125   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1126     goto yydefault;
1127   yyn = yytable[yyn];
1128   if (yyn <= 0)
1129     {
1130       if (yytable_value_is_error (yyn))
1131         goto yyerrlab;
1132       yyn = -yyn;
1133       goto yyreduce;
1134     }
1135
1136   /* Count tokens shifted since error; after three, turn off error
1137      status.  */
1138   if (yyerrstatus)
1139     yyerrstatus--;
1140
1141   /* Shift the lookahead token.  */
1142   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1143
1144   /* Discard the shifted token.  */
1145   yychar = YYEMPTY;
1146
1147   yystate = yyn;
1148   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1149   *++yyvsp = yylval;
1150   YY_IGNORE_MAYBE_UNINITIALIZED_END
1151
1152   goto yynewstate;
1153
1154
1155 /*-----------------------------------------------------------.
1156 | yydefault -- do the default action for the current state.  |
1157 `-----------------------------------------------------------*/
1158 yydefault:
1159   yyn = yydefact[yystate];
1160   if (yyn == 0)
1161     goto yyerrlab;
1162   goto yyreduce;
1163
1164
1165 /*-----------------------------.
1166 | yyreduce -- Do a reduction.  |
1167 `-----------------------------*/
1168 yyreduce:
1169   /* yyn is the number of a rule to reduce with.  */
1170   yylen = yyr2[yyn];
1171
1172   /* If YYLEN is nonzero, implement the default value of the action:
1173      '$$ = $1'.
1174
1175      Otherwise, the following line sets YYVAL to garbage.
1176      This behavior is undocumented and Bison
1177      users should not rely upon it.  Assigning to YYVAL
1178      unconditionally makes the parser a bit smaller, and it avoids a
1179      GCC warning that YYVAL may be used uninitialized.  */
1180   yyval = yyvsp[1-yylen];
1181
1182
1183   YY_REDUCE_PRINT (yyn);
1184   switch (yyn)
1185     {
1186
1187 #line 1188 "null_gram.c" /* yacc.c:1646  */
1188       default: break;
1189     }
1190   /* User semantic actions sometimes alter yychar, and that requires
1191      that yytoken be updated with the new translation.  We take the
1192      approach of translating immediately before every use of yytoken.
1193      One alternative is translating here after every semantic action,
1194      but that translation would be missed if the semantic action invokes
1195      YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1196      if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
1197      incorrect destructor might then be invoked immediately.  In the
1198      case of YYERROR or YYBACKUP, subsequent parser actions might lead
1199      to an incorrect destructor call or verbose syntax error message
1200      before the lookahead is translated.  */
1201   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1202
1203   YYPOPSTACK (yylen);
1204   yylen = 0;
1205   YY_STACK_PRINT (yyss, yyssp);
1206
1207   *++yyvsp = yyval;
1208
1209   /* Now 'shift' the result of the reduction.  Determine what state
1210      that goes to, based on the state we popped back to and the rule
1211      number reduced by.  */
1212
1213   yyn = yyr1[yyn];
1214
1215   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1216   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1217     yystate = yytable[yystate];
1218   else
1219     yystate = yydefgoto[yyn - YYNTOKENS];
1220
1221   goto yynewstate;
1222
1223
1224 /*--------------------------------------.
1225 | yyerrlab -- here on detecting error.  |
1226 `--------------------------------------*/
1227 yyerrlab:
1228   /* Make sure we have latest lookahead translation.  See comments at
1229      user semantic actions for why this is necessary.  */
1230   yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1231
1232   /* If not already recovering from an error, report this error.  */
1233   if (!yyerrstatus)
1234     {
1235       ++yynerrs;
1236 #if ! YYERROR_VERBOSE
1237       yyerror (YY_("syntax error"));
1238 #else
1239 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1240                                         yyssp, yytoken)
1241       {
1242         char const *yymsgp = YY_("syntax error");
1243         int yysyntax_error_status;
1244         yysyntax_error_status = YYSYNTAX_ERROR;
1245         if (yysyntax_error_status == 0)
1246           yymsgp = yymsg;
1247         else if (yysyntax_error_status == 1)
1248           {
1249             if (yymsg != yymsgbuf)
1250               YYSTACK_FREE (yymsg);
1251             yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1252             if (!yymsg)
1253               {
1254                 yymsg = yymsgbuf;
1255                 yymsg_alloc = sizeof yymsgbuf;
1256                 yysyntax_error_status = 2;
1257               }
1258             else
1259               {
1260                 yysyntax_error_status = YYSYNTAX_ERROR;
1261                 yymsgp = yymsg;
1262               }
1263           }
1264         yyerror (yymsgp);
1265         if (yysyntax_error_status == 2)
1266           goto yyexhaustedlab;
1267       }
1268 # undef YYSYNTAX_ERROR
1269 #endif
1270     }
1271
1272
1273
1274   if (yyerrstatus == 3)
1275     {
1276       /* If just tried and failed to reuse lookahead token after an
1277          error, discard it.  */
1278
1279       if (yychar <= YYEOF)
1280         {
1281           /* Return failure if at end of input.  */
1282           if (yychar == YYEOF)
1283             YYABORT;
1284         }
1285       else
1286         {
1287           yydestruct ("Error: discarding",
1288                       yytoken, &yylval);
1289           yychar = YYEMPTY;
1290         }
1291     }
1292
1293   /* Else will try to reuse lookahead token after shifting the error
1294      token.  */
1295   goto yyerrlab1;
1296
1297
1298 /*---------------------------------------------------.
1299 | yyerrorlab -- error raised explicitly by YYERROR.  |
1300 `---------------------------------------------------*/
1301 yyerrorlab:
1302
1303   /* Pacify compilers like GCC when the user code never invokes
1304      YYERROR and the label yyerrorlab therefore never appears in user
1305      code.  */
1306   if (/*CONSTCOND*/ 0)
1307      goto yyerrorlab;
1308
1309   /* Do not reclaim the symbols of the rule whose action triggered
1310      this YYERROR.  */
1311   YYPOPSTACK (yylen);
1312   yylen = 0;
1313   YY_STACK_PRINT (yyss, yyssp);
1314   yystate = *yyssp;
1315   goto yyerrlab1;
1316
1317
1318 /*-------------------------------------------------------------.
1319 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
1320 `-------------------------------------------------------------*/
1321 yyerrlab1:
1322   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
1323
1324   for (;;)
1325     {
1326       yyn = yypact[yystate];
1327       if (!yypact_value_is_default (yyn))
1328         {
1329           yyn += YYTERROR;
1330           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1331             {
1332               yyn = yytable[yyn];
1333               if (0 < yyn)
1334                 break;
1335             }
1336         }
1337
1338       /* Pop the current state because it cannot handle the error token.  */
1339       if (yyssp == yyss)
1340         YYABORT;
1341
1342
1343       yydestruct ("Error: popping",
1344                   yystos[yystate], yyvsp);
1345       YYPOPSTACK (1);
1346       yystate = *yyssp;
1347       YY_STACK_PRINT (yyss, yyssp);
1348     }
1349
1350   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1351   *++yyvsp = yylval;
1352   YY_IGNORE_MAYBE_UNINITIALIZED_END
1353
1354
1355   /* Shift the error token.  */
1356   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1357
1358   yystate = yyn;
1359   goto yynewstate;
1360
1361
1362 /*-------------------------------------.
1363 | yyacceptlab -- YYACCEPT comes here.  |
1364 `-------------------------------------*/
1365 yyacceptlab:
1366   yyresult = 0;
1367   goto yyreturn;
1368
1369 /*-----------------------------------.
1370 | yyabortlab -- YYABORT comes here.  |
1371 `-----------------------------------*/
1372 yyabortlab:
1373   yyresult = 1;
1374   goto yyreturn;
1375
1376 #if !defined yyoverflow || YYERROR_VERBOSE
1377 /*-------------------------------------------------.
1378 | yyexhaustedlab -- memory exhaustion comes here.  |
1379 `-------------------------------------------------*/
1380 yyexhaustedlab:
1381   yyerror (YY_("memory exhausted"));
1382   yyresult = 2;
1383   /* Fall through.  */
1384 #endif
1385
1386 yyreturn:
1387   if (yychar != YYEMPTY)
1388     {
1389       /* Make sure we have latest lookahead translation.  See comments at
1390          user semantic actions for why this is necessary.  */
1391       yytoken = YYTRANSLATE (yychar);
1392       yydestruct ("Cleanup: discarding lookahead",
1393                   yytoken, &yylval);
1394     }
1395   /* Do not reclaim the symbols of the rule whose action triggered
1396      this YYABORT or YYACCEPT.  */
1397   YYPOPSTACK (yylen);
1398   YY_STACK_PRINT (yyss, yyssp);
1399   while (yyssp != yyss)
1400     {
1401       yydestruct ("Cleanup: popping",
1402                   yystos[*yyssp], yyvsp);
1403       YYPOPSTACK (1);
1404     }
1405 #ifndef yyoverflow
1406   if (yyss != yyssa)
1407     YYSTACK_FREE (yyss);
1408 #endif
1409 #if YYERROR_VERBOSE
1410   if (yymsg != yymsgbuf)
1411     YYSTACK_FREE (yymsg);
1412 #endif
1413   return yyresult;
1414 }