Annotation of win32/tools/cygwin/usr/share/bison/yacc.c, revision 1.1
1.1 ! misha 1: -*- C -*-
! 2:
! 3: # Yacc compatible skeleton for Bison
! 4:
! 5: # Copyright (C) 1984, 1989-1990, 2000-2010 Free Software Foundation,
! 6: # Inc.
! 7:
! 8: # This program is free software: you can redistribute it and/or modify
! 9: # it under the terms of the GNU General Public License as published by
! 10: # the Free Software Foundation, either version 3 of the License, or
! 11: # (at your option) any later version.
! 12: #
! 13: # This program is distributed in the hope that it will be useful,
! 14: # but WITHOUT ANY WARRANTY; without even the implied warranty of
! 15: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 16: # GNU General Public License for more details.
! 17: #
! 18: # You should have received a copy of the GNU General Public License
! 19: # along with this program. If not, see <http://www.gnu.org/licenses/>.
! 20:
! 21: # Check the value of %define api.push_pull.
! 22: b4_percent_define_default([[api.push_pull]], [[pull]])
! 23: b4_percent_define_check_values([[[[api.push_pull]],
! 24: [[pull]], [[push]], [[both]]]])
! 25: b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]])
! 26: b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]])
! 27: m4_case(b4_percent_define_get([[api.push_pull]]),
! 28: [pull], [m4_define([b4_push_flag], [[0]])],
! 29: [push], [m4_define([b4_pull_flag], [[0]])])
! 30:
! 31: # Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing
! 32: # tests function as written, don't let BISON_USE_PUSH_FOR_PULL modify Bison's
! 33: # behavior at all when push parsing is already requested.
! 34: b4_define_flag_if([use_push_for_pull])
! 35: b4_use_push_for_pull_if([
! 36: b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])],
! 37: [m4_define([b4_push_flag], [[1]])])])
! 38:
! 39: m4_include(b4_pkgdatadir/[c.m4])
! 40:
! 41: ## ---------------- ##
! 42: ## Default values. ##
! 43: ## ---------------- ##
! 44:
! 45: # Stack parameters.
! 46: m4_define_default([b4_stack_depth_max], [10000])
! 47: m4_define_default([b4_stack_depth_init], [200])
! 48:
! 49:
! 50: ## ------------------------ ##
! 51: ## Pure/impure interfaces. ##
! 52: ## ------------------------ ##
! 53:
! 54: b4_percent_define_default([[api.pure]], [[false]])
! 55: b4_define_flag_if([pure])
! 56: m4_define([b4_pure_flag],
! 57: [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])
! 58:
! 59: # b4_yacc_pure_if(IF-TRUE, IF-FALSE)
! 60: # ----------------------------------
! 61: # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
! 62: m4_define([b4_yacc_pure_if],
! 63: [b4_pure_if([m4_ifset([b4_parse_param],
! 64: [$1], [$2])],
! 65: [$2])])
! 66:
! 67:
! 68: # b4_yyerror_args
! 69: # ---------------
! 70: # Arguments passed to yyerror: user args plus yylloc.
! 71: m4_define([b4_yyerror_args],
! 72: [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
! 73: m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
! 74:
! 75:
! 76: # b4_lex_param
! 77: # ------------
! 78: # Accumulate in b4_lex_param all the yylex arguments.
! 79: # b4_lex_param arrives quoted twice, but we want to keep only one level.
! 80: m4_define([b4_lex_param],
! 81: m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
! 82: b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
! 83: m4_ifdef([b4_lex_param], b4_lex_param)))
! 84:
! 85:
! 86: ## ------------ ##
! 87: ## Data Types. ##
! 88: ## ------------ ##
! 89:
! 90: # b4_int_type(MIN, MAX)
! 91: # ---------------------
! 92: # Return the smallest int type able to handle numbers ranging from
! 93: # MIN to MAX (included). Overwrite the version from c.m4, which
! 94: # uses only C89 types, so that the user can override the shorter
! 95: # types, and so that pre-C89 compilers are handled correctly.
! 96: m4_define([b4_int_type],
! 97: [m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8],
! 98: b4_ints_in($@, [-128], [127]), [1], [yytype_int8],
! 99:
! 100: b4_ints_in($@, [0], [65535]), [1], [yytype_uint16],
! 101: b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
! 102:
! 103: m4_eval([0 <= $1]), [1], [unsigned int],
! 104:
! 105: [int])])
! 106:
! 107:
! 108: ## ----------------- ##
! 109: ## Semantic Values. ##
! 110: ## ----------------- ##
! 111:
! 112:
! 113: # b4_lhs_value([TYPE])
! 114: # --------------------
! 115: # Expansion of $<TYPE>$.
! 116: m4_define([b4_lhs_value],
! 117: [(yyval[]m4_ifval([$1], [.$1]))])
! 118:
! 119:
! 120: # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
! 121: # --------------------------------------
! 122: # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
! 123: # symbols on RHS.
! 124: m4_define([b4_rhs_value],
! 125: [(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])
! 126:
! 127:
! 128:
! 129: ## ----------- ##
! 130: ## Locations. ##
! 131: ## ----------- ##
! 132:
! 133: # b4_lhs_location()
! 134: # -----------------
! 135: # Expansion of @$.
! 136: m4_define([b4_lhs_location],
! 137: [(yyloc)])
! 138:
! 139:
! 140: # b4_rhs_location(RULE-LENGTH, NUM)
! 141: # ---------------------------------
! 142: # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
! 143: # on RHS.
! 144: m4_define([b4_rhs_location],
! 145: [(yylsp@{($2) - ($1)@})])
! 146:
! 147:
! 148:
! 149: ## --------------------------------------------------------- ##
! 150: ## Defining symbol actions, e.g., printers and destructors. ##
! 151: ## --------------------------------------------------------- ##
! 152:
! 153: # We do want M4 expansion after # for CPP macros.
! 154: m4_changecom()
! 155: m4_divert_push(0)dnl
! 156: @output(b4_parser_file_name@)@
! 157: b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],
! 158: [1984, 1989-1990, 2000-2006, 2009-2010])[
! 159:
! 160: /* C LALR(1) parser skeleton written by Richard Stallman, by
! 161: simplifying the original so-called "semantic" parser. */
! 162:
! 163: /* All symbols defined below should begin with yy or YY, to avoid
! 164: infringing on user name space. This should be done even for local
! 165: variables, as they might otherwise be expanded by user macros.
! 166: There are some unavoidable exceptions within include files to
! 167: define necessary library symbols; they are noted "INFRINGES ON
! 168: USER NAME SPACE" below. */
! 169:
! 170: ]b4_identification
! 171: b4_percent_code_get([[top]])[]dnl
! 172: m4_if(b4_prefix, [yy], [],
! 173: [[/* Substitute the variable and function names. */
! 174: ]b4_pull_if([[#define yyparse ]b4_prefix[parse
! 175: ]])b4_push_if([[#define yypush_parse ]b4_prefix[push_parse
! 176: ]b4_pull_if([[#define yypull_parse ]b4_prefix[pull_parse
! 177: ]])[#define yypstate_new ]b4_prefix[pstate_new
! 178: #define yypstate_delete ]b4_prefix[pstate_delete
! 179: #define yypstate ]b4_prefix[pstate
! 180: ]])[#define yylex ]b4_prefix[lex
! 181: #define yyerror ]b4_prefix[error
! 182: #define yylval ]b4_prefix[lval
! 183: #define yychar ]b4_prefix[char
! 184: #define yydebug ]b4_prefix[debug
! 185: #define yynerrs ]b4_prefix[nerrs
! 186: ]b4_locations_if([[#define yylloc ]b4_prefix[lloc]])])[
! 187:
! 188: /* Copy the first part of user declarations. */
! 189: ]b4_user_pre_prologue[
! 190:
! 191: /* Enabling traces. */
! 192: #ifndef YYDEBUG
! 193: # define YYDEBUG ]b4_debug_flag[
! 194: #endif
! 195:
! 196: /* Enabling verbose error messages. */
! 197: #ifdef YYERROR_VERBOSE
! 198: # undef YYERROR_VERBOSE
! 199: # define YYERROR_VERBOSE 1
! 200: #else
! 201: # define YYERROR_VERBOSE ]b4_error_verbose_flag[
! 202: #endif
! 203:
! 204: /* Enabling the token table. */
! 205: #ifndef YYTOKEN_TABLE
! 206: # define YYTOKEN_TABLE ]b4_token_table[
! 207: #endif
! 208:
! 209: ]b4_percent_code_get([[requires]])[]dnl
! 210:
! 211: b4_token_enums_defines(b4_tokens)[
! 212:
! 213: #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
! 214: ]m4_ifdef([b4_stype],
! 215: [[typedef union ]b4_union_name[
! 216: {
! 217: ]b4_user_stype[
! 218: } YYSTYPE;
! 219: # define YYSTYPE_IS_TRIVIAL 1]],
! 220: [m4_if(b4_tag_seen_flag, 0,
! 221: [[typedef int YYSTYPE;
! 222: # define YYSTYPE_IS_TRIVIAL 1]])])[
! 223: # define yystype YYSTYPE /* obsolescent; will be withdrawn */
! 224: # define YYSTYPE_IS_DECLARED 1
! 225: #endif]b4_locations_if([[
! 226:
! 227: #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
! 228: typedef struct YYLTYPE
! 229: {
! 230: int first_line;
! 231: int first_column;
! 232: int last_line;
! 233: int last_column;
! 234: } YYLTYPE;
! 235: # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
! 236: # define YYLTYPE_IS_DECLARED 1
! 237: # define YYLTYPE_IS_TRIVIAL 1
! 238: #endif]])b4_push_if([[
! 239:
! 240: #ifndef YYPUSH_DECLS
! 241: # define YYPUSH_DECLS
! 242: struct yypstate;
! 243: typedef struct yypstate yypstate;
! 244: enum { YYPUSH_MORE = 4 };
! 245:
! 246: ]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param)
! 247: ])b4_c_function_decl([[yypush_parse]], [[int]],
! 248: [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
! 249: [[[int yypushed_char]], [[yypushed_char]]],
! 250: [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
! 251: [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
! 252: b4_parse_param]))
! 253: b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]],
! 254: [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
! 255: b4_parse_param]))])
! 256: b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []])
! 257: b4_c_function_decl([[yypstate_delete]], [[void]],
! 258: [[[yypstate *yyps]], [[yyps]]])[
! 259: #endif]])
! 260:
! 261: b4_percent_code_get([[provides]])[]dnl
! 262:
! 263: [/* Copy the second part of user declarations. */
! 264: ]b4_user_post_prologue
! 265: b4_percent_code_get[]dnl
! 266:
! 267: [#ifdef short
! 268: # undef short
! 269: #endif
! 270:
! 271: #ifdef YYTYPE_UINT8
! 272: typedef YYTYPE_UINT8 yytype_uint8;
! 273: #else
! 274: typedef unsigned char yytype_uint8;
! 275: #endif
! 276:
! 277: #ifdef YYTYPE_INT8
! 278: typedef YYTYPE_INT8 yytype_int8;
! 279: #elif ]b4_c_modern[
! 280: typedef signed char yytype_int8;
! 281: #else
! 282: typedef short int yytype_int8;
! 283: #endif
! 284:
! 285: #ifdef YYTYPE_UINT16
! 286: typedef YYTYPE_UINT16 yytype_uint16;
! 287: #else
! 288: typedef unsigned short int yytype_uint16;
! 289: #endif
! 290:
! 291: #ifdef YYTYPE_INT16
! 292: typedef YYTYPE_INT16 yytype_int16;
! 293: #else
! 294: typedef short int yytype_int16;
! 295: #endif
! 296:
! 297: #ifndef YYSIZE_T
! 298: # ifdef __SIZE_TYPE__
! 299: # define YYSIZE_T __SIZE_TYPE__
! 300: # elif defined size_t
! 301: # define YYSIZE_T size_t
! 302: # elif ! defined YYSIZE_T && ]b4_c_modern[
! 303: # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
! 304: # define YYSIZE_T size_t
! 305: # else
! 306: # define YYSIZE_T unsigned int
! 307: # endif
! 308: #endif
! 309:
! 310: #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
! 311:
! 312: #ifndef YY_
! 313: # if defined YYENABLE_NLS && YYENABLE_NLS
! 314: # if ENABLE_NLS
! 315: # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
! 316: # define YY_(msgid) dgettext ("bison-runtime", msgid)
! 317: # endif
! 318: # endif
! 319: # ifndef YY_
! 320: # define YY_(msgid) msgid
! 321: # endif
! 322: #endif
! 323:
! 324: /* Suppress unused-variable warnings by "using" E. */
! 325: #if ! defined lint || defined __GNUC__
! 326: # define YYUSE(e) ((void) (e))
! 327: #else
! 328: # define YYUSE(e) /* empty */
! 329: #endif
! 330:
! 331: /* Identity function, used to suppress warnings about constant conditions. */
! 332: #ifndef lint
! 333: # define YYID(n) (n)
! 334: #else
! 335: ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
! 336: {
! 337: return yyi;
! 338: }
! 339: #endif
! 340:
! 341: #if ! defined yyoverflow || YYERROR_VERBOSE
! 342:
! 343: ]b4_push_if([],
! 344: [[/* The parser invokes alloca or malloc; define the necessary symbols. */
! 345:
! 346: # ifdef YYSTACK_USE_ALLOCA
! 347: # if YYSTACK_USE_ALLOCA
! 348: # ifdef __GNUC__
! 349: # define YYSTACK_ALLOC __builtin_alloca
! 350: # elif defined __BUILTIN_VA_ARG_INCR
! 351: # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
! 352: # elif defined _AIX
! 353: # define YYSTACK_ALLOC __alloca
! 354: # elif defined _MSC_VER
! 355: # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
! 356: # define alloca _alloca
! 357: # else
! 358: # define YYSTACK_ALLOC alloca
! 359: # if ! defined _ALLOCA_H && ! defined _STDLIB_H && ]b4_c_modern[
! 360: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
! 361: # ifndef _STDLIB_H
! 362: # define _STDLIB_H 1
! 363: # endif
! 364: # endif
! 365: # endif
! 366: # endif
! 367: # endif
! 368:
! 369: ]])dnl
! 370: [# ifdef YYSTACK_ALLOC
! 371: /* Pacify GCC's `empty if-body' warning. */
! 372: # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
! 373: # ifndef YYSTACK_ALLOC_MAXIMUM
! 374: /* The OS might guarantee only one guard page at the bottom of the stack,
! 375: and a page size can be as small as 4096 bytes. So we cannot safely
! 376: invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
! 377: to allow for a few compiler-allocated temporary stack slots. */
! 378: # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
! 379: # endif
! 380: # else
! 381: # define YYSTACK_ALLOC YYMALLOC
! 382: # define YYSTACK_FREE YYFREE
! 383: # ifndef YYSTACK_ALLOC_MAXIMUM
! 384: # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
! 385: # endif
! 386: # if (defined __cplusplus && ! defined _STDLIB_H \
! 387: && ! ((defined YYMALLOC || defined malloc) \
! 388: && (defined YYFREE || defined free)))
! 389: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
! 390: # ifndef _STDLIB_H
! 391: # define _STDLIB_H 1
! 392: # endif
! 393: # endif
! 394: # ifndef YYMALLOC
! 395: # define YYMALLOC malloc
! 396: # if ! defined malloc && ! defined _STDLIB_H && ]b4_c_modern[
! 397: void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
! 398: # endif
! 399: # endif
! 400: # ifndef YYFREE
! 401: # define YYFREE free
! 402: # if ! defined free && ! defined _STDLIB_H && ]b4_c_modern[
! 403: void free (void *); /* INFRINGES ON USER NAME SPACE */
! 404: # endif
! 405: # endif
! 406: # endif
! 407: #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
! 408:
! 409:
! 410: #if (! defined yyoverflow \
! 411: && (! defined __cplusplus \
! 412: || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
! 413: && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
! 414:
! 415: /* A type that is properly aligned for any stack member. */
! 416: union yyalloc
! 417: {
! 418: yytype_int16 yyss_alloc;
! 419: YYSTYPE yyvs_alloc;]b4_locations_if([
! 420: YYLTYPE yyls_alloc;])[
! 421: };
! 422:
! 423: /* The size of the maximum gap between one aligned stack and the next. */
! 424: # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
! 425:
! 426: /* The size of an array large to enough to hold all stacks, each with
! 427: N elements. */
! 428: ]b4_locations_if(
! 429: [# define YYSTACK_BYTES(N) \
! 430: ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
! 431: + 2 * YYSTACK_GAP_MAXIMUM)],
! 432: [# define YYSTACK_BYTES(N) \
! 433: ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
! 434: + YYSTACK_GAP_MAXIMUM)])[
! 435:
! 436: /* Copy COUNT objects from FROM to TO. The source and destination do
! 437: not overlap. */
! 438: # ifndef YYCOPY
! 439: # if defined __GNUC__ && 1 < __GNUC__
! 440: # define YYCOPY(To, From, Count) \
! 441: __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
! 442: # else
! 443: # define YYCOPY(To, From, Count) \
! 444: do \
! 445: { \
! 446: YYSIZE_T yyi; \
! 447: for (yyi = 0; yyi < (Count); yyi++) \
! 448: (To)[yyi] = (From)[yyi]; \
! 449: } \
! 450: while (YYID (0))
! 451: # endif
! 452: # endif
! 453:
! 454: /* Relocate STACK from its old location to the new one. The
! 455: local variables YYSIZE and YYSTACKSIZE give the old and new number of
! 456: elements in the stack, and YYPTR gives the new location of the
! 457: stack. Advance YYPTR to a properly aligned location for the next
! 458: stack. */
! 459: # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
! 460: do \
! 461: { \
! 462: YYSIZE_T yynewbytes; \
! 463: YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
! 464: Stack = &yyptr->Stack_alloc; \
! 465: yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
! 466: yyptr += yynewbytes / sizeof (*yyptr); \
! 467: } \
! 468: while (YYID (0))
! 469:
! 470: #endif
! 471:
! 472: /* YYFINAL -- State number of the termination state. */
! 473: #define YYFINAL ]b4_final_state_number[
! 474: /* YYLAST -- Last index in YYTABLE. */
! 475: #define YYLAST ]b4_last[
! 476:
! 477: /* YYNTOKENS -- Number of terminals. */
! 478: #define YYNTOKENS ]b4_tokens_number[
! 479: /* YYNNTS -- Number of nonterminals. */
! 480: #define YYNNTS ]b4_nterms_number[
! 481: /* YYNRULES -- Number of rules. */
! 482: #define YYNRULES ]b4_rules_number[
! 483: /* YYNRULES -- Number of states. */
! 484: #define YYNSTATES ]b4_states_number[
! 485:
! 486: /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
! 487: #define YYUNDEFTOK ]b4_undef_token_number[
! 488: #define YYMAXUTOK ]b4_user_token_number_max[
! 489:
! 490: #define YYTRANSLATE(YYX) \
! 491: ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
! 492:
! 493: /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
! 494: static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
! 495: {
! 496: ]b4_translate[
! 497: };
! 498:
! 499: #if YYDEBUG
! 500: /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
! 501: YYRHS. */
! 502: static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
! 503: {
! 504: ]b4_prhs[
! 505: };
! 506:
! 507: /* YYRHS -- A `-1'-separated list of the rules' RHS. */
! 508: static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
! 509: {
! 510: ]b4_rhs[
! 511: };
! 512:
! 513: /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
! 514: static const ]b4_int_type_for([b4_rline])[ yyrline[] =
! 515: {
! 516: ]b4_rline[
! 517: };
! 518: #endif
! 519:
! 520: #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
! 521: /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
! 522: First, the terminals, then, starting at YYNTOKENS, nonterminals. */
! 523: static const char *const yytname[] =
! 524: {
! 525: ]b4_tname[
! 526: };
! 527: #endif
! 528:
! 529: # ifdef YYPRINT
! 530: /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
! 531: token YYLEX-NUM. */
! 532: static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
! 533: {
! 534: ]b4_toknum[
! 535: };
! 536: # endif
! 537:
! 538: /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
! 539: static const ]b4_int_type_for([b4_r1])[ yyr1[] =
! 540: {
! 541: ]b4_r1[
! 542: };
! 543:
! 544: /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
! 545: static const ]b4_int_type_for([b4_r2])[ yyr2[] =
! 546: {
! 547: ]b4_r2[
! 548: };
! 549:
! 550: /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
! 551: STATE-NUM when YYTABLE doesn't specify something else to do. Zero
! 552: means the default is an error. */
! 553: static const ]b4_int_type_for([b4_defact])[ yydefact[] =
! 554: {
! 555: ]b4_defact[
! 556: };
! 557:
! 558: /* YYDEFGOTO[NTERM-NUM]. */
! 559: static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
! 560: {
! 561: ]b4_defgoto[
! 562: };
! 563:
! 564: /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
! 565: STATE-NUM. */
! 566: #define YYPACT_NINF ]b4_pact_ninf[
! 567: static const ]b4_int_type_for([b4_pact])[ yypact[] =
! 568: {
! 569: ]b4_pact[
! 570: };
! 571:
! 572: /* YYPGOTO[NTERM-NUM]. */
! 573: static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
! 574: {
! 575: ]b4_pgoto[
! 576: };
! 577:
! 578: /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
! 579: positive, shift that token. If negative, reduce the rule which
! 580: number is the opposite. If zero, do what YYDEFACT says.
! 581: If YYTABLE_NINF, syntax error. */
! 582: #define YYTABLE_NINF ]b4_table_ninf[
! 583: static const ]b4_int_type_for([b4_table])[ yytable[] =
! 584: {
! 585: ]b4_table[
! 586: };
! 587:
! 588: static const ]b4_int_type_for([b4_check])[ yycheck[] =
! 589: {
! 590: ]b4_check[
! 591: };
! 592:
! 593: /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
! 594: symbol of state STATE-NUM. */
! 595: static const ]b4_int_type_for([b4_stos])[ yystos[] =
! 596: {
! 597: ]b4_stos[
! 598: };
! 599:
! 600: #define yyerrok (yyerrstatus = 0)
! 601: #define yyclearin (yychar = YYEMPTY)
! 602: #define YYEMPTY (-2)
! 603: #define YYEOF 0
! 604:
! 605: #define YYACCEPT goto yyacceptlab
! 606: #define YYABORT goto yyabortlab
! 607: #define YYERROR goto yyerrorlab
! 608:
! 609:
! 610: /* Like YYERROR except do call yyerror. This remains here temporarily
! 611: to ease the transition to the new meaning of YYERROR, for GCC.
! 612: Once GCC version 2 has supplanted version 1, this can go. However,
! 613: YYFAIL appears to be in use. Nevertheless, it is formally deprecated
! 614: in Bison 2.4.2's NEWS entry, where a plan to phase it out is
! 615: discussed. */
! 616:
! 617: #define YYFAIL goto yyerrlab
! 618: #if defined YYFAIL
! 619: /* This is here to suppress warnings from the GCC cpp's
! 620: -Wunused-macros. Normally we don't worry about that warning, but
! 621: some users do, and we want to make it easy for users to remove
! 622: YYFAIL uses, which will produce warnings from Bison 2.5. */
! 623: #endif
! 624:
! 625: #define YYRECOVERING() (!!yyerrstatus)
! 626:
! 627: #define YYBACKUP(Token, Value) \
! 628: do \
! 629: if (yychar == YYEMPTY && yylen == 1) \
! 630: { \
! 631: yychar = (Token); \
! 632: yylval = (Value); \
! 633: yytoken = YYTRANSLATE (yychar); \
! 634: YYPOPSTACK (1); \
! 635: goto yybackup; \
! 636: } \
! 637: else \
! 638: { \
! 639: yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
! 640: YYERROR; \
! 641: } \
! 642: while (YYID (0))
! 643:
! 644:
! 645: #define YYTERROR 1
! 646: #define YYERRCODE 256
! 647:
! 648:
! 649: /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
! 650: If N is 0, then set CURRENT to the empty location which ends
! 651: the previous symbol: RHS[0] (always defined). */
! 652:
! 653: #define YYRHSLOC(Rhs, K) ((Rhs)[K])
! 654: #ifndef YYLLOC_DEFAULT
! 655: # define YYLLOC_DEFAULT(Current, Rhs, N) \
! 656: do \
! 657: if (YYID (N)) \
! 658: { \
! 659: (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
! 660: (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
! 661: (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
! 662: (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
! 663: } \
! 664: else \
! 665: { \
! 666: (Current).first_line = (Current).last_line = \
! 667: YYRHSLOC (Rhs, 0).last_line; \
! 668: (Current).first_column = (Current).last_column = \
! 669: YYRHSLOC (Rhs, 0).last_column; \
! 670: } \
! 671: while (YYID (0))
! 672: #endif
! 673:
! 674:
! 675: /* YY_LOCATION_PRINT -- Print the location on the stream.
! 676: This macro was not mandated originally: define only if we know
! 677: we won't break user code: when these are the locations we know. */
! 678:
! 679: #ifndef YY_LOCATION_PRINT
! 680: # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
! 681: # define YY_LOCATION_PRINT(File, Loc) \
! 682: fprintf (File, "%d.%d-%d.%d", \
! 683: (Loc).first_line, (Loc).first_column, \
! 684: (Loc).last_line, (Loc).last_column)
! 685: # else
! 686: # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
! 687: # endif
! 688: #endif
! 689:
! 690:
! 691: /* YYLEX -- calling `yylex' with the right arguments. */
! 692:
! 693: #ifdef YYLEX_PARAM
! 694: # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
! 695: #else
! 696: # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
! 697: #endif
! 698:
! 699: /* Enable debugging if requested. */
! 700: #if YYDEBUG
! 701:
! 702: # ifndef YYFPRINTF
! 703: # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
! 704: # define YYFPRINTF fprintf
! 705: # endif
! 706:
! 707: # define YYDPRINTF(Args) \
! 708: do { \
! 709: if (yydebug) \
! 710: YYFPRINTF Args; \
! 711: } while (YYID (0))
! 712:
! 713: # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
! 714: do { \
! 715: if (yydebug) \
! 716: { \
! 717: YYFPRINTF (stderr, "%s ", Title); \
! 718: yy_symbol_print (stderr, \
! 719: Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
! 720: YYFPRINTF (stderr, "\n"); \
! 721: } \
! 722: } while (YYID (0))
! 723:
! 724: ]b4_yy_symbol_print_generate([b4_c_function_def])[
! 725:
! 726: /*------------------------------------------------------------------.
! 727: | yy_stack_print -- Print the state stack from its BOTTOM up to its |
! 728: | TOP (included). |
! 729: `------------------------------------------------------------------*/
! 730:
! 731: ]b4_c_function_def([yy_stack_print], [static void],
! 732: [[yytype_int16 *yybottom], [yybottom]],
! 733: [[yytype_int16 *yytop], [yytop]])[
! 734: {
! 735: YYFPRINTF (stderr, "Stack now");
! 736: for (; yybottom <= yytop; yybottom++)
! 737: {
! 738: int yybot = *yybottom;
! 739: YYFPRINTF (stderr, " %d", yybot);
! 740: }
! 741: YYFPRINTF (stderr, "\n");
! 742: }
! 743:
! 744: # define YY_STACK_PRINT(Bottom, Top) \
! 745: do { \
! 746: if (yydebug) \
! 747: yy_stack_print ((Bottom), (Top)); \
! 748: } while (YYID (0))
! 749:
! 750:
! 751: /*------------------------------------------------.
! 752: | Report that the YYRULE is going to be reduced. |
! 753: `------------------------------------------------*/
! 754:
! 755: ]b4_c_function_def([yy_reduce_print], [static void],
! 756: [[YYSTYPE *yyvsp], [yyvsp]],
! 757: b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
! 758: ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
! 759: b4_parse_param]))[
! 760: {
! 761: int yynrhs = yyr2[yyrule];
! 762: int yyi;
! 763: unsigned long int yylno = yyrline[yyrule];
! 764: YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
! 765: yyrule - 1, yylno);
! 766: /* The symbols being reduced. */
! 767: for (yyi = 0; yyi < yynrhs; yyi++)
! 768: {
! 769: YYFPRINTF (stderr, " $%d = ", yyi + 1);
! 770: yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
! 771: &]b4_rhs_value(yynrhs, yyi + 1)[
! 772: ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
! 773: b4_user_args[);
! 774: YYFPRINTF (stderr, "\n");
! 775: }
! 776: }
! 777:
! 778: # define YY_REDUCE_PRINT(Rule) \
! 779: do { \
! 780: if (yydebug) \
! 781: yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
! 782: } while (YYID (0))
! 783:
! 784: /* Nonzero means print parse trace. It is left uninitialized so that
! 785: multiple parsers can coexist. */
! 786: int yydebug;
! 787: #else /* !YYDEBUG */
! 788: # define YYDPRINTF(Args)
! 789: # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
! 790: # define YY_STACK_PRINT(Bottom, Top)
! 791: # define YY_REDUCE_PRINT(Rule)
! 792: #endif /* !YYDEBUG */
! 793:
! 794:
! 795: /* YYINITDEPTH -- initial size of the parser's stacks. */
! 796: #ifndef YYINITDEPTH
! 797: # define YYINITDEPTH ]b4_stack_depth_init[
! 798: #endif
! 799:
! 800: /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
! 801: if the built-in stack extension method is used).
! 802:
! 803: Do not make this value too large; the results are undefined if
! 804: YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
! 805: evaluated with infinite-precision integer arithmetic. */
! 806:
! 807: #ifndef YYMAXDEPTH
! 808: # define YYMAXDEPTH ]b4_stack_depth_max[
! 809: #endif
! 810:
! 811:
! 812:
! 813: #if YYERROR_VERBOSE
! 814:
! 815: # ifndef yystrlen
! 816: # if defined __GLIBC__ && defined _STRING_H
! 817: # define yystrlen strlen
! 818: # else
! 819: /* Return the length of YYSTR. */
! 820: ]b4_c_function_def([yystrlen], [static YYSIZE_T],
! 821: [[const char *yystr], [yystr]])[
! 822: {
! 823: YYSIZE_T yylen;
! 824: for (yylen = 0; yystr[yylen]; yylen++)
! 825: continue;
! 826: return yylen;
! 827: }
! 828: # endif
! 829: # endif
! 830:
! 831: # ifndef yystpcpy
! 832: # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
! 833: # define yystpcpy stpcpy
! 834: # else
! 835: /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
! 836: YYDEST. */
! 837: ]b4_c_function_def([yystpcpy], [static char *],
! 838: [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
! 839: {
! 840: char *yyd = yydest;
! 841: const char *yys = yysrc;
! 842:
! 843: while ((*yyd++ = *yys++) != '\0')
! 844: continue;
! 845:
! 846: return yyd - 1;
! 847: }
! 848: # endif
! 849: # endif
! 850:
! 851: # ifndef yytnamerr
! 852: /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
! 853: quotes and backslashes, so that it's suitable for yyerror. The
! 854: heuristic is that double-quoting is unnecessary unless the string
! 855: contains an apostrophe, a comma, or backslash (other than
! 856: backslash-backslash). YYSTR is taken from yytname. If YYRES is
! 857: null, do not copy; instead, return the length of what the result
! 858: would have been. */
! 859: static YYSIZE_T
! 860: yytnamerr (char *yyres, const char *yystr)
! 861: {
! 862: if (*yystr == '"')
! 863: {
! 864: YYSIZE_T yyn = 0;
! 865: char const *yyp = yystr;
! 866:
! 867: for (;;)
! 868: switch (*++yyp)
! 869: {
! 870: case '\'':
! 871: case ',':
! 872: goto do_not_strip_quotes;
! 873:
! 874: case '\\':
! 875: if (*++yyp != '\\')
! 876: goto do_not_strip_quotes;
! 877: /* Fall through. */
! 878: default:
! 879: if (yyres)
! 880: yyres[yyn] = *yyp;
! 881: yyn++;
! 882: break;
! 883:
! 884: case '"':
! 885: if (yyres)
! 886: yyres[yyn] = '\0';
! 887: return yyn;
! 888: }
! 889: do_not_strip_quotes: ;
! 890: }
! 891:
! 892: if (! yyres)
! 893: return yystrlen (yystr);
! 894:
! 895: return yystpcpy (yyres, yystr) - yyres;
! 896: }
! 897: # endif
! 898:
! 899: /* Copy into YYRESULT an error message about the unexpected token
! 900: YYCHAR while in state YYSTATE. Return the number of bytes copied,
! 901: including the terminating null byte. If YYRESULT is null, do not
! 902: copy anything; just return the number of bytes that would be
! 903: copied. As a special case, return 0 if an ordinary "syntax error"
! 904: message will do. Return YYSIZE_MAXIMUM if overflow occurs during
! 905: size calculation. */
! 906: static YYSIZE_T
! 907: yysyntax_error (char *yyresult, int yystate, int yychar)
! 908: {
! 909: int yyn = yypact[yystate];
! 910:
! 911: if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
! 912: return 0;
! 913: else
! 914: {
! 915: int yytype = YYTRANSLATE (yychar);
! 916: YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
! 917: YYSIZE_T yysize = yysize0;
! 918: YYSIZE_T yysize1;
! 919: int yysize_overflow = 0;
! 920: enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
! 921: char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
! 922: int yyx;
! 923:
! 924: # if 0
! 925: /* This is so xgettext sees the translatable formats that are
! 926: constructed on the fly. */
! 927: YY_("syntax error, unexpected %s");
! 928: YY_("syntax error, unexpected %s, expecting %s");
! 929: YY_("syntax error, unexpected %s, expecting %s or %s");
! 930: YY_("syntax error, unexpected %s, expecting %s or %s or %s");
! 931: YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
! 932: # endif
! 933: char *yyfmt;
! 934: char const *yyf;
! 935: static char const yyunexpected[] = "syntax error, unexpected %s";
! 936: static char const yyexpecting[] = ", expecting %s";
! 937: static char const yyor[] = " or %s";
! 938: char yyformat[sizeof yyunexpected
! 939: + sizeof yyexpecting - 1
! 940: + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
! 941: * (sizeof yyor - 1))];
! 942: char const *yyprefix = yyexpecting;
! 943:
! 944: /* Start YYX at -YYN if negative to avoid negative indexes in
! 945: YYCHECK. */
! 946: int yyxbegin = yyn < 0 ? -yyn : 0;
! 947:
! 948: /* Stay within bounds of both yycheck and yytname. */
! 949: int yychecklim = YYLAST - yyn + 1;
! 950: int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
! 951: int yycount = 1;
! 952:
! 953: yyarg[0] = yytname[yytype];
! 954: yyfmt = yystpcpy (yyformat, yyunexpected);
! 955:
! 956: for (yyx = yyxbegin; yyx < yyxend; ++yyx)
! 957: if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
! 958: {
! 959: if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
! 960: {
! 961: yycount = 1;
! 962: yysize = yysize0;
! 963: yyformat[sizeof yyunexpected - 1] = '\0';
! 964: break;
! 965: }
! 966: yyarg[yycount++] = yytname[yyx];
! 967: yysize1 = yysize + yytnamerr (0, yytname[yyx]);
! 968: yysize_overflow |= (yysize1 < yysize);
! 969: yysize = yysize1;
! 970: yyfmt = yystpcpy (yyfmt, yyprefix);
! 971: yyprefix = yyor;
! 972: }
! 973:
! 974: yyf = YY_(yyformat);
! 975: yysize1 = yysize + yystrlen (yyf);
! 976: yysize_overflow |= (yysize1 < yysize);
! 977: yysize = yysize1;
! 978:
! 979: if (yysize_overflow)
! 980: return YYSIZE_MAXIMUM;
! 981:
! 982: if (yyresult)
! 983: {
! 984: /* Avoid sprintf, as that infringes on the user's name space.
! 985: Don't have undefined behavior even if the translation
! 986: produced a string with the wrong number of "%s"s. */
! 987: char *yyp = yyresult;
! 988: int yyi = 0;
! 989: while ((*yyp = *yyf) != '\0')
! 990: {
! 991: if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
! 992: {
! 993: yyp += yytnamerr (yyp, yyarg[yyi++]);
! 994: yyf += 2;
! 995: }
! 996: else
! 997: {
! 998: yyp++;
! 999: yyf++;
! 1000: }
! 1001: }
! 1002: }
! 1003: return yysize;
! 1004: }
! 1005: }
! 1006: #endif /* YYERROR_VERBOSE */
! 1007:
! 1008:
! 1009: ]b4_yydestruct_generate([b4_c_function_def])[
! 1010:
! 1011: ]b4_push_if([],
! 1012: [[/* Prevent warnings from -Wmissing-prototypes. */
! 1013: #ifdef YYPARSE_PARAM
! 1014: ]b4_c_function_decl([yyparse], [int],
! 1015: [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
! 1016: #else /* ! YYPARSE_PARAM */
! 1017: ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
! 1018: #endif /* ! YYPARSE_PARAM */]])
! 1019:
! 1020: m4_divert_push([KILL])# ======================== M4 code.
! 1021: # b4_declare_scanner_communication_variables
! 1022: # ------------------------------------------
! 1023: # Declare the variables that are global, or local to YYPARSE if
! 1024: # pure-parser.
! 1025: m4_define([b4_declare_scanner_communication_variables],
! 1026: [[/* The lookahead symbol. */
! 1027: int yychar;
! 1028:
! 1029: /* The semantic value of the lookahead symbol. */
! 1030: YYSTYPE yylval;
! 1031: ]b4_locations_if([[
! 1032: /* Location data for the lookahead symbol. */
! 1033: YYLTYPE yylloc;
! 1034: ]])b4_pure_if([], [[
! 1035: /* Number of syntax errors so far. */
! 1036: int yynerrs;
! 1037: ]])])
! 1038:
! 1039: # b4_declare_parser_state_variables
! 1040: # ---------------------------------
! 1041: # Declare all the variables that are needed to maintain the parser state
! 1042: # between calls to yypush_parse.
! 1043: m4_define([b4_declare_parser_state_variables],
! 1044: [b4_pure_if([[ /* Number of syntax errors so far. */
! 1045: int yynerrs;
! 1046: ]])[
! 1047: int yystate;
! 1048: /* Number of tokens to shift before error messages enabled. */
! 1049: int yyerrstatus;
! 1050:
! 1051: /* The stacks and their tools:
! 1052: `yyss': related to states.
! 1053: `yyvs': related to semantic values.]b4_locations_if([[
! 1054: `yyls': related to locations.]])[
! 1055:
! 1056: Refer to the stacks thru separate pointers, to allow yyoverflow
! 1057: to reallocate them elsewhere. */
! 1058:
! 1059: /* The state stack. */
! 1060: yytype_int16 yyssa[YYINITDEPTH];
! 1061: yytype_int16 *yyss;
! 1062: yytype_int16 *yyssp;
! 1063:
! 1064: /* The semantic value stack. */
! 1065: YYSTYPE yyvsa[YYINITDEPTH];
! 1066: YYSTYPE *yyvs;
! 1067: YYSTYPE *yyvsp;
! 1068: ]b4_locations_if([[
! 1069: /* The location stack. */
! 1070: YYLTYPE yylsa[YYINITDEPTH];
! 1071: YYLTYPE *yyls;
! 1072: YYLTYPE *yylsp;
! 1073:
! 1074: /* The locations where the error started and ended. */
! 1075: YYLTYPE yyerror_range[2];
! 1076: ]])[
! 1077: YYSIZE_T yystacksize;
! 1078: ]])
! 1079:
! 1080: m4_divert_pop([KILL])dnl# ====================== End of M4 code.
! 1081:
! 1082: b4_pure_if([], [b4_declare_scanner_communication_variables])
! 1083:
! 1084: b4_push_if(
! 1085: [[struct yypstate
! 1086: {
! 1087: ]b4_declare_parser_state_variables[
! 1088: /* Used to determine if this is the first time this instance has
! 1089: been used. */
! 1090: int yynew;
! 1091: };]b4_pure_if([], [[
! 1092:
! 1093: static char yypstate_allocated = 0;]])b4_pull_if([
! 1094:
! 1095: b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
! 1096: {
! 1097: return yypull_parse (0]m4_ifset([b4_parse_param],
! 1098: [[, ]b4_c_args(b4_parse_param)])[);
! 1099: }
! 1100:
! 1101: ]b4_c_function_def([[yypull_parse]], [[int]],
! 1102: [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
! 1103: b4_parse_param]))[
! 1104: {
! 1105: int yystatus;
! 1106: yypstate *yyps_local;]b4_pure_if([[
! 1107: int yychar;
! 1108: YYSTYPE yylval;]b4_locations_if([[
! 1109: YYLTYPE yylloc;]])])[
! 1110: if (yyps == 0)
! 1111: {
! 1112: yyps_local = yypstate_new ();
! 1113: if (!yyps_local)
! 1114: {]b4_pure_if([[
! 1115: yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
! 1116: if (!yypstate_allocated)
! 1117: yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
! 1118: return 2;
! 1119: }
! 1120: }
! 1121: else
! 1122: yyps_local = yyps;
! 1123: do {
! 1124: yychar = YYLEX;
! 1125: yystatus =
! 1126: yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
! 1127: } while (yystatus == YYPUSH_MORE);
! 1128: if (yyps == 0)
! 1129: yypstate_delete (yyps_local);
! 1130: return yystatus;
! 1131: }]])[
! 1132:
! 1133: /* Initialize the parser data structure. */
! 1134: ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
! 1135: {
! 1136: yypstate *yyps;]b4_pure_if([], [[
! 1137: if (yypstate_allocated)
! 1138: return 0;]])[
! 1139: yyps = (yypstate *) malloc (sizeof *yyps);
! 1140: if (!yyps)
! 1141: return 0;
! 1142: yyps->yynew = 1;]b4_pure_if([], [[
! 1143: yypstate_allocated = 1;]])[
! 1144: return yyps;
! 1145: }
! 1146:
! 1147: ]b4_c_function_def([[yypstate_delete]], [[void]],
! 1148: [[[yypstate *yyps]], [[yyps]]])[
! 1149: {
! 1150: #ifndef yyoverflow
! 1151: /* If the stack was reallocated but the parse did not complete, then the
! 1152: stack still needs to be freed. */
! 1153: if (!yyps->yynew && yyps->yyss != yyps->yyssa)
! 1154: YYSTACK_FREE (yyps->yyss);
! 1155: #endif
! 1156: free (yyps);]b4_pure_if([], [[
! 1157: yypstate_allocated = 0;]])[
! 1158: }
! 1159:
! 1160: ]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs
! 1161: ]])[#define yystate yyps->yystate
! 1162: #define yyerrstatus yyps->yyerrstatus
! 1163: #define yyssa yyps->yyssa
! 1164: #define yyss yyps->yyss
! 1165: #define yyssp yyps->yyssp
! 1166: #define yyvsa yyps->yyvsa
! 1167: #define yyvs yyps->yyvs
! 1168: #define yyvsp yyps->yyvsp
! 1169: ]b4_locations_if([[#define yylsa yyps->yylsa
! 1170: #define yyls yyps->yyls
! 1171: #define yylsp yyps->yylsp
! 1172: #define yyerror_range yyps->yyerror_range
! 1173: ]])[#define yystacksize yyps->yystacksize
! 1174: ]])[
! 1175: /*-------------------------.
! 1176: | yyparse or yypush_parse. |
! 1177: `-------------------------*/
! 1178: ]b4_push_if([
! 1179: b4_c_function_def([[yypush_parse]], [[int]],
! 1180: [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
! 1181: [[[int yypushed_char]], [[yypushed_char]]],
! 1182: [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
! 1183: [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
! 1184: b4_parse_param]))], [
! 1185: #ifdef YYPARSE_PARAM
! 1186: b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
! 1187: #else /* ! YYPARSE_PARAM */
! 1188: b4_c_function_def([yyparse], [int], b4_parse_param)
! 1189: #endif])[
! 1190: {
! 1191: ]b4_pure_if([b4_declare_scanner_communication_variables])
! 1192: b4_push_if([b4_pure_if([], [[ int yypushed_char = yychar;
! 1193: YYSTYPE yypushed_val = yylval;
! 1194: ]b4_locations_if([[YYLTYPE yypushed_loc = yylloc;
! 1195: ]])])],
! 1196: [b4_declare_parser_state_variables])[
! 1197: int yyn;
! 1198: int yyresult;
! 1199: /* Lookahead token as an internal (translated) token number. */
! 1200: int yytoken;
! 1201: /* The variables used to return semantic value and location from the
! 1202: action routines. */
! 1203: YYSTYPE yyval;]b4_locations_if([[
! 1204: YYLTYPE yyloc;]])[
! 1205:
! 1206: #if YYERROR_VERBOSE
! 1207: /* Buffer for error messages, and its allocated size. */
! 1208: char yymsgbuf[128];
! 1209: char *yymsg = yymsgbuf;
! 1210: YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
! 1211: #endif
! 1212:
! 1213: #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
! 1214:
! 1215: /* The number of symbols on the RHS of the reduced rule.
! 1216: Keep to zero when no symbol should be popped. */
! 1217: int yylen = 0;]b4_push_if([[
! 1218:
! 1219: if (!yyps->yynew)
! 1220: {
! 1221: yyn = yypact[yystate];
! 1222: goto yyread_pushed_token;
! 1223: }]])[
! 1224:
! 1225: yytoken = 0;
! 1226: yyss = yyssa;
! 1227: yyvs = yyvsa;]b4_locations_if([[
! 1228: yyls = yylsa;]])[
! 1229: yystacksize = YYINITDEPTH;
! 1230:
! 1231: YYDPRINTF ((stderr, "Starting parse\n"));
! 1232:
! 1233: yystate = 0;
! 1234: yyerrstatus = 0;
! 1235: yynerrs = 0;
! 1236: yychar = YYEMPTY; /* Cause a token to be read. */
! 1237:
! 1238: /* Initialize stack pointers.
! 1239: Waste one element of value and location stack
! 1240: so that they stay on the same level as the state stack.
! 1241: The wasted elements are never initialized. */
! 1242: yyssp = yyss;
! 1243: yyvsp = yyvs;]b4_locations_if([[
! 1244: yylsp = yyls;
! 1245:
! 1246: #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
! 1247: /* Initialize the default location before parsing starts. */
! 1248: yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
! 1249: yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
! 1250: #endif]])
! 1251: m4_ifdef([b4_initial_action],[
! 1252: m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
! 1253: m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
! 1254: /* User initialization code. */
! 1255: b4_user_initial_action
! 1256: m4_popdef([b4_dollar_dollar])dnl
! 1257: m4_popdef([b4_at_dollar])])dnl
! 1258: m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
! 1259: ]])dnl
! 1260: m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
! 1261: ]])[
! 1262: goto yysetstate;
! 1263:
! 1264: /*------------------------------------------------------------.
! 1265: | yynewstate -- Push a new state, which is found in yystate. |
! 1266: `------------------------------------------------------------*/
! 1267: yynewstate:
! 1268: /* In all cases, when you get here, the value and location stacks
! 1269: have just been pushed. So pushing a state here evens the stacks. */
! 1270: yyssp++;
! 1271:
! 1272: yysetstate:
! 1273: *yyssp = yystate;
! 1274:
! 1275: if (yyss + yystacksize - 1 <= yyssp)
! 1276: {
! 1277: /* Get the current used size of the three stacks, in elements. */
! 1278: YYSIZE_T yysize = yyssp - yyss + 1;
! 1279:
! 1280: #ifdef yyoverflow
! 1281: {
! 1282: /* Give user a chance to reallocate the stack. Use copies of
! 1283: these so that the &'s don't force the real ones into
! 1284: memory. */
! 1285: YYSTYPE *yyvs1 = yyvs;
! 1286: yytype_int16 *yyss1 = yyss;]b4_locations_if([
! 1287: YYLTYPE *yyls1 = yyls;])[
! 1288:
! 1289: /* Each stack pointer address is followed by the size of the
! 1290: data in use in that stack, in bytes. This used to be a
! 1291: conditional around just the two extra args, but that might
! 1292: be undefined if yyoverflow is a macro. */
! 1293: yyoverflow (YY_("memory exhausted"),
! 1294: &yyss1, yysize * sizeof (*yyssp),
! 1295: &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
! 1296: &yyls1, yysize * sizeof (*yylsp),])[
! 1297: &yystacksize);
! 1298: ]b4_locations_if([
! 1299: yyls = yyls1;])[
! 1300: yyss = yyss1;
! 1301: yyvs = yyvs1;
! 1302: }
! 1303: #else /* no yyoverflow */
! 1304: # ifndef YYSTACK_RELOCATE
! 1305: goto yyexhaustedlab;
! 1306: # else
! 1307: /* Extend the stack our own way. */
! 1308: if (YYMAXDEPTH <= yystacksize)
! 1309: goto yyexhaustedlab;
! 1310: yystacksize *= 2;
! 1311: if (YYMAXDEPTH < yystacksize)
! 1312: yystacksize = YYMAXDEPTH;
! 1313:
! 1314: {
! 1315: yytype_int16 *yyss1 = yyss;
! 1316: union yyalloc *yyptr =
! 1317: (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
! 1318: if (! yyptr)
! 1319: goto yyexhaustedlab;
! 1320: YYSTACK_RELOCATE (yyss_alloc, yyss);
! 1321: YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
! 1322: YYSTACK_RELOCATE (yyls_alloc, yyls);])[
! 1323: # undef YYSTACK_RELOCATE
! 1324: if (yyss1 != yyssa)
! 1325: YYSTACK_FREE (yyss1);
! 1326: }
! 1327: # endif
! 1328: #endif /* no yyoverflow */
! 1329:
! 1330: yyssp = yyss + yysize - 1;
! 1331: yyvsp = yyvs + yysize - 1;]b4_locations_if([
! 1332: yylsp = yyls + yysize - 1;])[
! 1333:
! 1334: YYDPRINTF ((stderr, "Stack size increased to %lu\n",
! 1335: (unsigned long int) yystacksize));
! 1336:
! 1337: if (yyss + yystacksize - 1 <= yyssp)
! 1338: YYABORT;
! 1339: }
! 1340:
! 1341: YYDPRINTF ((stderr, "Entering state %d\n", yystate));
! 1342:
! 1343: if (yystate == YYFINAL)
! 1344: YYACCEPT;
! 1345:
! 1346: goto yybackup;
! 1347:
! 1348: /*-----------.
! 1349: | yybackup. |
! 1350: `-----------*/
! 1351: yybackup:
! 1352:
! 1353: /* Do appropriate processing given the current state. Read a
! 1354: lookahead token if we need one and don't already have one. */
! 1355:
! 1356: /* First try to decide what to do without reference to lookahead token. */
! 1357: yyn = yypact[yystate];
! 1358: if (yyn == YYPACT_NINF)
! 1359: goto yydefault;
! 1360:
! 1361: /* Not known => get a lookahead token if don't already have one. */
! 1362:
! 1363: /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
! 1364: if (yychar == YYEMPTY)
! 1365: {]b4_push_if([[
! 1366: if (!yyps->yynew)
! 1367: {]b4_use_push_for_pull_if([], [[
! 1368: YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
! 1369: yyresult = YYPUSH_MORE;
! 1370: goto yypushreturn;
! 1371: }
! 1372: yyps->yynew = 0;]b4_pure_if([], [[
! 1373: /* Restoring the pushed token is only necessary for the first
! 1374: yypush_parse invocation since subsequent invocations don't overwrite
! 1375: it before jumping to yyread_pushed_token. */
! 1376: yychar = yypushed_char;
! 1377: yylval = yypushed_val;]b4_locations_if([[
! 1378: yylloc = yypushed_loc;]])])[
! 1379: yyread_pushed_token:]])[
! 1380: YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
! 1381: yychar = yypushed_char;
! 1382: if (yypushed_val)
! 1383: yylval = *yypushed_val;]b4_locations_if([[
! 1384: if (yypushed_loc)
! 1385: yylloc = *yypushed_loc;]])])], [[
! 1386: yychar = YYLEX;]])[
! 1387: }
! 1388:
! 1389: if (yychar <= YYEOF)
! 1390: {
! 1391: yychar = yytoken = YYEOF;
! 1392: YYDPRINTF ((stderr, "Now at end of input.\n"));
! 1393: }
! 1394: else
! 1395: {
! 1396: yytoken = YYTRANSLATE (yychar);
! 1397: YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
! 1398: }
! 1399:
! 1400: /* If the proper action on seeing token YYTOKEN is to reduce or to
! 1401: detect an error, take that action. */
! 1402: yyn += yytoken;
! 1403: if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
! 1404: goto yydefault;
! 1405: yyn = yytable[yyn];
! 1406: if (yyn <= 0)
! 1407: {
! 1408: if (yyn == 0 || yyn == YYTABLE_NINF)
! 1409: goto yyerrlab;
! 1410: yyn = -yyn;
! 1411: goto yyreduce;
! 1412: }
! 1413:
! 1414: /* Count tokens shifted since error; after three, turn off error
! 1415: status. */
! 1416: if (yyerrstatus)
! 1417: yyerrstatus--;
! 1418:
! 1419: /* Shift the lookahead token. */
! 1420: YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
! 1421:
! 1422: /* Discard the shifted token. */
! 1423: yychar = YYEMPTY;
! 1424:
! 1425: yystate = yyn;
! 1426: *++yyvsp = yylval;
! 1427: ]b4_locations_if([ *++yylsp = yylloc;])[
! 1428: goto yynewstate;
! 1429:
! 1430:
! 1431: /*-----------------------------------------------------------.
! 1432: | yydefault -- do the default action for the current state. |
! 1433: `-----------------------------------------------------------*/
! 1434: yydefault:
! 1435: yyn = yydefact[yystate];
! 1436: if (yyn == 0)
! 1437: goto yyerrlab;
! 1438: goto yyreduce;
! 1439:
! 1440:
! 1441: /*-----------------------------.
! 1442: | yyreduce -- Do a reduction. |
! 1443: `-----------------------------*/
! 1444: yyreduce:
! 1445: /* yyn is the number of a rule to reduce with. */
! 1446: yylen = yyr2[yyn];
! 1447:
! 1448: /* If YYLEN is nonzero, implement the default value of the action:
! 1449: `$$ = $1'.
! 1450:
! 1451: Otherwise, the following line sets YYVAL to garbage.
! 1452: This behavior is undocumented and Bison
! 1453: users should not rely upon it. Assigning to YYVAL
! 1454: unconditionally makes the parser a bit smaller, and it avoids a
! 1455: GCC warning that YYVAL may be used uninitialized. */
! 1456: yyval = yyvsp[1-yylen];
! 1457:
! 1458: ]b4_locations_if(
! 1459: [[ /* Default location. */
! 1460: YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
! 1461: YY_REDUCE_PRINT (yyn);
! 1462: switch (yyn)
! 1463: {
! 1464: ]b4_user_actions[
! 1465: default: break;
! 1466: }
! 1467: YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
! 1468:
! 1469: YYPOPSTACK (yylen);
! 1470: yylen = 0;
! 1471: YY_STACK_PRINT (yyss, yyssp);
! 1472:
! 1473: *++yyvsp = yyval;]b4_locations_if([
! 1474: *++yylsp = yyloc;])[
! 1475:
! 1476: /* Now `shift' the result of the reduction. Determine what state
! 1477: that goes to, based on the state we popped back to and the rule
! 1478: number reduced by. */
! 1479:
! 1480: yyn = yyr1[yyn];
! 1481:
! 1482: yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
! 1483: if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
! 1484: yystate = yytable[yystate];
! 1485: else
! 1486: yystate = yydefgoto[yyn - YYNTOKENS];
! 1487:
! 1488: goto yynewstate;
! 1489:
! 1490:
! 1491: /*------------------------------------.
! 1492: | yyerrlab -- here on detecting error |
! 1493: `------------------------------------*/
! 1494: yyerrlab:
! 1495: /* If not already recovering from an error, report this error. */
! 1496: if (!yyerrstatus)
! 1497: {
! 1498: ++yynerrs;
! 1499: #if ! YYERROR_VERBOSE
! 1500: yyerror (]b4_yyerror_args[YY_("syntax error"));
! 1501: #else
! 1502: {
! 1503: YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
! 1504: if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
! 1505: {
! 1506: YYSIZE_T yyalloc = 2 * yysize;
! 1507: if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
! 1508: yyalloc = YYSTACK_ALLOC_MAXIMUM;
! 1509: if (yymsg != yymsgbuf)
! 1510: YYSTACK_FREE (yymsg);
! 1511: yymsg = (char *) YYSTACK_ALLOC (yyalloc);
! 1512: if (yymsg)
! 1513: yymsg_alloc = yyalloc;
! 1514: else
! 1515: {
! 1516: yymsg = yymsgbuf;
! 1517: yymsg_alloc = sizeof yymsgbuf;
! 1518: }
! 1519: }
! 1520:
! 1521: if (0 < yysize && yysize <= yymsg_alloc)
! 1522: {
! 1523: (void) yysyntax_error (yymsg, yystate, yychar);
! 1524: yyerror (]b4_yyerror_args[yymsg);
! 1525: }
! 1526: else
! 1527: {
! 1528: yyerror (]b4_yyerror_args[YY_("syntax error"));
! 1529: if (yysize != 0)
! 1530: goto yyexhaustedlab;
! 1531: }
! 1532: }
! 1533: #endif
! 1534: }
! 1535:
! 1536: ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[
! 1537:
! 1538: if (yyerrstatus == 3)
! 1539: {
! 1540: /* If just tried and failed to reuse lookahead token after an
! 1541: error, discard it. */
! 1542:
! 1543: if (yychar <= YYEOF)
! 1544: {
! 1545: /* Return failure if at end of input. */
! 1546: if (yychar == YYEOF)
! 1547: YYABORT;
! 1548: }
! 1549: else
! 1550: {
! 1551: yydestruct ("Error: discarding",
! 1552: yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
! 1553: yychar = YYEMPTY;
! 1554: }
! 1555: }
! 1556:
! 1557: /* Else will try to reuse lookahead token after shifting the error
! 1558: token. */
! 1559: goto yyerrlab1;
! 1560:
! 1561:
! 1562: /*---------------------------------------------------.
! 1563: | yyerrorlab -- error raised explicitly by YYERROR. |
! 1564: `---------------------------------------------------*/
! 1565: yyerrorlab:
! 1566:
! 1567: /* Pacify compilers like GCC when the user code never invokes
! 1568: YYERROR and the label yyerrorlab therefore never appears in user
! 1569: code. */
! 1570: if (/*CONSTCOND*/ 0)
! 1571: goto yyerrorlab;
! 1572:
! 1573: ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen];
! 1574: ]])[ /* Do not reclaim the symbols of the rule which action triggered
! 1575: this YYERROR. */
! 1576: YYPOPSTACK (yylen);
! 1577: yylen = 0;
! 1578: YY_STACK_PRINT (yyss, yyssp);
! 1579: yystate = *yyssp;
! 1580: goto yyerrlab1;
! 1581:
! 1582:
! 1583: /*-------------------------------------------------------------.
! 1584: | yyerrlab1 -- common code for both syntax error and YYERROR. |
! 1585: `-------------------------------------------------------------*/
! 1586: yyerrlab1:
! 1587: yyerrstatus = 3; /* Each real token shifted decrements this. */
! 1588:
! 1589: for (;;)
! 1590: {
! 1591: yyn = yypact[yystate];
! 1592: if (yyn != YYPACT_NINF)
! 1593: {
! 1594: yyn += YYTERROR;
! 1595: if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
! 1596: {
! 1597: yyn = yytable[yyn];
! 1598: if (0 < yyn)
! 1599: break;
! 1600: }
! 1601: }
! 1602:
! 1603: /* Pop the current state because it cannot handle the error token. */
! 1604: if (yyssp == yyss)
! 1605: YYABORT;
! 1606:
! 1607: ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[
! 1608: yydestruct ("Error: popping",
! 1609: yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
! 1610: YYPOPSTACK (1);
! 1611: yystate = *yyssp;
! 1612: YY_STACK_PRINT (yyss, yyssp);
! 1613: }
! 1614:
! 1615: *++yyvsp = yylval;
! 1616: ]b4_locations_if([[
! 1617: yyerror_range[1] = yylloc;
! 1618: /* Using YYLLOC is tempting, but would change the location of
! 1619: the lookahead. YYLOC is available though. */
! 1620: YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
! 1621: *++yylsp = yyloc;]])[
! 1622:
! 1623: /* Shift the error token. */
! 1624: YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
! 1625:
! 1626: yystate = yyn;
! 1627: goto yynewstate;
! 1628:
! 1629:
! 1630: /*-------------------------------------.
! 1631: | yyacceptlab -- YYACCEPT comes here. |
! 1632: `-------------------------------------*/
! 1633: yyacceptlab:
! 1634: yyresult = 0;
! 1635: goto yyreturn;
! 1636:
! 1637: /*-----------------------------------.
! 1638: | yyabortlab -- YYABORT comes here. |
! 1639: `-----------------------------------*/
! 1640: yyabortlab:
! 1641: yyresult = 1;
! 1642: goto yyreturn;
! 1643:
! 1644: #if !defined(yyoverflow) || YYERROR_VERBOSE
! 1645: /*-------------------------------------------------.
! 1646: | yyexhaustedlab -- memory exhaustion comes here. |
! 1647: `-------------------------------------------------*/
! 1648: yyexhaustedlab:
! 1649: yyerror (]b4_yyerror_args[YY_("memory exhausted"));
! 1650: yyresult = 2;
! 1651: /* Fall through. */
! 1652: #endif
! 1653:
! 1654: yyreturn:
! 1655: if (yychar != YYEMPTY)
! 1656: yydestruct ("Cleanup: discarding lookahead",
! 1657: yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
! 1658: /* Do not reclaim the symbols of the rule which action triggered
! 1659: this YYABORT or YYACCEPT. */
! 1660: YYPOPSTACK (yylen);
! 1661: YY_STACK_PRINT (yyss, yyssp);
! 1662: while (yyssp != yyss)
! 1663: {
! 1664: yydestruct ("Cleanup: popping",
! 1665: yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
! 1666: YYPOPSTACK (1);
! 1667: }
! 1668: #ifndef yyoverflow
! 1669: if (yyss != yyssa)
! 1670: YYSTACK_FREE (yyss);
! 1671: #endif
! 1672: ]b4_push_if([[ yyps->yynew = 1;
! 1673:
! 1674: yypushreturn:
! 1675: ]])[#if YYERROR_VERBOSE
! 1676: if (yymsg != yymsgbuf)
! 1677: YYSTACK_FREE (yymsg);
! 1678: #endif
! 1679: /* Make sure YYID is used. */
! 1680: return YYID (yyresult);
! 1681: }
! 1682:
! 1683:
! 1684: ]b4_epilogue
! 1685: b4_defines_if(
! 1686: [@output(b4_spec_defines_file@)@
! 1687: b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],
! 1688: [1984, 1989-1990, 2000-2006, 2009-2010])
! 1689:
! 1690: b4_percent_code_get([[requires]])[]dnl
! 1691:
! 1692: b4_token_enums_defines(b4_tokens)
! 1693:
! 1694: [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
! 1695: ]m4_ifdef([b4_stype],
! 1696: [[typedef union ]b4_union_name[
! 1697: {
! 1698: ]b4_user_stype[
! 1699: } YYSTYPE;
! 1700: # define YYSTYPE_IS_TRIVIAL 1]],
! 1701: [m4_if(b4_tag_seen_flag, 0,
! 1702: [[typedef int YYSTYPE;
! 1703: # define YYSTYPE_IS_TRIVIAL 1]])])[
! 1704: # define yystype YYSTYPE /* obsolescent; will be withdrawn */
! 1705: # define YYSTYPE_IS_DECLARED 1
! 1706: #endif
! 1707:
! 1708: ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
! 1709:
! 1710: b4_locations_if(
! 1711: [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
! 1712: typedef struct YYLTYPE
! 1713: {
! 1714: int first_line;
! 1715: int first_column;
! 1716: int last_line;
! 1717: int last_column;
! 1718: } YYLTYPE;
! 1719: # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
! 1720: # define YYLTYPE_IS_DECLARED 1
! 1721: # define YYLTYPE_IS_TRIVIAL 1
! 1722: #endif
! 1723:
! 1724: ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
! 1725: )dnl b4_locations_if
! 1726: b4_push_if([[
! 1727: #ifndef YYPUSH_DECLS
! 1728: # define YYPUSH_DECLS
! 1729: struct ]b4_prefix[pstate;
! 1730: typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
! 1731: enum { YYPUSH_MORE = 4 };
! 1732: ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
! 1733: ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
! 1734: [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
! 1735: [[[int yypushed_char]], [[yypushed_char]]],
! 1736: [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
! 1737: [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
! 1738: b4_parse_param]))
! 1739: b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
! 1740: [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
! 1741: b4_parse_param]))])
! 1742: b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
! 1743: [[[void]], []])
! 1744: b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
! 1745: [[b4_prefix[pstate *yyps]], [[yyps]]])[
! 1746: #endif
! 1747: ]])
! 1748: b4_percent_code_get([[provides]])[]dnl
! 1749: ])dnl b4_defines_if
! 1750: m4_divert_pop(0)
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to yacc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / win32 / tools / cygwin / usr / share / bison