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 752 #if YYERROR_VERBOSE 753 754 # ifndef yystrlen 755 # if defined __GLIBC__ && defined _STRING_H 756 # define yystrlen strlen 757 # else 758 /* Return the length of YYSTR. */ 759 ]b4_c_function_def([yystrlen], [static YYSIZE_T], 760 [[const char *yystr], [yystr]])[ 761 { 762 YYSIZE_T yylen; 763 for (yylen = 0; yystr[yylen]; yylen++) 764 continue; 765 return yylen; 766 } 767 # endif 768 # endif 769 770 # ifndef yystpcpy 771 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 772 # define yystpcpy stpcpy 773 # else 774 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 775 YYDEST. */ 776 ]b4_c_function_def([yystpcpy], [static char *], 777 [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[ 778 { 779 char *yyd = yydest; 780 const char *yys = yysrc; 781 782 while ((*yyd++ = *yys++) != '\0') 783 continue; 784 785 return yyd - 1; 786 } 787 # endif 788 # endif 789 790 # ifndef yytnamerr 791 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 792 quotes and backslashes, so that it's suitable for yyerror. The 793 heuristic is that double-quoting is unnecessary unless the string 794 contains an apostrophe, a comma, or backslash (other than 795 backslash-backslash). YYSTR is taken from yytname. If YYRES is 796 null, do not copy; instead, return the length of what the result 797 would have been. */ 798 static YYSIZE_T 799 yytnamerr (char *yyres, const char *yystr) 800 { 801 if (*yystr == '"') 802 { 803 YYSIZE_T yyn = 0; 804 char const *yyp = yystr; 805 806 for (;;) 807 switch (*++yyp) 808 { 809 case '\'': 810 case ',': 811 goto do_not_strip_quotes; 812 813 case '\\': 814 if (*++yyp != '\\') 815 goto do_not_strip_quotes; 816 /* Fall through. */ 817 default: 818 if (yyres) 819 yyres[yyn] = *yyp; 820 yyn++; 821 break; 822 823 case '"': 824 if (yyres) 825 yyres[yyn] = '\0'; 826 return yyn; 827 } 828 do_not_strip_quotes: ; 829 } 830 831 if (! yyres) 832 return yystrlen (yystr); 833 834 return yystpcpy (yyres, yystr) - yyres; 835 } 836 # endif 837 838 /* Copy into YYRESULT an error message about the unexpected token 839 YYCHAR while in state YYSTATE. Return the number of bytes copied, 840 including the terminating null byte. If YYRESULT is null, do not 841 copy anything; just return the number of bytes that would be 842 copied. As a special case, return 0 if an ordinary "syntax error" 843 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 844 size calculation. */ 845 static YYSIZE_T 846 yysyntax_error (char *yyresult, int yystate, int yychar) 847 { 848 int yyn = yypact[yystate]; 849 850 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 851 return 0; 852 else 853 { 854 int yytype = YYTRANSLATE (yychar); 855 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 856 YYSIZE_T yysize = yysize0; 857 YYSIZE_T yysize1; 858 int yysize_overflow = 0; 859 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 860 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 861 int yyx; 862 863 # if 0 864 /* This is so xgettext sees the translatable formats that are 865 constructed on the fly. */ 866 YY_("syntax error, unexpected %s"); 867 YY_("syntax error, unexpected %s, expecting %s"); 868 YY_("syntax error, unexpected %s, expecting %s or %s"); 869 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 870 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 871 # endif 872 char *yyfmt; 873 char const *yyf; 874 static char const yyunexpected[] = "syntax error, unexpected %s"; 875 static char const yyexpecting[] = ", expecting %s"; 876 static char const yyor[] = " or %s"; 877 char yyformat[sizeof yyunexpected 878 + sizeof yyexpecting - 1 879 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 880 * (sizeof yyor - 1))]; 881 char const *yyprefix = yyexpecting; 882 883 /* Start YYX at -YYN if negative to avoid negative indexes in 884 YYCHECK. */ 885 int yyxbegin = yyn < 0 ? -yyn : 0; 886 887 /* Stay within bounds of both yycheck and yytname. */ 888 int yychecklim = YYLAST - yyn + 1; 889 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 890 int yycount = 1; 891 892 yyarg[0] = yytname[yytype]; 893 yyfmt = yystpcpy (yyformat, yyunexpected); 894 895 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 896 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 897 { 898 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 899 { 900 yycount = 1; 901 yysize = yysize0; 902 yyformat[sizeof yyunexpected - 1] = '\0'; 903 break; 904 } 905 yyarg[yycount++] = yytname[yyx]; 906 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 907 yysize_overflow |= (yysize1 < yysize); 908 yysize = yysize1; 909 yyfmt = yystpcpy (yyfmt, yyprefix); 910 yyprefix = yyor; 911 } 912 913 yyf = YY_(yyformat); 914 yysize1 = yysize + yystrlen (yyf); 915 yysize_overflow |= (yysize1 < yysize); 916 yysize = yysize1; 917 918 if (yysize_overflow) 919 return YYSIZE_MAXIMUM; 920 921 if (yyresult) 922 { 923 /* Avoid sprintf, as that infringes on the user's name space. 924 Don't have undefined behavior even if the translation 925 produced a string with the wrong number of "%s"s. */ 926 char *yyp = yyresult; 927 int yyi = 0; 928 while ((*yyp = *yyf) != '\0') 929 { 930 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 931 { 932 yyp += yytnamerr (yyp, yyarg[yyi++]); 933 yyf += 2; 934 } 935 else 936 { 937 yyp++; 938 yyf++; 939 } 940 } 941 } 942 return yysize; 943 } 944 } 945 #endif /* YYERROR_VERBOSE */ 946 947 948 ]b4_yydestruct_generate([b4_c_function_def])[ 949 950 951 /* Prevent warnings from -Wmissing-prototypes. */ 952 953 #ifdef YYPARSE_PARAM 954 ]b4_c_function_decl([yyparse], [int], 955 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ 956 #else /* ! YYPARSE_PARAM */ 957 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[ 958 #endif /* ! YYPARSE_PARAM */ 959 960 961 ]m4_divert_push([KILL])# ======================== M4 code. 962 # b4_declare_parser_variables 963 # --------------------------- 964 # Declare the variables that are global, or local to YYPARSE if 965 # pure-parser. 966 m4_define([b4_declare_parser_variables], 967 [/* The look-ahead symbol. */ 968 int yychar; 969 970 /* The semantic value of the look-ahead symbol. */ 971 YYSTYPE yylval; 972 973 /* Number of syntax errors so far. */ 974 int yynerrs;b4_locations_if([ 975 /* Location data for the look-ahead symbol. */ 976 YYLTYPE yylloc;]) 977 ]) 978 m4_divert_pop([KILL])dnl# ====================== End of M4 code. 979 980 b4_pure_if([], 981 [b4_declare_parser_variables]) 982 983 984 /*----------. 985 | yyparse. | 986 `----------*/ 987 988 #ifdef YYPARSE_PARAM 989 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]]) 990 #else /* ! YYPARSE_PARAM */ 991 b4_c_function_def([yyparse], [int], b4_parse_param) 992 #endif 993 {[ 994 ]b4_pure_if([b4_declare_parser_variables])[ 995 int yystate; 996 int yyn; 997 int yyresult; 998 /* Number of tokens to shift before error messages enabled. */ 999 int yyerrstatus; 1000 /* Look-ahead token as an internal (translated) token number. */ 1001 int yytoken = 0; 1002 #if YYERROR_VERBOSE 1003 /* Buffer for error messages, and its allocated size. */ 1004 char yymsgbuf[128]; 1005 char *yymsg = yymsgbuf; 1006 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1007 #endif 1008 1009 /* Three stacks and their tools: 1010 `yyss': related to states, 1011 `yyvs': related to semantic values, 1012 `yyls': related to locations. 1013 1014 Refer to the stacks thru separate pointers, to allow yyoverflow 1015 to reallocate them elsewhere. */ 1016 1017 /* The state stack. */ 1018 yytype_int16 yyssa[YYINITDEPTH]; 1019 yytype_int16 *yyss = yyssa; 1020 yytype_int16 *yyssp; 1021 1022 /* The semantic value stack. */ 1023 YYSTYPE yyvsa[YYINITDEPTH]; 1024 YYSTYPE *yyvs = yyvsa; 1025 YYSTYPE *yyvsp; 1026 1027 ]b4_locations_if( 1028 [[ /* The location stack. */ 1029 YYLTYPE yylsa[YYINITDEPTH]; 1030 YYLTYPE *yyls = yylsa; 1031 YYLTYPE *yylsp; 1032 /* The locations where the error started and ended. */ 1033 YYLTYPE yyerror_range[2];]])[ 1034 1035 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[) 1036 1037 YYSIZE_T yystacksize = YYINITDEPTH; 1038 1039 /* The variables used to return semantic value and location from the 1040 action routines. */ 1041 YYSTYPE yyval; 1042 ]b4_locations_if([ YYLTYPE yyloc;])[ 1043 1044 /* The number of symbols on the RHS of the reduced rule. 1045 Keep to zero when no symbol should be popped. */ 1046 int yylen = 0; 1047 1048 YYDPRINTF ((stderr, "Starting parse\n")); 1049 1050 yystate = 0; 1051 yyerrstatus = 0; 1052 yynerrs = 0; 1053 yychar = YYEMPTY; /* Cause a token to be read. */ 1054 1055 /* Initialize stack pointers. 1056 Waste one element of value and location stack 1057 so that they stay on the same level as the state stack. 1058 The wasted elements are never initialized. */ 1059 1060 yyssp = yyss; 1061 yyvsp = yyvs; 1062 ]b4_locations_if([[ yylsp = yyls; 1063 #if YYLTYPE_IS_TRIVIAL 1064 /* Initialize the default location before parsing starts. */ 1065 yylloc.first_line = yylloc.last_line = 1; 1066 yylloc.first_column = yylloc.last_column = 0; 1067 #endif 1068 ]]) 1069 m4_ifdef([b4_initial_action], [ 1070 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl 1071 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl 1072 /* User initialization code. */ 1073 b4_initial_action 1074 m4_popdef([b4_dollar_dollar])dnl 1075 m4_popdef([b4_at_dollar])dnl 1076 /* Line __line__ of yacc.c. */ 1077 b4_syncline([@oline@], [@ofile@]) 1078 ])dnl 1079 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; 1080 ]])dnl 1081 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; 1082 ]])dnl 1083 [ goto yysetstate; 1084 1085 /*------------------------------------------------------------. 1086 | yynewstate -- Push a new state, which is found in yystate. | 1087 `------------------------------------------------------------*/ 1088 yynewstate: 1089 /* In all cases, when you get here, the value and location stacks 1090 have just been pushed. So pushing a state here evens the stacks. */ 1091 yyssp++; 1092 1093 yysetstate: 1094 *yyssp = yystate; 1095 1096 if (yyss + yystacksize - 1 <= yyssp) 1097 { 1098 /* Get the current used size of the three stacks, in elements. */ 1099 YYSIZE_T yysize = yyssp - yyss + 1; 1100 1101 #ifdef yyoverflow 1102 { 1103 /* Give user a chance to reallocate the stack. Use copies of 1104 these so that the &'s don't force the real ones into 1105 memory. */ 1106 YYSTYPE *yyvs1 = yyvs; 1107 yytype_int16 *yyss1 = yyss; 1108 ]b4_locations_if([ YYLTYPE *yyls1 = yyls;])[ 1109 1110 /* Each stack pointer address is followed by the size of the 1111 data in use in that stack, in bytes. This used to be a 1112 conditional around just the two extra args, but that might 1113 be undefined if yyoverflow is a macro. */ 1114 yyoverflow (YY_("memory exhausted"), 1115 &yyss1, yysize * sizeof (*yyssp), 1116 &yyvs1, yysize * sizeof (*yyvsp), 1117 ]b4_locations_if([ &yyls1, yysize * sizeof (*yylsp),])[ 1118 &yystacksize); 1119 ]b4_locations_if([ yyls = yyls1;])[ 1120 yyss = yyss1; 1121 yyvs = yyvs1; 1122 } 1123 #else /* no yyoverflow */ 1124 # ifndef YYSTACK_RELOCATE 1125 goto yyexhaustedlab; 1126 # else 1127 /* Extend the stack our own way. */ 1128 if (YYMAXDEPTH <= yystacksize) 1129 goto yyexhaustedlab; 1130 yystacksize *= 2; 1131 if (YYMAXDEPTH < yystacksize) 1132 yystacksize = YYMAXDEPTH; 1133 1134 { 1135 yytype_int16 *yyss1 = yyss; 1136 union yyalloc *yyptr = 1137 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1138 if (! yyptr) 1139 goto yyexhaustedlab; 1140 YYSTACK_RELOCATE (yyss); 1141 YYSTACK_RELOCATE (yyvs); 1142 ]b4_locations_if([ YYSTACK_RELOCATE (yyls);])[ 1143 # undef YYSTACK_RELOCATE 1144 if (yyss1 != yyssa) 1145 YYSTACK_FREE (yyss1); 1146 } 1147 # endif 1148 #endif /* no yyoverflow */ 1149 1150 yyssp = yyss + yysize - 1; 1151 yyvsp = yyvs + yysize - 1; 1152 ]b4_locations_if([ yylsp = yyls + yysize - 1;])[ 1153 1154 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1155 (unsigned long int) yystacksize)); 1156 1157 if (yyss + yystacksize - 1 <= yyssp) 1158 YYABORT; 1159 } 1160 1161 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1162 1163 goto yybackup; 1164 1165 /*-----------. 1166 | yybackup. | 1167 `-----------*/ 1168 yybackup: 1169 1170 /* Do appropriate processing given the current state. Read a 1171 look-ahead token if we need one and don't already have one. */ 1172 1173 /* First try to decide what to do without reference to look-ahead token. */ 1174 yyn = yypact[yystate]; 1175 if (yyn == YYPACT_NINF) 1176 goto yydefault; 1177 1178 /* Not known => get a look-ahead token if don't already have one. */ 1179 1180 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 1181 if (yychar == YYEMPTY) 1182 { 1183 YYDPRINTF ((stderr, "Reading a token: ")); 1184 yychar = YYLEX; 1185 } 1186 1187 if (yychar <= YYEOF) 1188 { 1189 yychar = yytoken = YYEOF; 1190 YYDPRINTF ((stderr, "Now at end of input.\n")); 1191 } 1192 else 1193 { 1194 yytoken = YYTRANSLATE (yychar); 1195 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1196 } 1197 1198 /* If the proper action on seeing token YYTOKEN is to reduce or to 1199 detect an error, take that action. */ 1200 yyn += yytoken; 1201 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1202 goto yydefault; 1203 yyn = yytable[yyn]; 1204 if (yyn <= 0) 1205 { 1206 if (yyn == 0 || yyn == YYTABLE_NINF) 1207 goto yyerrlab; 1208 yyn = -yyn; 1209 goto yyreduce; 1210 } 1211 1212 if (yyn == YYFINAL) 1213 YYACCEPT; 1214 1215 /* Count tokens shifted since error; after three, turn off error 1216 status. */ 1217 if (yyerrstatus) 1218 yyerrstatus--; 1219 1220 /* Shift the look-ahead token. */ 1221 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1222 1223 /* Discard the shifted token unless it is eof. */ 1224 if (yychar != YYEOF) 1225 yychar = YYEMPTY; 1226 1227 yystate = yyn; 1228 *++yyvsp = yylval; 1229 ]b4_locations_if([ *++yylsp = yylloc;])[ 1230 goto yynewstate; 1231 1232 1233 /*-----------------------------------------------------------. 1234 | yydefault -- do the default action for the current state. | 1235 `-----------------------------------------------------------*/ 1236 yydefault: 1237 yyn = yydefact[yystate]; 1238 if (yyn == 0) 1239 goto yyerrlab; 1240 goto yyreduce; 1241 1242 1243 /*-----------------------------. 1244 | yyreduce -- Do a reduction. | 1245 `-----------------------------*/ 1246 yyreduce: 1247 /* yyn is the number of a rule to reduce with. */ 1248 yylen = yyr2[yyn]; 1249 1250 /* If YYLEN is nonzero, implement the default value of the action: 1251 `$$ = $1'. 1252 1253 Otherwise, the following line sets YYVAL to garbage. 1254 This behavior is undocumented and Bison 1255 users should not rely upon it. Assigning to YYVAL 1256 unconditionally makes the parser a bit smaller, and it avoids a 1257 GCC warning that YYVAL may be used uninitialized. */ 1258 yyval = yyvsp[1-yylen]; 1259 1260 ]b4_locations_if( 1261 [[ /* Default location. */ 1262 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[ 1263 YY_REDUCE_PRINT (yyn); 1264 switch (yyn) 1265 { 1266 ]b4_actions 1267 /* Line __line__ of yacc.c. */ 1268 b4_syncline([@oline@], [@ofile@])[ 1269 default: break; 1270 } 1271 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1272 1273 YYPOPSTACK (yylen); 1274 yylen = 0; 1275 YY_STACK_PRINT (yyss, yyssp); 1276 1277 *++yyvsp = yyval; 1278 ]b4_locations_if([ *++yylsp = yyloc;])[ 1279 1280 /* Now `shift' the result of the reduction. Determine what state 1281 that goes to, based on the state we popped back to and the rule 1282 number reduced by. */ 1283 1284 yyn = yyr1[yyn]; 1285 1286 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1287 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1288 yystate = yytable[yystate]; 1289 else 1290 yystate = yydefgoto[yyn - YYNTOKENS]; 1291 1292 goto yynewstate; 1293 1294 1295 /*------------------------------------. 1296 | yyerrlab -- here on detecting error | 1297 `------------------------------------*/ 1298 yyerrlab: 1299 /* If not already recovering from an error, report this error. */ 1300 if (!yyerrstatus) 1301 { 1302 ++yynerrs; 1303 #if ! YYERROR_VERBOSE 1304 yyerror (]b4_yyerror_args[YY_("syntax error")); 1305 #else 1306 { 1307 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 1308 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 1309 { 1310 YYSIZE_T yyalloc = 2 * yysize; 1311 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 1312 yyalloc = YYSTACK_ALLOC_MAXIMUM; 1313 if (yymsg != yymsgbuf) 1314 YYSTACK_FREE (yymsg); 1315 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 1316 if (yymsg) 1317 yymsg_alloc = yyalloc; 1318 else 1319 { 1320 yymsg = yymsgbuf; 1321 yymsg_alloc = sizeof yymsgbuf; 1322 } 1323 } 1324 1325 if (0 < yysize && yysize <= yymsg_alloc) 1326 { 1327 (void) yysyntax_error (yymsg, yystate, yychar); 1328 yyerror (]b4_yyerror_args[yymsg); 1329 } 1330 else 1331 { 1332 yyerror (]b4_yyerror_args[YY_("syntax error")); 1333 if (yysize != 0) 1334 goto yyexhaustedlab; 1335 } 1336 } 1337 #endif 1338 } 1339 1340 ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[ 1341 1342 if (yyerrstatus == 3) 1343 { 1344 /* If just tried and failed to reuse look-ahead token after an 1345 error, discard it. */ 1346 1347 if (yychar <= YYEOF) 1348 { 1349 /* Return failure if at end of input. */ 1350 if (yychar == YYEOF) 1351 YYABORT; 1352 } 1353 else 1354 { 1355 yydestruct ("Error: discarding", 1356 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); 1357 yychar = YYEMPTY; 1358 } 1359 } 1360 1361 /* Else will try to reuse look-ahead token after shifting the error 1362 token. */ 1363 goto yyerrlab1; 1364 1365 1366 /*---------------------------------------------------. 1367 | yyerrorlab -- error raised explicitly by YYERROR. | 1368 `---------------------------------------------------*/ 1369 yyerrorlab: 1370 1371 /* Pacify compilers like GCC when the user code never invokes 1372 YYERROR and the label yyerrorlab therefore never appears in user 1373 code. */ 1374 if (/*CONSTCOND*/ 0) 1375 goto yyerrorlab; 1376 1377 ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen]; 1378 ]])[ /* Do not reclaim the symbols of the rule which action triggered 1379 this YYERROR. */ 1380 YYPOPSTACK (yylen); 1381 yylen = 0; 1382 YY_STACK_PRINT (yyss, yyssp); 1383 yystate = *yyssp; 1384 goto yyerrlab1; 1385 1386 1387 /*-------------------------------------------------------------. 1388 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1389 `-------------------------------------------------------------*/ 1390 yyerrlab1: 1391 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1392 1393 for (;;) 1394 { 1395 yyn = yypact[yystate]; 1396 if (yyn != YYPACT_NINF) 1397 { 1398 yyn += YYTERROR; 1399 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 1400 { 1401 yyn = yytable[yyn]; 1402 if (0 < yyn) 1403 break; 1404 } 1405 } 1406 1407 /* Pop the current state because it cannot handle the error token. */ 1408 if (yyssp == yyss) 1409 YYABORT; 1410 1411 ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[ 1412 yydestruct ("Error: popping", 1413 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); 1414 YYPOPSTACK (1); 1415 yystate = *yyssp; 1416 YY_STACK_PRINT (yyss, yyssp); 1417 } 1418 1419 if (yyn == YYFINAL) 1420 YYACCEPT; 1421 1422 *++yyvsp = yylval; 1423 ]b4_locations_if([[ 1424 yyerror_range[1] = yylloc; 1425 /* Using YYLLOC is tempting, but would change the location of 1426 the look-ahead. YYLOC is available though. */ 1427 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); 1428 *++yylsp = yyloc;]])[ 1429 1430 /* Shift the error token. */ 1431 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 1432 1433 yystate = yyn; 1434 goto yynewstate; 1435 1436 1437 /*-------------------------------------. 1438 | yyacceptlab -- YYACCEPT comes here. | 1439 `-------------------------------------*/ 1440 yyacceptlab: 1441 yyresult = 0; 1442 goto yyreturn; 1443 1444 /*-----------------------------------. 1445 | yyabortlab -- YYABORT comes here. | 1446 `-----------------------------------*/ 1447 yyabortlab: 1448 yyresult = 1; 1449 goto yyreturn; 1450 1451 #ifndef yyoverflow 1452 /*-------------------------------------------------. 1453 | yyexhaustedlab -- memory exhaustion comes here. | 1454 `-------------------------------------------------*/ 1455 yyexhaustedlab: 1456 yyerror (]b4_yyerror_args[YY_("memory exhausted")); 1457 yyresult = 2; 1458 /* Fall through. */ 1459 #endif 1460 1461 yyreturn: 1462 if (yychar != YYEOF && yychar != YYEMPTY) 1463 yydestruct ("Cleanup: discarding lookahead", 1464 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); 1465 /* Do not reclaim the symbols of the rule which action triggered 1466 this YYABORT or YYACCEPT. */ 1467 YYPOPSTACK (yylen); 1468 YY_STACK_PRINT (yyss, yyssp); 1469 while (yyssp != yyss) 1470 { 1471 yydestruct ("Cleanup: popping", 1472 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); 1473 YYPOPSTACK (1); 1474 } 1475 #ifndef yyoverflow 1476 if (yyss != yyssa) 1477 YYSTACK_FREE (yyss); 1478 #endif 1479 #if YYERROR_VERBOSE 1480 if (yymsg != yymsgbuf) 1481 YYSTACK_FREE (yymsg); 1482 #endif 1483 /* Make sure YYID is used. */ 1484 return YYID (yyresult); 1485 ]} 1486 1487 1488 b4_epilogue 1489 b4_defines_if( 1490 [@output @output_header_name@ 1491 b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],dnl ' 1492 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006]) 1493 1494 b4_token_enums_defines(b4_tokens) 1495 1496 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 1497 m4_ifdef([b4_stype], 1498 [typedef union[]m4_bregexp(b4_stype, [^{], [ YYSTYPE]) 1499 b4_stype 1500 /* Line __line__ of yacc.c. */ 1501 b4_syncline([@oline@], [@ofile@]) 1502 YYSTYPE;], 1503 [typedef int YYSTYPE;]) 1504 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 1505 # define YYSTYPE_IS_DECLARED 1 1506 # define YYSTYPE_IS_TRIVIAL 1 1507 #endif 1508 1509 b4_pure_if([], 1510 [extern YYSTYPE b4_prefix[]lval;]) 1511 1512 b4_locations_if( 1513 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED 1514 typedef struct YYLTYPE 1515 { 1516 int first_line; 1517 int first_column; 1518 int last_line; 1519 int last_column; 1520 } YYLTYPE; 1521 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ 1522 # define YYLTYPE_IS_DECLARED 1 1523 # define YYLTYPE_IS_TRIVIAL 1 1524 #endif 1525 1526 b4_pure_if([], 1527 [extern YYLTYPE b4_prefix[]lloc;]) 1528 ])dnl b4_locations_if 1529 ])dnl b4_defines_if 1530