Annotation of win32/tools/yacc.c, revision 1.1
1.1 ! paf 1: m4_divert(-1) -*- C -*-
! 2:
! 3: # Yacc compatible skeleton for Bison
! 4: # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003
! 5: # 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 2 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, write to the Free Software
! 19: # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
! 20: # 02111-1307 USA
! 21:
! 22:
! 23:
! 24: ## ---------------- ##
! 25: ## Default values. ##
! 26: ## ---------------- ##
! 27:
! 28: # Stack parameters.
! 29: m4_define_default([b4_stack_depth_max], [10000])
! 30: m4_define_default([b4_stack_depth_init], [200])
! 31:
! 32:
! 33: ## ------------------------ ##
! 34: ## Pure/impure interfaces. ##
! 35: ## ------------------------ ##
! 36:
! 37:
! 38: # b4_pure_if(IF-TRUE, IF-FALSE)
! 39: # -----------------------------
! 40: # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
! 41: m4_define([b4_Pure_if],
! 42: [b4_pure_if([m4_ifset([b4_parse_param],
! 43: [$1], [$2])],
! 44: [$2])])
! 45:
! 46:
! 47: # b4_yyerror_args
! 48: # ---------------
! 49: # Arguments passed to yyerror: user args plus yylloc.
! 50: m4_define([b4_yyerror_args],
! 51: [b4_Pure_if([b4_location_if([&yylloc, ])])dnl
! 52: m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
! 53:
! 54:
! 55: # b4_lex_param
! 56: # ------------
! 57: # Accumulate in b4_lex_param all the yylex arguments.
! 58: # b4_lex_param arrives quoted twice, but we want to keep only one level.
! 59: m4_define([b4_lex_param],
! 60: m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
! 61: b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl
! 62: m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
! 63:
! 64:
! 65:
! 66: ## ------------ ##
! 67: ## Data Types. ##
! 68: ## ------------ ##
! 69:
! 70: # b4_int_type(MIN, MAX)
! 71: # ---------------------
! 72: # Return the smallest int type able to handle numbers ranging from
! 73: # MIN to MAX (included). We overwrite the version from c.m4 which relies
! 74: # on "signed char" which is not portable to old K&R compilers.
! 75: m4_define([b4_int_type],
! 76: [m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char],
! 77: b4_ints_in($@, [-128], [127]), [1], [yysigned_char],
! 78:
! 79: b4_ints_in($@, [0], [65535]), [1], [unsigned short],
! 80: b4_ints_in($@, [-32768], [32767]), [1], [short],
! 81:
! 82: m4_eval([0 <= $1]), [1], [unsigned int],
! 83:
! 84: [int])])
! 85:
! 86:
! 87: ## ----------------- ##
! 88: ## Semantic Values. ##
! 89: ## ----------------- ##
! 90:
! 91:
! 92: # b4_lhs_value([TYPE])
! 93: # --------------------
! 94: # Expansion of $<TYPE>$.
! 95: m4_define([b4_lhs_value],
! 96: [yyval[]m4_ifval([$1], [.$1])])
! 97:
! 98:
! 99: # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
! 100: # --------------------------------------
! 101: # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
! 102: # symbols on RHS.
! 103: m4_define([b4_rhs_value],
! 104: [yyvsp@{m4_eval([$2 - $1])@}m4_ifval([$3], [.$3])])
! 105:
! 106:
! 107:
! 108: ## ----------- ##
! 109: ## Locations. ##
! 110: ## ----------- ##
! 111:
! 112: # b4_lhs_location()
! 113: # -----------------
! 114: # Expansion of @$.
! 115: m4_define([b4_lhs_location],
! 116: [yyloc])
! 117:
! 118:
! 119: # b4_rhs_location(RULE-LENGTH, NUM)
! 120: # ---------------------------------
! 121: # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
! 122: # on RHS.
! 123: m4_define([b4_rhs_location],
! 124: [yylsp@{m4_eval([$2 - $1])@}])
! 125:
! 126:
! 127:
! 128: ## --------------------------------------------------------- ##
! 129: ## Defining symbol actions, e.g., printers and destructors. ##
! 130: ## --------------------------------------------------------- ##
! 131:
! 132: # We do want M4 expansion after # for CPP macros.
! 133: m4_changecom()
! 134: m4_divert(0)dnl
! 135: @output @output_parser_name@
! 136: b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
! 137: [1984, 1989, 1990, 2000, 2001, 2002, 2003])[
! 138:
! 139: /* As a special exception, when this file is copied by Bison into a
! 140: Bison output file, you may use that output file without restriction.
! 141: This special exception was added by the Free Software Foundation
! 142: in version 1.24 of Bison. */
! 143:
! 144: /* Written by Richard Stallman by simplifying the original so called
! 145: ``semantic'' parser. */
! 146:
! 147: /* All symbols defined below should begin with yy or YY, to avoid
! 148: infringing on user name space. This should be done even for local
! 149: variables, as they might otherwise be expanded by user macros.
! 150: There are some unavoidable exceptions within include files to
! 151: define necessary library symbols; they are noted "INFRINGES ON
! 152: USER NAME SPACE" below. */
! 153:
! 154: ]b4_identification
! 155: m4_if(b4_prefix[], [yy], [],
! 156: [/* If NAME_PREFIX is specified substitute the variables and functions
! 157: names. */
! 158: #define yyparse b4_prefix[]parse
! 159: #define yylex b4_prefix[]lex
! 160: #define yyerror b4_prefix[]error
! 161: #define yylval b4_prefix[]lval
! 162: #define yychar b4_prefix[]char
! 163: #define yydebug b4_prefix[]debug
! 164: #define yynerrs b4_prefix[]nerrs
! 165: b4_location_if([#define yylloc b4_prefix[]lloc])])[
! 166:
! 167: ]b4_token_defines(b4_tokens)[
! 168:
! 169: /* Copy the first part of user declarations. */
! 170: ]b4_pre_prologue[
! 171:
! 172: /* Enabling traces. */
! 173: #ifndef YYDEBUG
! 174: # define YYDEBUG ]b4_debug[
! 175: #endif
! 176:
! 177: /* Enabling verbose error messages. */
! 178: #ifdef YYERROR_VERBOSE
! 179: # undef YYERROR_VERBOSE
! 180: # define YYERROR_VERBOSE 1
! 181: #else
! 182: # define YYERROR_VERBOSE ]b4_error_verbose[
! 183: #endif
! 184:
! 185: #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
! 186: ]m4_ifdef([b4_stype],
! 187: [b4_syncline([b4_stype_line], [b4_filename])
! 188: typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
! 189: /* Line __line__ of yacc.c. */
! 190: b4_syncline([@oline@], [@ofile@])],
! 191: [typedef int YYSTYPE;])[
! 192: # define yystype YYSTYPE /* obsolescent; will be withdrawn */
! 193: # define YYSTYPE_IS_DECLARED 1
! 194: # define YYSTYPE_IS_TRIVIAL 1
! 195: #endif
! 196:
! 197: ]b4_location_if([#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
! 198: typedef struct YYLTYPE
! 199: {
! 200: int first_line;
! 201: int first_column;
! 202: int last_line;
! 203: int last_column;
! 204: } YYLTYPE;
! 205: # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
! 206: # define YYLTYPE_IS_DECLARED 1
! 207: # define YYLTYPE_IS_TRIVIAL 1
! 208: #endif
! 209: ])[
! 210:
! 211: /* Copy the second part of user declarations. */
! 212: ]b4_post_prologue
! 213:
! 214: /* Line __line__ of yacc.c. */
! 215: b4_syncline([@oline@], [@ofile@])[
! 216:
! 217: #if ! defined (yyoverflow) || YYERROR_VERBOSE
! 218:
! 219: /* The parser invokes alloca or malloc; define the necessary symbols. */
! 220:
! 221: # if YYSTACK_USE_ALLOCA
! 222: # define YYSTACK_ALLOC alloca
! 223: # else
! 224: # ifndef YYSTACK_USE_ALLOCA
! 225: # if defined (alloca) || defined (_ALLOCA_H)
! 226: # define YYSTACK_ALLOC alloca
! 227: # else
! 228: # ifdef __GNUC__
! 229: # define YYSTACK_ALLOC __builtin_alloca
! 230: # endif
! 231: # endif
! 232: # endif
! 233: # endif
! 234:
! 235: # ifdef YYSTACK_ALLOC
! 236: /* Pacify GCC's `empty if-body' warning. */
! 237: # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
! 238: # else
! 239: # if defined (__STDC__) || defined (__cplusplus)
! 240: # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
! 241: # define YYSIZE_T size_t
! 242: # endif
! 243: # define YYSTACK_ALLOC malloc
! 244: # define YYSTACK_FREE free
! 245: # endif
! 246: #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
! 247:
! 248:
! 249: #if (! defined (yyoverflow) \
! 250: && (! defined (__cplusplus) \
! 251: || (]b4_location_if([YYLTYPE_IS_TRIVIAL && ])[YYSTYPE_IS_TRIVIAL)))
! 252:
! 253: /* A type that is properly aligned for any stack member. */
! 254: union yyalloc
! 255: {
! 256: short yyss;
! 257: YYSTYPE yyvs;
! 258: ]b4_location_if([ YYLTYPE yyls;
! 259: ])dnl
! 260: [};
! 261:
! 262: /* The size of the maximum gap between one aligned stack and the next. */
! 263: # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
! 264:
! 265: /* The size of an array large to enough to hold all stacks, each with
! 266: N elements. */
! 267: ]b4_location_if(
! 268: [# define YYSTACK_BYTES(N) \
! 269: ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
! 270: + 2 * YYSTACK_GAP_MAXIMUM)],
! 271: [# define YYSTACK_BYTES(N) \
! 272: ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
! 273: + YYSTACK_GAP_MAXIMUM)])[
! 274:
! 275: /* Copy COUNT objects from FROM to TO. The source and destination do
! 276: not overlap. */
! 277: # ifndef YYCOPY
! 278: # if 1 < __GNUC__
! 279: # define YYCOPY(To, From, Count) \
! 280: __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
! 281: # else
! 282: # define YYCOPY(To, From, Count) \
! 283: do \
! 284: { \
! 285: register YYSIZE_T yyi; \
! 286: for (yyi = 0; yyi < (Count); yyi++) \
! 287: (To)[yyi] = (From)[yyi]; \
! 288: } \
! 289: while (0)
! 290: # endif
! 291: # endif
! 292:
! 293: /* Relocate STACK from its old location to the new one. The
! 294: local variables YYSIZE and YYSTACKSIZE give the old and new number of
! 295: elements in the stack, and YYPTR gives the new location of the
! 296: stack. Advance YYPTR to a properly aligned location for the next
! 297: stack. */
! 298: # define YYSTACK_RELOCATE(Stack) \
! 299: do \
! 300: { \
! 301: YYSIZE_T yynewbytes; \
! 302: YYCOPY (&yyptr->Stack, Stack, yysize); \
! 303: Stack = &yyptr->Stack; \
! 304: yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
! 305: yyptr += yynewbytes / sizeof (*yyptr); \
! 306: } \
! 307: while (0)
! 308:
! 309: #endif
! 310:
! 311: #if defined (__STDC__) || defined (__cplusplus)
! 312: typedef signed char yysigned_char;
! 313: #else
! 314: typedef short yysigned_char;
! 315: #endif
! 316:
! 317: /* YYFINAL -- State number of the termination state. */
! 318: #define YYFINAL ]b4_final_state_number[
! 319: /* YYLAST -- Last index in YYTABLE. */
! 320: #define YYLAST ]b4_last[
! 321:
! 322: /* YYNTOKENS -- Number of terminals. */
! 323: #define YYNTOKENS ]b4_tokens_number[
! 324: /* YYNNTS -- Number of nonterminals. */
! 325: #define YYNNTS ]b4_nterms_number[
! 326: /* YYNRULES -- Number of rules. */
! 327: #define YYNRULES ]b4_rules_number[
! 328: /* YYNRULES -- Number of states. */
! 329: #define YYNSTATES ]b4_states_number[
! 330:
! 331: /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
! 332: #define YYUNDEFTOK ]b4_undef_token_number[
! 333: #define YYMAXUTOK ]b4_user_token_number_max[
! 334:
! 335: #define YYTRANSLATE(YYX) \
! 336: ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
! 337:
! 338: /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
! 339: static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
! 340: {
! 341: ]b4_translate[
! 342: };
! 343:
! 344: #if YYDEBUG
! 345: /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
! 346: YYRHS. */
! 347: static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
! 348: {
! 349: ]b4_prhs[
! 350: };
! 351:
! 352: /* YYRHS -- A `-1'-separated list of the rules' RHS. */
! 353: static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
! 354: {
! 355: ]b4_rhs[
! 356: };
! 357:
! 358: /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
! 359: static const ]b4_int_type_for([b4_rline])[ yyrline[] =
! 360: {
! 361: ]b4_rline[
! 362: };
! 363: #endif
! 364:
! 365: #if YYDEBUG || YYERROR_VERBOSE
! 366: /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
! 367: First, the terminals, then, starting at YYNTOKENS, nonterminals. */
! 368: static const char *const yytname[] =
! 369: {
! 370: ]b4_tname[
! 371: };
! 372: #endif
! 373:
! 374: # ifdef YYPRINT
! 375: /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
! 376: token YYLEX-NUM. */
! 377: static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
! 378: {
! 379: ]b4_toknum[
! 380: };
! 381: # endif
! 382:
! 383: /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
! 384: static const ]b4_int_type_for([b4_r1])[ yyr1[] =
! 385: {
! 386: ]b4_r1[
! 387: };
! 388:
! 389: /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
! 390: static const ]b4_int_type_for([b4_r2])[ yyr2[] =
! 391: {
! 392: ]b4_r2[
! 393: };
! 394:
! 395: /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
! 396: STATE-NUM when YYTABLE doesn't specify something else to do. Zero
! 397: means the default is an error. */
! 398: static const ]b4_int_type_for([b4_defact])[ yydefact[] =
! 399: {
! 400: ]b4_defact[
! 401: };
! 402:
! 403: /* YYDEFGOTO[NTERM-NUM]. */
! 404: static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
! 405: {
! 406: ]b4_defgoto[
! 407: };
! 408:
! 409: /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
! 410: STATE-NUM. */
! 411: #define YYPACT_NINF ]b4_pact_ninf[
! 412: static const ]b4_int_type_for([b4_pact])[ yypact[] =
! 413: {
! 414: ]b4_pact[
! 415: };
! 416:
! 417: /* YYPGOTO[NTERM-NUM]. */
! 418: static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
! 419: {
! 420: ]b4_pgoto[
! 421: };
! 422:
! 423: /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
! 424: positive, shift that token. If negative, reduce the rule which
! 425: number is the opposite. If zero, do what YYDEFACT says.
! 426: If YYTABLE_NINF, syntax error. */
! 427: #define YYTABLE_NINF ]b4_table_ninf[
! 428: static const ]b4_int_type_for([b4_table])[ yytable[] =
! 429: {
! 430: ]b4_table[
! 431: };
! 432:
! 433: static const ]b4_int_type_for([b4_check])[ yycheck[] =
! 434: {
! 435: ]b4_check[
! 436: };
! 437:
! 438: /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
! 439: symbol of state STATE-NUM. */
! 440: static const ]b4_int_type_for([b4_stos])[ yystos[] =
! 441: {
! 442: ]b4_stos[
! 443: };
! 444:
! 445: #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
! 446: # define YYSIZE_T __SIZE_TYPE__
! 447: #endif
! 448: #if ! defined (YYSIZE_T) && defined (size_t)
! 449: # define YYSIZE_T size_t
! 450: #endif
! 451: #if ! defined (YYSIZE_T)
! 452: # if defined (__STDC__) || defined (__cplusplus)
! 453: # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
! 454: # define YYSIZE_T size_t
! 455: # endif
! 456: #endif
! 457: #if ! defined (YYSIZE_T)
! 458: # define YYSIZE_T unsigned int
! 459: #endif
! 460:
! 461: #define yyerrok (yyerrstatus = 0)
! 462: #define yyclearin (yychar = YYEMPTY)
! 463: #define YYEMPTY (-2)
! 464: #define YYEOF 0
! 465:
! 466: #define YYACCEPT goto yyacceptlab
! 467: #define YYABORT goto yyabortlab
! 468: #define YYERROR ]b4_location_if([do \
! 469: { \
! 470: yylerrsp = yylsp; \
! 471: *++yylerrsp = yyloc; \
! 472: goto yyerrlab1; \
! 473: } \
! 474: while (0)],
! 475: [goto yyerrlab1])[
! 476:
! 477:
! 478: /* Like YYERROR except do call yyerror. This remains here temporarily
! 479: to ease the transition to the new meaning of YYERROR, for GCC.
! 480: Once GCC version 2 has supplanted version 1, this can go. */
! 481:
! 482: #define YYFAIL goto yyerrlab
! 483:
! 484: #define YYRECOVERING() (!!yyerrstatus)
! 485:
! 486: #define YYBACKUP(Token, Value) \
! 487: do \
! 488: if (yychar == YYEMPTY && yylen == 1) \
! 489: { \
! 490: yychar = (Token); \
! 491: yylval = (Value); \
! 492: yytoken = YYTRANSLATE (yychar); \
! 493: YYPOPSTACK; \
! 494: goto yybackup; \
! 495: } \
! 496: else \
! 497: { \
! 498: yyerror (]b4_yyerror_args["syntax error: cannot back up");\
! 499: YYERROR; \
! 500: } \
! 501: while (0)
! 502:
! 503: #define YYTERROR 1
! 504: #define YYERRCODE 256
! 505:
! 506: /* YYLLOC_DEFAULT -- Compute the default location (before the actions
! 507: are run). */
! 508:
! 509: #ifndef YYLLOC_DEFAULT
! 510: # define YYLLOC_DEFAULT(Current, Rhs, N) \
! 511: Current.first_line = Rhs[1].first_line; \
! 512: Current.first_column = Rhs[1].first_column; \
! 513: Current.last_line = Rhs[N].last_line; \
! 514: Current.last_column = Rhs[N].last_column;
! 515: #endif
! 516:
! 517: /* YYLEX -- calling `yylex' with the right arguments. */
! 518:
! 519: #ifdef YYLEX_PARAM
! 520: # define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM)
! 521: #else
! 522: # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
! 523: #endif
! 524:
! 525: /* Enable debugging if requested. */
! 526: #if YYDEBUG
! 527:
! 528: # ifndef YYFPRINTF
! 529: # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
! 530: # define YYFPRINTF fprintf
! 531: # endif
! 532:
! 533: # define YYDPRINTF(Args) \
! 534: do { \
! 535: if (yydebug) \
! 536: YYFPRINTF Args; \
! 537: } while (0)
! 538:
! 539: # define YYDSYMPRINT(Args) \
! 540: do { \
! 541: if (yydebug) \
! 542: yysymprint Args; \
! 543: } while (0)
! 544:
! 545: # define YYDSYMPRINTF(Title, Token, Value, Location) \
! 546: do { \
! 547: if (yydebug) \
! 548: { \
! 549: YYFPRINTF (stderr, "%s ", Title); \
! 550: yysymprint (stderr, \
! 551: Token, Value]b4_location_if([, Location])[); \
! 552: YYFPRINTF (stderr, "\n"); \
! 553: } \
! 554: } while (0)
! 555:
! 556: /*------------------------------------------------------------------.
! 557: | yy_stack_print -- Print the state stack from its BOTTOM up to its |
! 558: | TOP (cinluded). |
! 559: `------------------------------------------------------------------*/
! 560:
! 561: ]b4_c_function_def([yy_stack_print], [static void],
! 562: [[short *bottom], [bottom]],
! 563: [[short *top], [top]])[
! 564: {
! 565: YYFPRINTF (stderr, "Stack now");
! 566: for (/* Nothing. */; bottom <= top; ++bottom)
! 567: YYFPRINTF (stderr, " %d", *bottom);
! 568: YYFPRINTF (stderr, "\n");
! 569: }
! 570:
! 571: # define YY_STACK_PRINT(Bottom, Top) \
! 572: do { \
! 573: if (yydebug) \
! 574: yy_stack_print ((Bottom), (Top)); \
! 575: } while (0)
! 576:
! 577:
! 578: /*------------------------------------------------.
! 579: | Report that the YYRULE is going to be reduced. |
! 580: `------------------------------------------------*/
! 581:
! 582: ]b4_c_function_def([yy_reduce_print], [static void],
! 583: [[int yyrule], [yyrule]])[
! 584: {
! 585: int yyi;
! 586: unsigned int yylno = yyrline[yyrule];
! 587: YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
! 588: yyrule - 1, yylno);
! 589: /* Print the symbols being reduced, and their result. */
! 590: for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
! 591: YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
! 592: YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
! 593: }
! 594:
! 595: # define YY_REDUCE_PRINT(Rule) \
! 596: do { \
! 597: if (yydebug) \
! 598: yy_reduce_print (Rule); \
! 599: } while (0)
! 600:
! 601: /* Nonzero means print parse trace. It is left uninitialized so that
! 602: multiple parsers can coexist. */
! 603: int yydebug;
! 604: #else /* !YYDEBUG */
! 605: # define YYDPRINTF(Args)
! 606: # define YYDSYMPRINT(Args)
! 607: # define YYDSYMPRINTF(Title, Token, Value, Location)
! 608: # define YY_STACK_PRINT(Bottom, Top)
! 609: # define YY_REDUCE_PRINT(Rule)
! 610: #endif /* !YYDEBUG */
! 611:
! 612:
! 613: /* YYINITDEPTH -- initial size of the parser's stacks. */
! 614: #ifndef YYINITDEPTH
! 615: # define YYINITDEPTH ]b4_stack_depth_init[
! 616: #endif
! 617:
! 618: /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
! 619: if the built-in stack extension method is used).
! 620:
! 621: Do not make this value too large; the results are undefined if
! 622: SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
! 623: evaluated with infinite-precision integer arithmetic. */
! 624:
! 625: #if YYMAXDEPTH == 0
! 626: # undef YYMAXDEPTH
! 627: #endif
! 628:
! 629: #ifndef YYMAXDEPTH
! 630: # define YYMAXDEPTH ]b4_stack_depth_max[
! 631: #endif
! 632:
! 633:
! 634:
! 635: #if YYERROR_VERBOSE
! 636:
! 637: # ifndef yystrlen
! 638: # if defined (__GLIBC__) && defined (_STRING_H)
! 639: # define yystrlen strlen
! 640: # else
! 641: /* Return the length of YYSTR. */
! 642: static YYSIZE_T
! 643: # if defined (__STDC__) || defined (__cplusplus)
! 644: yystrlen (const char *yystr)
! 645: # else
! 646: yystrlen (yystr)
! 647: const char *yystr;
! 648: # endif
! 649: {
! 650: register const char *yys = yystr;
! 651:
! 652: while (*yys++ != '\0')
! 653: continue;
! 654:
! 655: return yys - yystr - 1;
! 656: }
! 657: # endif
! 658: # endif
! 659:
! 660: # ifndef yystpcpy
! 661: # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
! 662: # define yystpcpy stpcpy
! 663: # else
! 664: /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
! 665: YYDEST. */
! 666: static char *
! 667: # if defined (__STDC__) || defined (__cplusplus)
! 668: yystpcpy (char *yydest, const char *yysrc)
! 669: # else
! 670: yystpcpy (yydest, yysrc)
! 671: char *yydest;
! 672: const char *yysrc;
! 673: # endif
! 674: {
! 675: register char *yyd = yydest;
! 676: register const char *yys = yysrc;
! 677:
! 678: while ((*yyd++ = *yys++) != '\0')
! 679: continue;
! 680:
! 681: return yyd - 1;
! 682: }
! 683: # endif
! 684: # endif
! 685:
! 686: #endif /* !YYERROR_VERBOSE */
! 687:
! 688:
! 689:
! 690: #if YYDEBUG
! 691: ]b4_yysymprint_generate([b4_c_function_def])[
! 692: #endif /* ! YYDEBUG */
! 693: ]b4_yydestruct_generate([b4_c_function_def])
! 694:
! 695:
! 696: /* Prevent warnings from -Wmissing-prototypes. */
! 697:
! 698: #ifdef YYPARSE_PARAM
! 699: # if defined (__STDC__) || defined (__cplusplus)
! 700: int yyparse (void *YYPARSE_PARAM);
! 701: # else
! 702: int yyparse ();
! 703: # endif
! 704: #else /* ! YYPARSE_PARAM */
! 705: b4_c_function_decl([yyparse], [int], b4_parse_param)
! 706: #endif /* ! YYPARSE_PARAM */
! 707:
! 708:
! 709: m4_divert_push([KILL])# ======================== M4 code.
! 710: # b4_declare_parser_variables
! 711: # ---------------------------
! 712: # Declare the variables that are global, or local to YYPARSE if
! 713: # pure-parser.
! 714: m4_define([b4_declare_parser_variables],
! 715: [/* The lookahead symbol. */
! 716: int yychar;
! 717:
! 718: /* The semantic value of the lookahead symbol. */
! 719: YYSTYPE yylval;
! 720:
! 721: /* Number of syntax errors so far. */
! 722: int yynerrs;b4_location_if([
! 723: /* Location data for the lookahead symbol. */
! 724: YYLTYPE yylloc;])
! 725: ])
! 726: m4_divert_pop([KILL])dnl# ====================== End of M4 code.
! 727:
! 728: b4_pure_if([],
! 729: [b4_declare_parser_variables])
! 730:
! 731:
! 732: /*----------.
! 733: | yyparse. |
! 734: `----------*/
! 735:
! 736: #ifdef YYPARSE_PARAM
! 737: # if defined (__STDC__) || defined (__cplusplus)
! 738: int yyparse (void *YYPARSE_PARAM)
! 739: # else
! 740: int yyparse (YYPARSE_PARAM)
! 741: void *YYPARSE_PARAM;
! 742: # endif
! 743: #else /* ! YYPARSE_PARAM */
! 744: b4_c_function_def([yyparse], [int], b4_parse_param)
! 745: #endif
! 746: {[
! 747: ]b4_pure_if([b4_declare_parser_variables])[
! 748: register int yystate;
! 749: register int yyn;
! 750: int yyresult;
! 751: /* Number of tokens to shift before error messages enabled. */
! 752: int yyerrstatus;
! 753: /* Lookahead token as an internal (translated) token number. */
! 754: int yytoken = 0;
! 755:
! 756: /* Three stacks and their tools:
! 757: `yyss': related to states,
! 758: `yyvs': related to semantic values,
! 759: `yyls': related to locations.
! 760:
! 761: Refer to the stacks thru separate pointers, to allow yyoverflow
! 762: to reallocate them elsewhere. */
! 763:
! 764: /* The state stack. */
! 765: short yyssa[YYINITDEPTH];
! 766: short *yyss = yyssa;
! 767: register short *yyssp;
! 768:
! 769: /* The semantic value stack. */
! 770: YYSTYPE yyvsa[YYINITDEPTH];
! 771: YYSTYPE *yyvs = yyvsa;
! 772: register YYSTYPE *yyvsp;
! 773:
! 774: ]b4_location_if(
! 775: [[ /* The location stack. */
! 776: YYLTYPE yylsa[YYINITDEPTH];
! 777: YYLTYPE *yyls = yylsa;
! 778: YYLTYPE *yylsp;
! 779: YYLTYPE *yylerrsp;]])[
! 780:
! 781: #define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
! 782:
! 783: YYSIZE_T yystacksize = YYINITDEPTH;
! 784:
! 785: /* The variables used to return semantic value and location from the
! 786: action routines. */
! 787: YYSTYPE yyval;
! 788: ]b4_location_if([ YYLTYPE yyloc;])[
! 789:
! 790: /* When reducing, the number of symbols on the RHS of the reduced
! 791: rule. */
! 792: int yylen;
! 793:
! 794: YYDPRINTF ((stderr, "Starting parse\n"));
! 795:
! 796: yystate = 0;
! 797: yyerrstatus = 0;
! 798: yynerrs = 0;
! 799: yychar = YYEMPTY; /* Cause a token to be read. */
! 800:
! 801: /* Initialize stack pointers.
! 802: Waste one element of value and location stack
! 803: so that they stay on the same level as the state stack.
! 804: The wasted elements are never initialized. */
! 805:
! 806: yyssp = yyss;
! 807: yyvsp = yyvs;
! 808: ]b4_location_if([ yylsp = yyls;])[
! 809: goto yysetstate;
! 810:
! 811: /*------------------------------------------------------------.
! 812: | yynewstate -- Push a new state, which is found in yystate. |
! 813: `------------------------------------------------------------*/
! 814: yynewstate:
! 815: /* In all cases, when you get here, the value and location stacks
! 816: have just been pushed. so pushing a state here evens the stacks.
! 817: */
! 818: yyssp++;
! 819:
! 820: yysetstate:
! 821: *yyssp = yystate;
! 822:
! 823: if (yyss + yystacksize - 1 <= yyssp)
! 824: {
! 825: /* Get the current used size of the three stacks, in elements. */
! 826: YYSIZE_T yysize = yyssp - yyss + 1;
! 827:
! 828: #ifdef yyoverflow
! 829: {
! 830: /* Give user a chance to reallocate the stack. Use copies of
! 831: these so that the &'s don't force the real ones into
! 832: memory. */
! 833: YYSTYPE *yyvs1 = yyvs;
! 834: short *yyss1 = yyss;
! 835: ]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
! 836:
! 837: /* Each stack pointer address is followed by the size of the
! 838: data in use in that stack, in bytes. This used to be a
! 839: conditional around just the two extra args, but that might
! 840: be undefined if yyoverflow is a macro. */
! 841: yyoverflow ("parser stack overflow",
! 842: &yyss1, yysize * sizeof (*yyssp),
! 843: &yyvs1, yysize * sizeof (*yyvsp),
! 844: ]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
! 845: &yystacksize);
! 846: ]b4_location_if([ yyls = yyls1;])[
! 847: yyss = yyss1;
! 848: yyvs = yyvs1;
! 849: }
! 850: #else /* no yyoverflow */
! 851: # ifndef YYSTACK_RELOCATE
! 852: goto yyoverflowlab;
! 853: # else
! 854: /* Extend the stack our own way. */
! 855: if (YYMAXDEPTH <= yystacksize)
! 856: goto yyoverflowlab;
! 857: yystacksize *= 2;
! 858: if (YYMAXDEPTH < yystacksize)
! 859: yystacksize = YYMAXDEPTH;
! 860:
! 861: {
! 862: short *yyss1 = yyss;
! 863: union yyalloc *yyptr =
! 864: (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
! 865: if (! yyptr)
! 866: goto yyoverflowlab;
! 867: YYSTACK_RELOCATE (yyss);
! 868: YYSTACK_RELOCATE (yyvs);
! 869: ]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
! 870: # undef YYSTACK_RELOCATE
! 871: if (yyss1 != yyssa)
! 872: YYSTACK_FREE (yyss1);
! 873: }
! 874: # endif
! 875: #endif /* no yyoverflow */
! 876:
! 877: yyssp = yyss + yysize - 1;
! 878: yyvsp = yyvs + yysize - 1;
! 879: ]b4_location_if([ yylsp = yyls + yysize - 1;])[
! 880:
! 881: YYDPRINTF ((stderr, "Stack size increased to %lu\n",
! 882: (unsigned long int) yystacksize));
! 883:
! 884: if (yyss + yystacksize - 1 <= yyssp)
! 885: YYABORT;
! 886: }
! 887:
! 888: YYDPRINTF ((stderr, "Entering state %d\n", yystate));
! 889:
! 890: goto yybackup;
! 891:
! 892: /*-----------.
! 893: | yybackup. |
! 894: `-----------*/
! 895: yybackup:
! 896:
! 897: /* Do appropriate processing given the current state. */
! 898: /* Read a lookahead token if we need one and don't already have one. */
! 899: /* yyresume: */
! 900:
! 901: /* First try to decide what to do without reference to lookahead token. */
! 902:
! 903: yyn = yypact[yystate];
! 904: if (yyn == YYPACT_NINF)
! 905: goto yydefault;
! 906:
! 907: /* Not known => get a lookahead token if don't already have one. */
! 908:
! 909: /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
! 910: if (yychar == YYEMPTY)
! 911: {
! 912: YYDPRINTF ((stderr, "Reading a token: "));
! 913: yychar = YYLEX;
! 914: }
! 915:
! 916: if (yychar <= YYEOF)
! 917: {
! 918: yychar = yytoken = YYEOF;
! 919: YYDPRINTF ((stderr, "Now at end of input.\n"));
! 920: }
! 921: else
! 922: {
! 923: yytoken = YYTRANSLATE (yychar);
! 924: YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
! 925: }
! 926:
! 927: /* If the proper action on seeing token YYTOKEN is to reduce or to
! 928: detect an error, take that action. */
! 929: yyn += yytoken;
! 930: if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
! 931: goto yydefault;
! 932: yyn = yytable[yyn];
! 933: if (yyn <= 0)
! 934: {
! 935: if (yyn == 0 || yyn == YYTABLE_NINF)
! 936: goto yyerrlab;
! 937: yyn = -yyn;
! 938: goto yyreduce;
! 939: }
! 940:
! 941: if (yyn == YYFINAL)
! 942: YYACCEPT;
! 943:
! 944: /* Shift the lookahead token. */
! 945: YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
! 946:
! 947: /* Discard the token being shifted unless it is eof. */
! 948: if (yychar != YYEOF)
! 949: yychar = YYEMPTY;
! 950:
! 951: *++yyvsp = yylval;
! 952: ]b4_location_if([ *++yylsp = yylloc;])[
! 953:
! 954: /* Count tokens shifted since error; after three, turn off error
! 955: status. */
! 956: if (yyerrstatus)
! 957: yyerrstatus--;
! 958:
! 959: yystate = yyn;
! 960: goto yynewstate;
! 961:
! 962:
! 963: /*-----------------------------------------------------------.
! 964: | yydefault -- do the default action for the current state. |
! 965: `-----------------------------------------------------------*/
! 966: yydefault:
! 967: yyn = yydefact[yystate];
! 968: if (yyn == 0)
! 969: goto yyerrlab;
! 970: goto yyreduce;
! 971:
! 972:
! 973: /*-----------------------------.
! 974: | yyreduce -- Do a reduction. |
! 975: `-----------------------------*/
! 976: yyreduce:
! 977: /* yyn is the number of a rule to reduce with. */
! 978: yylen = yyr2[yyn];
! 979:
! 980: /* If YYLEN is nonzero, implement the default value of the action:
! 981: `$$ = $1'.
! 982:
! 983: Otherwise, the following line sets YYVAL to garbage.
! 984: This behavior is undocumented and Bison
! 985: users should not rely upon it. Assigning to YYVAL
! 986: unconditionally makes the parser a bit smaller, and it avoids a
! 987: GCC warning that YYVAL may be used uninitialized. */
! 988: yyval = yyvsp[1-yylen];
! 989:
! 990: ]b4_location_if(
! 991: [ /* Default location. */
! 992: YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
! 993: YY_REDUCE_PRINT (yyn);
! 994: switch (yyn)
! 995: ]{
! 996: b4_actions
! 997: }
! 998:
! 999: /* Line __line__ of yacc.c. */
! 1000: b4_syncline([@oline@], [@ofile@])
! 1001:
! 1002: [ yyvsp -= yylen;
! 1003: yyssp -= yylen;
! 1004: ]b4_location_if([ yylsp -= yylen;])[
! 1005:
! 1006: YY_STACK_PRINT (yyss, yyssp);
! 1007:
! 1008: *++yyvsp = yyval;
! 1009: ]b4_location_if([ *++yylsp = yyloc;])[
! 1010:
! 1011: /* Now `shift' the result of the reduction. Determine what state
! 1012: that goes to, based on the state we popped back to and the rule
! 1013: number reduced by. */
! 1014:
! 1015: yyn = yyr1[yyn];
! 1016:
! 1017: yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
! 1018: if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
! 1019: yystate = yytable[yystate];
! 1020: else
! 1021: yystate = yydefgoto[yyn - YYNTOKENS];
! 1022:
! 1023: goto yynewstate;
! 1024:
! 1025:
! 1026: /*------------------------------------.
! 1027: | yyerrlab -- here on detecting error |
! 1028: `------------------------------------*/
! 1029: yyerrlab:
! 1030: /* If not already recovering from an error, report this error. */
! 1031: if (!yyerrstatus)
! 1032: {
! 1033: ++yynerrs;
! 1034: #if YYERROR_VERBOSE
! 1035: yyn = yypact[yystate];
! 1036:
! 1037: if (YYPACT_NINF < yyn && yyn < YYLAST)
! 1038: {
! 1039: YYSIZE_T yysize = 0;
! 1040: int yytype = YYTRANSLATE (yychar);
! 1041: const char* yyprefix;
! 1042: char *yymsg;
! 1043: int yyx;
! 1044:
! 1045: /* Start YYX at -YYN if negative to avoid negative indexes in
! 1046: YYCHECK. */
! 1047: int yyxbegin = yyn < 0 ? -yyn : 0;
! 1048:
! 1049: /* Stay within bounds of both yycheck and yytname. */
! 1050: int yychecklim = YYLAST - yyn;
! 1051: int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
! 1052: int yycount = 0;
! 1053:
! 1054: yyprefix = ", expecting ";
! 1055: for (yyx = yyxbegin; yyx < yyxend; ++yyx)
! 1056: if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
! 1057: {
! 1058: yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
! 1059: yycount += 1;
! 1060: if (yycount == 5)
! 1061: {
! 1062: yysize = 0;
! 1063: break;
! 1064: }
! 1065: }
! 1066: yysize += (sizeof ("syntax error, unexpected ")
! 1067: + yystrlen (yytname[yytype]));
! 1068: yymsg = (char *) YYSTACK_ALLOC (yysize);
! 1069: if (yymsg != 0)
! 1070: {
! 1071: char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
! 1072: yyp = yystpcpy (yyp, yytname[yytype]);
! 1073:
! 1074: if (yycount < 5)
! 1075: {
! 1076: yyprefix = ", expecting ";
! 1077: for (yyx = yyxbegin; yyx < yyxend; ++yyx)
! 1078: if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
! 1079: {
! 1080: yyp = yystpcpy (yyp, yyprefix);
! 1081: yyp = yystpcpy (yyp, yytname[yyx]);
! 1082: yyprefix = " or ";
! 1083: }
! 1084: }
! 1085: yyerror (]b4_yyerror_args[yymsg);
! 1086: YYSTACK_FREE (yymsg);
! 1087: }
! 1088: else
! 1089: yyerror (]b4_yyerror_args["syntax error; also virtual memory exhausted");
! 1090: }
! 1091: else
! 1092: #endif /* YYERROR_VERBOSE */
! 1093: yyerror (]b4_yyerror_args["syntax error");
! 1094: }
! 1095:
! 1096: ]b4_location_if([ yylerrsp = yylsp;])[
! 1097:
! 1098: if (yyerrstatus == 3)
! 1099: {
! 1100: /* If just tried and failed to reuse lookahead token after an
! 1101: error, discard it. */
! 1102:
! 1103: /* Return failure if at end of input. */
! 1104: if (yychar == YYEOF)
! 1105: {
! 1106: /* Pop the error token. */
! 1107: YYPOPSTACK;
! 1108: /* Pop the rest of the stack. */
! 1109: while (yyss < yyssp)
! 1110: {
! 1111: YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
! 1112: yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
! 1113: YYPOPSTACK;
! 1114: }
! 1115: YYABORT;
! 1116: }
! 1117:
! 1118: YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
! 1119: yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[);
! 1120: yychar = YYEMPTY;
! 1121: ]b4_location_if([ *++yylerrsp = yylloc;])[
! 1122: }
! 1123:
! 1124: /* Else will try to reuse lookahead token after shifting the error
! 1125: token. */
! 1126: goto yyerrlab1;
! 1127:
! 1128:
! 1129: /*----------------------------------------------------.
! 1130: | yyerrlab1 -- error raised explicitly by an action. |
! 1131: `----------------------------------------------------*/
! 1132: yyerrlab1:
! 1133: yyerrstatus = 3; /* Each real token shifted decrements this. */
! 1134:
! 1135: for (;;)
! 1136: {
! 1137: yyn = yypact[yystate];
! 1138: if (yyn != YYPACT_NINF)
! 1139: {
! 1140: yyn += YYTERROR;
! 1141: if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
! 1142: {
! 1143: yyn = yytable[yyn];
! 1144: if (0 < yyn)
! 1145: break;
! 1146: }
! 1147: }
! 1148:
! 1149: /* Pop the current state because it cannot handle the error token. */
! 1150: if (yyssp == yyss)
! 1151: YYABORT;
! 1152:
! 1153: YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
! 1154: yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
! 1155: yyvsp--;
! 1156: yystate = *--yyssp;
! 1157: ]b4_location_if([ yylsp--;])[
! 1158: YY_STACK_PRINT (yyss, yyssp);
! 1159: }
! 1160:
! 1161: if (yyn == YYFINAL)
! 1162: YYACCEPT;
! 1163:
! 1164: YYDPRINTF ((stderr, "Shifting error token, "));
! 1165:
! 1166: *++yyvsp = yylval;
! 1167: ]b4_location_if([ YYLLOC_DEFAULT (yyloc, yylsp, (yylerrsp - yylsp));
! 1168: *++yylsp = yyloc;])[
! 1169:
! 1170: yystate = yyn;
! 1171: goto yynewstate;
! 1172:
! 1173:
! 1174: /*-------------------------------------.
! 1175: | yyacceptlab -- YYACCEPT comes here. |
! 1176: `-------------------------------------*/
! 1177: yyacceptlab:
! 1178: yyresult = 0;
! 1179: goto yyreturn;
! 1180:
! 1181: /*-----------------------------------.
! 1182: | yyabortlab -- YYABORT comes here. |
! 1183: `-----------------------------------*/
! 1184: yyabortlab:
! 1185: yyresult = 1;
! 1186: goto yyreturn;
! 1187:
! 1188: #ifndef yyoverflow
! 1189: /*----------------------------------------------.
! 1190: | yyoverflowlab -- parser overflow comes here. |
! 1191: `----------------------------------------------*/
! 1192: yyoverflowlab:
! 1193: yyerror (]b4_yyerror_args["parser stack overflow");
! 1194: yyresult = 2;
! 1195: /* Fall through. */
! 1196: #endif
! 1197:
! 1198: yyreturn:
! 1199: #ifndef yyoverflow
! 1200: if (yyss != yyssa)
! 1201: YYSTACK_FREE (yyss);
! 1202: #endif
! 1203: return yyresult;
! 1204: ]}
! 1205:
! 1206:
! 1207: b4_epilogue
! 1208: m4_if(b4_defines_flag, 0, [],
! 1209: [@output @output_header_name@
! 1210: b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
! 1211: [1984, 1989, 1990, 2000, 2001, 2002, 2003])
! 1212:
! 1213: /* As a special exception, when this file is copied by Bison into a
! 1214: Bison output file, you may use that output file without restriction.
! 1215: This special exception was added by the Free Software Foundation
! 1216: in version 1.24 of Bison. */
! 1217:
! 1218: b4_token_defines(b4_tokens)
! 1219:
! 1220: #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
! 1221: m4_ifdef([b4_stype],
! 1222: [b4_syncline([b4_stype_line], [b4_filename])
! 1223: typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
! 1224: /* Line __line__ of yacc.c. */
! 1225: b4_syncline([@oline@], [@ofile@])],
! 1226: [typedef int YYSTYPE;])
! 1227: # define yystype YYSTYPE /* obsolescent; will be withdrawn */
! 1228: # define YYSTYPE_IS_DECLARED 1
! 1229: # define YYSTYPE_IS_TRIVIAL 1
! 1230: #endif
! 1231:
! 1232: b4_pure_if([],
! 1233: [extern YYSTYPE b4_prefix[]lval;])
! 1234:
! 1235: b4_location_if(
! 1236: [#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
! 1237: typedef struct YYLTYPE
! 1238: {
! 1239: int first_line;
! 1240: int first_column;
! 1241: int last_line;
! 1242: int last_column;
! 1243: } YYLTYPE;
! 1244: # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
! 1245: # define YYLTYPE_IS_DECLARED 1
! 1246: # define YYLTYPE_IS_TRIVIAL 1
! 1247: #endif
! 1248:
! 1249: m4_if(b4_pure, [0],
! 1250: [extern YYLTYPE b4_prefix[]lloc;])
! 1251: ])
! 1252: ])
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