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