null_gram.c revision 310490
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 75void yyerror(const char *fmt, ...); 76extern 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 105extern int null_debug; 106#endif 107 108 109/* Value type. */ 110#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 111typedef int YYSTYPE; 112# define YYSTYPE_IS_TRIVIAL 1 113# define YYSTYPE_IS_DECLARED 1 114#endif 115 116 117extern YYSTYPE null_lval; 118 119int 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 132typedef YYTYPE_UINT8 yytype_uint8; 133#else 134typedef unsigned char yytype_uint8; 135#endif 136 137#ifdef YYTYPE_INT8 138typedef YYTYPE_INT8 yytype_int8; 139#else 140typedef signed char yytype_int8; 141#endif 142 143#ifdef YYTYPE_UINT16 144typedef YYTYPE_UINT16 yytype_uint16; 145#else 146typedef unsigned short int yytype_uint16; 147#endif 148 149#ifdef YYTYPE_INT16 150typedef YYTYPE_INT16 yytype_int16; 151#else 152typedef 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 291void *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 297void 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. */ 309union 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. */ 388static 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. */ 420static 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. */ 429static 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). */ 438static 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. */ 456static 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. */ 464static const yytype_uint8 yydefact[] = 465{ 466 2, 0, 1 467}; 468 469 /* YYPGOTO[NTERM-NUM]. */ 470static const yytype_int8 yypgoto[] = 471{ 472 -1, -1 473}; 474 475 /* YYDEFGOTO[NTERM-NUM]. */ 476static 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. */ 484static const yytype_uint8 yytable[] = 485{ 486 2 487}; 488 489static 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. */ 496static const yytype_uint8 yystos[] = 497{ 498 0, 4, 0 499}; 500 501 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 502static 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. */ 508static 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) \ 527do \ 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 } \ 541while (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) \ 558do { \ 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) \ 570do { \ 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 585static void 586yy_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 604static void 605yy_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 619static void 620yy_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) \ 632do { \ 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 642static void 643yy_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) \ 663do { \ 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. */ 670int 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. */ 703static YYSIZE_T 704yystrlen (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. */ 720static char * 721yystpcpy (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. */ 742static YYSIZE_T 743yytnamerr (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. */ 790static int 791yysyntax_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 922static void 923yydestruct (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. */ 939int yychar; 940 941/* The semantic value of the lookahead symbol. */ 942YYSTYPE yylval; 943/* Number of syntax errors so far. */ 944int yynerrs; 945 946 947/*----------. 948| yyparse. | 949`----------*/ 950 951int 952yyparse (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`-----------*/ 1092yybackup: 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`-----------------------------------------------------------*/ 1158yydefault: 1159 yyn = yydefact[yystate]; 1160 if (yyn == 0) 1161 goto yyerrlab; 1162 goto yyreduce; 1163 1164 1165/*-----------------------------. 1166| yyreduce -- Do a reduction. | 1167`-----------------------------*/ 1168yyreduce: 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`--------------------------------------*/ 1227yyerrlab: 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`---------------------------------------------------*/ 1301yyerrorlab: 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`-------------------------------------------------------------*/ 1321yyerrlab1: 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`-------------------------------------*/ 1365yyacceptlab: 1366 yyresult = 0; 1367 goto yyreturn; 1368 1369/*-----------------------------------. 1370| yyabortlab -- YYABORT comes here. | 1371`-----------------------------------*/ 1372yyabortlab: 1373 yyresult = 1; 1374 goto yyreturn; 1375 1376#if !defined yyoverflow || YYERROR_VERBOSE 1377/*-------------------------------------------------. 1378| yyexhaustedlab -- memory exhaustion comes here. | 1379`-------------------------------------------------*/ 1380yyexhaustedlab: 1381 yyerror (YY_("memory exhausted")); 1382 yyresult = 2; 1383 /* Fall through. */ 1384#endif 1385 1386yyreturn: 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} 1415