1 m4_divert(-1) -*- C -*- 2 3 # GLR skeleton for Bison 4 # Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 5 6 # This program is free software; you can redistribute it and/or modify 7 # it under the terms of the GNU General Public License as published by 8 # the Free Software Foundation; either version 2 of the License, or 9 # (at your option) any later version. 10 11 # This program is distributed in the hope that it will be useful, 12 # but WITHOUT ANY WARRANTY; without even the implied warranty of 13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 # GNU General Public License for more details. 15 16 # You should have received a copy of the GNU General Public License 17 # along with this program; if not, write to the Free Software 18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19 # 02110-1301 USA 20 21 22 m4_include(b4_pkgdatadir/[c.m4]) 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 ## ------------------------ ## 35 ## Pure/impure interfaces. ## 36 ## ------------------------ ## 37 38 39 # b4_user_formals 40 # --------------- 41 # The possible parse-params formal arguments preceded by a comma. 42 # 43 # This is not shared with yacc.c in c.m4 because GLR relies on ISO C 44 # formal argument declarations. 45 m4_define([b4_user_formals], 46 [m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])]) 47 48 49 # b4_lex_param 50 # ------------ 51 # Accumule in b4_lex_param all the yylex arguments. 52 # Yes, this is quite ugly... 53 m4_define([b4_lex_param], 54 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl 55 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl 56 m4_ifdef([b4_lex_param], [, ]b4_lex_param))) 57 58 59 # b4_yyerror_args 60 # --------------- 61 # Optional effective arguments passed to yyerror: user args plus yylloc, and 62 # a trailing comma. 63 m4_define([b4_yyerror_args], 64 [b4_pure_if([b4_locations_if([yylocp, ])])dnl 65 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) 66 67 68 # b4_lyyerror_args 69 # ---------------- 70 # Same as above, but on the look-ahead, hence &yylloc instead of yylocp. 71 m4_define([b4_lyyerror_args], 72 [b4_pure_if([b4_locations_if([&yylloc, ])])dnl 73 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) 74 75 76 # b4_pure_args 77 # ------------ 78 # Same as b4_yyerror_args, but with a leading comma. 79 m4_define([b4_pure_args], 80 [b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args]) 81 82 83 # b4_lpure_args 84 # ------------- 85 # Same as above, but on the look-ahead, hence &yylloc instead of yylocp. 86 m4_define([b4_lpure_args], 87 [b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args]) 88 89 90 # b4_pure_formals 91 # --------------- 92 # Arguments passed to yyerror: user formals plus yylocp. 93 m4_define([b4_pure_formals], 94 [b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals]) 95 96 97 ## ----------------- ## 98 ## Semantic Values. ## 99 ## ----------------- ## 100 101 102 # b4_lhs_value([TYPE]) 103 # -------------------- 104 # Expansion of $<TYPE>$. 105 m4_define([b4_lhs_value], 106 [((*yyvalp)[]m4_ifval([$1], [.$1]))]) 107 108 109 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) 110 # -------------------------------------- 111 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH 112 # symbols on RHS. 113 m4_define([b4_rhs_value], 114 [(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3]))]) 115 116 117 118 ## ----------- ## 119 ## Locations. ## 120 ## ----------- ## 121 122 # b4_lhs_location() 123 # ----------------- 124 # Expansion of @$. 125 m4_define([b4_lhs_location], 126 [(*yylocp)]) 127 128 129 # b4_rhs_location(RULE-LENGTH, NUM) 130 # --------------------------------- 131 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols 132 # on RHS. 133 m4_define([b4_rhs_location], 134 [(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)]) 135 136 137 138 ## -------------- ## 139 ## Output files. ## 140 ## -------------- ## 141 142 # We do want M4 expansion after # for CPP macros. 143 m4_changecom() 144 m4_divert(0)dnl 145 @output @output_parser_name@ 146 b4_copyright([Skeleton implementation for Bison GLR parsers in C], 147 [2002, 2003, 2004, 2005, 2006]) 148 [ 149 /* C GLR parser skeleton written by Paul Hilfinger. */ 150 151 ]b4_identification 152 153 m4_if(b4_prefix, [yy], [], 154 [/* Substitute the variable and function names. */ 155 #define yyparse b4_prefix[]parse 156 #define yylex b4_prefix[]lex 157 #define yyerror b4_prefix[]error 158 #define yylval b4_prefix[]lval 159 #define yychar b4_prefix[]char 160 #define yydebug b4_prefix[]debug 161 #define yynerrs b4_prefix[]nerrs 162 #define yylloc b4_prefix[]lloc]) 163 164 dnl # b4_shared_declarations 165 dnl # ---------------------- 166 dnl # Declaration that might either go into the header (if --defines) 167 dnl # or open coded in the parser body. 168 m4_define([b4_shared_declarations], 169 [b4_token_enums(b4_tokens)[ 170 171 /* Copy the first part of user declarations. */ 172 ]b4_pre_prologue[ 173 174 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 175 ]m4_ifdef([b4_stype], 176 [typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ]) 177 b4_stype 178 /* Line __line__ of glr.c. */ 179 b4_syncline([@oline@], [@ofile@]) 180 YYSTYPE;], 181 [typedef int YYSTYPE;])[ 182 # define YYSTYPE_IS_DECLARED 1 183 # define YYSTYPE_IS_TRIVIAL 1 184 #endif 185 186 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED 187 typedef struct YYLTYPE 188 { 189 ]b4_locations_if([ 190 int first_line; 191 int first_column; 192 int last_line; 193 int last_column; 194 ],[ 195 char yydummy; 196 ])[ 197 } YYLTYPE; 198 # define YYLTYPE_IS_DECLARED 1 199 # define YYLTYPE_IS_TRIVIAL 1 200 #endif 201 ]]) 202 203 b4_defines_if([#include @output_header_name@], 204 [b4_shared_declarations])[ 205 206 /* Enabling traces. */ 207 #ifndef YYDEBUG 208 # define YYDEBUG ]b4_debug_flag[ 209 #endif 210 211 /* Enabling verbose error messages. */ 212 #ifdef YYERROR_VERBOSE 213 # undef YYERROR_VERBOSE 214 # define YYERROR_VERBOSE 1 215 #else 216 # define YYERROR_VERBOSE ]b4_error_verbose_flag[ 217 #endif 218 219 /* Enabling the token table. */ 220 #ifndef YYTOKEN_TABLE 221 # define YYTOKEN_TABLE ]b4_token_table[ 222 #endif 223 224 /* Default (constant) value used for initialization for null 225 right-hand sides. Unlike the standard yacc.c template, 226 here we set the default value of $$ to a zeroed-out value. 227 Since the default value is undefined, this behavior is 228 technically correct. */ 229 static YYSTYPE yyval_default; 230 231 /* Copy the second part of user declarations. */ 232 ]b4_post_prologue[ 233 234 ]/* Line __line__ of glr.c. */ 235 b4_syncline([@oline@], [@ofile@]) 236 [ 237 #include <stdio.h> 238 #include <stdlib.h> 239 #include <string.h> 240 #include <stdarg.h> 241 242 #ifndef YY_ 243 # if YYENABLE_NLS 244 # if ENABLE_NLS 245 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 246 # define YY_(msgid) dgettext ("bison-runtime", msgid) 247 # endif 248 # endif 249 # ifndef YY_ 250 # define YY_(msgid) msgid 251 # endif 252 #endif 253 254 /* Suppress unused-variable warnings by "using" E. */ 255 #if ! defined lint || defined __GNUC__ 256 # define YYUSE(e) ((void) (e)) 257 #else 258 # define YYUSE(e) /* empty */ 259 #endif 260 261 /* Identity function, used to suppress warnings about constant conditions. */ 262 #ifndef lint 263 # define YYID(n) (n) 264 #else 265 ]b4_c_function_def([YYID], [static int], [[int i], [i]])[ 266 { 267 return i; 268 } 269 #endif 270 271 #ifndef YYFREE 272 # define YYFREE free 273 #endif 274 #ifndef YYMALLOC 275 # define YYMALLOC malloc 276 #endif 277 #ifndef YYREALLOC 278 # define YYREALLOC realloc 279 #endif 280 281 #define YYSIZEMAX ((size_t) -1) 282 283 #ifdef __cplusplus 284 typedef bool yybool; 285 #else 286 typedef unsigned char yybool; 287 #endif 288 #define yytrue 1 289 #define yyfalse 0 290 291 #ifndef YYSETJMP 292 # include <setjmp.h> 293 # define YYJMP_BUF jmp_buf 294 # define YYSETJMP(env) setjmp (env) 295 # define YYLONGJMP(env, val) longjmp (env, val) 296 #endif 297 298 /*-----------------. 299 | GCC extensions. | 300 `-----------------*/ 301 302 #ifndef __attribute__ 303 /* This feature is available in gcc versions 2.5 and later. */ 304 # if (! defined __GNUC__ || __GNUC__ < 2 \ 305 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__) 306 # define __attribute__(Spec) /* empty */ 307 # endif 308 #endif 309 310 ]b4_locations_if([#define YYOPTIONAL_LOC(Name) Name],[ 311 #ifdef __cplusplus 312 # define YYOPTIONAL_LOC(Name) /* empty */ 313 #else 314 # define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__)) 315 #endif])[ 316 317 #ifndef YYASSERT 318 # define YYASSERT(condition) ((void) ((condition) || (abort (), 0))) 319 #endif 320 321 /* YYFINAL -- State number of the termination state. */ 322 #define YYFINAL ]b4_final_state_number[ 323 /* YYLAST -- Last index in YYTABLE. */ 324 #define YYLAST ]b4_last[ 325 326 /* YYNTOKENS -- Number of terminals. */ 327 #define YYNTOKENS ]b4_tokens_number[ 328 /* YYNNTS -- Number of nonterminals. */ 329 #define YYNNTS ]b4_nterms_number[ 330 /* YYNRULES -- Number of rules. */ 331 #define YYNRULES ]b4_rules_number[ 332 /* YYNRULES -- Number of states. */ 333 #define YYNSTATES ]b4_states_number[ 334 /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ 335 #define YYMAXRHS ]b4_r2_max[ 336 /* YYMAXLEFT -- Maximum number of symbols to the left of a handle 337 accessed by $0, $-1, etc., in any rule. */ 338 #define YYMAXLEFT ]b4_max_left_semantic_context[ 339 340 /* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */ 341 #define YYUNDEFTOK ]b4_undef_token_number[ 342 #define YYMAXUTOK ]b4_user_token_number_max[ 343 344 #define YYTRANSLATE(YYX) \ 345 ((YYX <= 0) ? YYEOF : \ 346 (unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 347 348 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 349 static const ]b4_int_type_for([b4_translate])[ yytranslate[] = 350 { 351 ]b4_translate[ 352 }; 353 354 #if YYDEBUG 355 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 356 YYRHS. */ 357 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = 358 { 359 ]b4_prhs[ 360 }; 361 362 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 363 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = 364 { 365 ]b4_rhs[ 366 }; 367 368 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 369 static const ]b4_int_type_for([b4_rline])[ yyrline[] = 370 { 371 ]b4_rline[ 372 }; 373 #endif 374 375 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 376 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 377 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 378 static const char *const yytname[] = 379 { 380 ]b4_tname[ 381 }; 382 #endif 383 384 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 385 static const ]b4_int_type_for([b4_r1])[ yyr1[] = 386 { 387 ]b4_r1[ 388 }; 389 390 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 391 static const ]b4_int_type_for([b4_r2])[ yyr2[] = 392 { 393 ]b4_r2[ 394 }; 395 396 /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ 397 static const ]b4_int_type_for([b4_dprec])[ yydprec[] = 398 { 399 ]b4_dprec[ 400 }; 401 402 /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ 403 static const ]b4_int_type_for([b4_merger])[ yymerger[] = 404 { 405 ]b4_merger[ 406 }; 407 408 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE 409 doesn't specify something else to do. Zero means the default is an 410 error. */ 411 static const ]b4_int_type_for([b4_defact])[ yydefact[] = 412 { 413 ]b4_defact[ 414 }; 415 416 /* YYPDEFGOTO[NTERM-NUM]. */ 417 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = 418 { 419 ]b4_defgoto[ 420 }; 421 422 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 423 STATE-NUM. */ 424 #define YYPACT_NINF ]b4_pact_ninf[ 425 static const ]b4_int_type_for([b4_pact])[ yypact[] = 426 { 427 ]b4_pact[ 428 }; 429 430 /* YYPGOTO[NTERM-NUM]. */ 431 static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = 432 { 433 ]b4_pgoto[ 434 }; 435 436 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 437 positive, shift that token. If negative, reduce the rule which 438 number is the opposite. If zero, do what YYDEFACT says. 439 If YYTABLE_NINF, syntax error. */ 440 #define YYTABLE_NINF ]b4_table_ninf[ 441 static const ]b4_int_type_for([b4_table])[ yytable[] = 442 { 443 ]b4_table[ 444 }; 445 446 /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of 447 list of conflicting reductions corresponding to action entry for 448 state STATE-NUM in yytable. 0 means no conflicts. The list in 449 yyconfl is terminated by a rule number of 0. */ 450 static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = 451 { 452 ]b4_conflict_list_heads[ 453 }; 454 455 /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by 456 0, pointed into by YYCONFLP. */ 457 ]dnl Do not use b4_int_type_for here, since there are places where 458 dnl pointers onto yyconfl are taken, which type is "short int *". 459 dnl We probably ought to introduce a type for confl. 460 [static const short int yyconfl[] = 461 { 462 ]b4_conflicting_rules[ 463 }; 464 465 static const ]b4_int_type_for([b4_check])[ yycheck[] = 466 { 467 ]b4_check[ 468 }; 469 470 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 471 symbol of state STATE-NUM. */ 472 static const ]b4_int_type_for([b4_stos])[ yystos[] = 473 { 474 ]b4_stos[ 475 }; 476 477 478 /* Prevent warning if -Wmissing-prototypes. */ 480 ]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[ 481 482 /* Error token number */ 483 #define YYTERROR 1 484 485 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 486 If N is 0, then set CURRENT to the empty location which ends 487 the previous symbol: RHS[0] (always defined). */ 488 489 ]b4_locations_if([[ 490 #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc) 491 #ifndef YYLLOC_DEFAULT 492 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 493 do \ 494 if (YYID (N)) \ 495 { \ 496 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 497 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 498 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 499 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 500 } \ 501 else \ 502 { \ 503 (Current).first_line = (Current).last_line = \ 504 YYRHSLOC (Rhs, 0).last_line; \ 505 (Current).first_column = (Current).last_column = \ 506 YYRHSLOC (Rhs, 0).last_column; \ 507 } \ 508 while (YYID (0)) 509 510 /* YY_LOCATION_PRINT -- Print the location on the stream. 511 This macro was not mandated originally: define only if we know 512 we won't break user code: when these are the locations we know. */ 513 514 # define YY_LOCATION_PRINT(File, Loc) \ 515 fprintf (File, "%d.%d-%d.%d", \ 516 (Loc).first_line, (Loc).first_column, \ 517 (Loc).last_line, (Loc).last_column) 518 #endif 519 ]],[ 520 #ifndef YYLLOC_DEFAULT 521 # define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0) 522 #endif 523 ])[ 524 525 #ifndef YY_LOCATION_PRINT 526 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 527 #endif 528 529 530 /* YYLEX -- calling `yylex' with the right arguments. */ 531 #define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ 532 533 ]b4_pure_if( 534 [ 535 #undef yynerrs 536 #define yynerrs (yystackp->yyerrcnt) 537 #undef yychar 538 #define yychar (yystackp->yyrawchar) 539 #undef yylval 540 #define yylval (yystackp->yyval) 541 #undef yylloc 542 #define yylloc (yystackp->yyloc) 543 m4_if(b4_prefix[], [yy], [], 544 [#define b4_prefix[]nerrs yynerrs 545 #define b4_prefix[]char yychar 546 #define b4_prefix[]lval yylval 547 #define b4_prefix[]lloc yylloc])], 548 [YYSTYPE yylval; 549 550 YYLTYPE yylloc; 551 552 int yynerrs; 553 int yychar;])[ 554 555 static const int YYEOF = 0; 556 static const int YYEMPTY = -2; 557 558 typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; 559 560 #define YYCHK(YYE) \ 561 do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \ 562 while (YYID (0)) 563 564 #if YYDEBUG 565 566 # ifndef YYFPRINTF 567 # define YYFPRINTF fprintf 568 # endif 569 570 # define YYDPRINTF(Args) \ 571 do { \ 572 if (yydebug) \ 573 YYFPRINTF Args; \ 574 } while (YYID (0)) 575 576 ]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[ 577 578 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 579 do { \ 580 if (yydebug) \ 581 { \ 582 YYFPRINTF (stderr, "%s ", Title); \ 583 yy_symbol_print (stderr, Type, \ 584 Value]b4_locations_if([, Location])[]b4_user_args[); \ 585 YYFPRINTF (stderr, "\n"); \ 586 } \ 587 } while (YYID (0)) 588 589 /* Nonzero means print parse trace. It is left uninitialized so that 590 multiple parsers can coexist. */ 591 int yydebug; 592 593 #else /* !YYDEBUG */ 594 595 # define YYDPRINTF(Args) 596 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 597 598 #endif /* !YYDEBUG */ 599 600 /* YYINITDEPTH -- initial size of the parser's stacks. */ 601 #ifndef YYINITDEPTH 602 # define YYINITDEPTH ]b4_stack_depth_init[ 603 #endif 604 605 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 606 if the built-in stack extension method is used). 607 608 Do not make this value too large; the results are undefined if 609 SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem) 610 evaluated with infinite-precision integer arithmetic. */ 611 612 #ifndef YYMAXDEPTH 613 # define YYMAXDEPTH ]b4_stack_depth_max[ 614 #endif 615 616 /* Minimum number of free items on the stack allowed after an 617 allocation. This is to allow allocation and initialization 618 to be completed by functions that call yyexpandGLRStack before the 619 stack is expanded, thus insuring that all necessary pointers get 620 properly redirected to new data. */ 621 #define YYHEADROOM 2 622 623 #ifndef YYSTACKEXPANDABLE 624 # if (! defined __cplusplus \ 625 || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \ 626 && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)) 627 # define YYSTACKEXPANDABLE 1 628 # else 629 # define YYSTACKEXPANDABLE 0 630 # endif 631 #endif 632 633 #if YYSTACKEXPANDABLE 634 # define YY_RESERVE_GLRSTACK(Yystack) \ 635 do { \ 636 if (Yystack->yyspaceLeft < YYHEADROOM) \ 637 yyexpandGLRStack (Yystack); \ 638 } while (YYID (0)) 639 #else 640 # define YY_RESERVE_GLRSTACK(Yystack) \ 641 do { \ 642 if (Yystack->yyspaceLeft < YYHEADROOM) \ 643 yyMemoryExhausted (Yystack); \ 644 } while (YYID (0)) 645 #endif 646 647 648 #if YYERROR_VERBOSE 649 650 # ifndef yystpcpy 651 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 652 # define yystpcpy stpcpy 653 # else 654 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 655 YYDEST. */ 656 static char * 657 yystpcpy (char *yydest, const char *yysrc) 658 { 659 char *yyd = yydest; 660 const char *yys = yysrc; 661 662 while ((*yyd++ = *yys++) != '\0') 663 continue; 664 665 return yyd - 1; 666 } 667 # endif 668 # endif 669 670 # ifndef yytnamerr 671 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 672 quotes and backslashes, so that it's suitable for yyerror. The 673 heuristic is that double-quoting is unnecessary unless the string 674 contains an apostrophe, a comma, or backslash (other than 675 backslash-backslash). YYSTR is taken from yytname. If YYRES is 676 null, do not copy; instead, return the length of what the result 677 would have been. */ 678 static size_t 679 yytnamerr (char *yyres, const char *yystr) 680 { 681 if (*yystr == '"') 682 { 683 size_t yyn = 0; 684 char const *yyp = yystr; 685 686 for (;;) 687 switch (*++yyp) 688 { 689 case '\'': 690 case ',': 691 goto do_not_strip_quotes; 692 693 case '\\': 694 if (*++yyp != '\\') 695 goto do_not_strip_quotes; 696 /* Fall through. */ 697 default: 698 if (yyres) 699 yyres[yyn] = *yyp; 700 yyn++; 701 break; 702 703 case '"': 704 if (yyres) 705 yyres[yyn] = '\0'; 706 return yyn; 707 } 708 do_not_strip_quotes: ; 709 } 710 711 if (! yyres) 712 return strlen (yystr); 713 714 return yystpcpy (yyres, yystr) - yyres; 715 } 716 # endif 717 718 #endif /* !YYERROR_VERBOSE */ 719 720 /** State numbers, as in LALR(1) machine */ 721 typedef int yyStateNum; 722 723 /** Rule numbers, as in LALR(1) machine */ 724 typedef int yyRuleNum; 725 726 /** Grammar symbol */ 727 typedef short int yySymbol; 728 729 /** Item references, as in LALR(1) machine */ 730 typedef short int yyItemNum; 731 732 typedef struct yyGLRState yyGLRState; 733 typedef struct yyGLRStateSet yyGLRStateSet; 734 typedef struct yySemanticOption yySemanticOption; 735 typedef union yyGLRStackItem yyGLRStackItem; 736 typedef struct yyGLRStack yyGLRStack; 737 738 struct yyGLRState { 739 /** Type tag: always true. */ 740 yybool yyisState; 741 /** Type tag for yysemantics. If true, yysval applies, otherwise 742 * yyfirstVal applies. */ 743 yybool yyresolved; 744 /** Number of corresponding LALR(1) machine state. */ 745 yyStateNum yylrState; 746 /** Preceding state in this stack */ 747 yyGLRState* yypred; 748 /** Source position of the first token produced by my symbol */ 749 size_t yyposn; 750 union { 751 /** First in a chain of alternative reductions producing the 752 * non-terminal corresponding to this state, threaded through 753 * yynext. */ 754 yySemanticOption* yyfirstVal; 755 /** Semantic value for this state. */ 756 YYSTYPE yysval; 757 } yysemantics; 758 /** Source location for this state. */ 759 YYLTYPE yyloc; 760 }; 761 762 struct yyGLRStateSet { 763 yyGLRState** yystates; 764 /** During nondeterministic operation, yylookaheadNeeds tracks which 765 * stacks have actually needed the current lookahead. During deterministic 766 * operation, yylookaheadNeeds[0] is not maintained since it would merely 767 * duplicate yychar != YYEMPTY. */ 768 yybool* yylookaheadNeeds; 769 size_t yysize, yycapacity; 770 }; 771 772 struct yySemanticOption { 773 /** Type tag: always false. */ 774 yybool yyisState; 775 /** Rule number for this reduction */ 776 yyRuleNum yyrule; 777 /** The last RHS state in the list of states to be reduced. */ 778 yyGLRState* yystate; 779 /** The lookahead for this reduction. */ 780 int yyrawchar; 781 YYSTYPE yyval; 782 YYLTYPE yyloc; 783 /** Next sibling in chain of options. To facilitate merging, 784 * options are chained in decreasing order by address. */ 785 yySemanticOption* yynext; 786 }; 787 788 /** Type of the items in the GLR stack. The yyisState field 789 * indicates which item of the union is valid. */ 790 union yyGLRStackItem { 791 yyGLRState yystate; 792 yySemanticOption yyoption; 793 }; 794 795 struct yyGLRStack { 796 int yyerrState; 797 ]b4_locations_if([[ /* To compute the location of the error token. */ 798 yyGLRStackItem yyerror_range[3];]])[ 799 ]b4_pure_if( 800 [ 801 int yyerrcnt; 802 int yyrawchar; 803 YYSTYPE yyval; 804 YYLTYPE yyloc; 805 ])[ 806 YYJMP_BUF yyexception_buffer; 807 yyGLRStackItem* yyitems; 808 yyGLRStackItem* yynextFree; 809 size_t yyspaceLeft; 810 yyGLRState* yysplitPoint; 811 yyGLRState* yylastDeleted; 812 yyGLRStateSet yytops; 813 }; 814 815 #if YYSTACKEXPANDABLE 816 static void yyexpandGLRStack (yyGLRStack* yystackp); 817 #endif 818 819 static void yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) 820 __attribute__ ((__noreturn__)); 821 static void 822 yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) 823 { 824 if (yymsg != NULL) 825 yyerror (]b4_yyerror_args[yymsg); 826 YYLONGJMP (yystackp->yyexception_buffer, 1); 827 } 828 829 static void yyMemoryExhausted (yyGLRStack* yystackp) 830 __attribute__ ((__noreturn__)); 831 static void 832 yyMemoryExhausted (yyGLRStack* yystackp) 833 { 834 YYLONGJMP (yystackp->yyexception_buffer, 2); 835 } 836 837 #if YYDEBUG || YYERROR_VERBOSE 838 /** A printable representation of TOKEN. */ 839 static inline const char* 840 yytokenName (yySymbol yytoken) 841 { 842 if (yytoken == YYEMPTY) 843 return ""; 844 845 return yytname[yytoken]; 846 } 847 #endif 848 849 /** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting 850 * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred 851 * containing the pointer to the next state in the chain. */ 852 static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__)); 853 static void 854 yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1) 855 { 856 yyGLRState* s; 857 int i; 858 s = yyvsp[yylow0].yystate.yypred; 859 for (i = yylow0-1; i >= yylow1; i -= 1) 860 { 861 YYASSERT (s->yyresolved); 862 yyvsp[i].yystate.yyresolved = yytrue; 863 yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval; 864 yyvsp[i].yystate.yyloc = s->yyloc; 865 s = yyvsp[i].yystate.yypred = s->yypred; 866 } 867 } 868 869 /* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in 870 * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1. 871 * For convenience, always return YYLOW1. */ 872 static inline int yyfill (yyGLRStackItem *, int *, int, yybool) 873 __attribute__ ((__unused__)); 874 static inline int 875 yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal) 876 { 877 if (!yynormal && yylow1 < *yylow) 878 { 879 yyfillin (yyvsp, *yylow, yylow1); 880 *yylow = yylow1; 881 } 882 return yylow1; 883 } 884 885 /** Perform user action for rule number YYN, with RHS length YYRHSLEN, 886 * and top stack item YYVSP. YYLVALP points to place to put semantic 887 * value ($$), and yylocp points to place for location information 888 * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT, 889 * yyerr for YYERROR, yyabort for YYABORT. */ 890 /*ARGSUSED*/ static YYRESULTTAG 891 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, 892 YYSTYPE* yyvalp, 893 YYLTYPE* YYOPTIONAL_LOC (yylocp), 894 yyGLRStack* yystackp 895 ]b4_user_formals[) 896 { 897 yybool yynormal __attribute__ ((__unused__)) = 898 (yystackp->yysplitPoint == NULL); 899 int yylow; 900 ]b4_parse_param_use[]dnl 901 [# undef yyerrok 902 # define yyerrok (yystackp->yyerrState = 0) 903 # undef YYACCEPT 904 # define YYACCEPT return yyaccept 905 # undef YYABORT 906 # define YYABORT return yyabort 907 # undef YYERROR 908 # define YYERROR return yyerrok, yyerr 909 # undef YYRECOVERING 910 # define YYRECOVERING() (yystackp->yyerrState != 0) 911 # undef yyclearin 912 # define yyclearin (yychar = YYEMPTY) 913 # undef YYFILL 914 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal) 915 # undef YYBACKUP 916 # define YYBACKUP(Token, Value) \ 917 return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \ 918 yyerrok, yyerr 919 920 yylow = 1; 921 if (yyrhslen == 0) 922 *yyvalp = yyval_default; 923 else 924 *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval; 925 YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); 926 ]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp; 927 ]])[ 928 switch (yyn) 929 { 930 ]b4_actions 931 /* Line __line__ of glr.c. */ 932 b4_syncline([@oline@], [@ofile@])[ 933 default: break; 934 } 935 936 return yyok; 937 # undef yyerrok 938 # undef YYABORT 939 # undef YYACCEPT 940 # undef YYERROR 941 # undef YYBACKUP 942 # undef yyclearin 943 # undef YYRECOVERING 944 } 945 946 948 /*ARGSUSED*/ static void 949 yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) 950 { 951 YYUSE (yy0); 952 YYUSE (yy1); 953 954 switch (yyn) 955 { 956 ]b4_mergers[ 957 default: break; 958 } 959 } 960 961 /* Bison grammar-table manipulation. */ 962 963 ]b4_yydestruct_generate([b4_c_ansi_function_def])[ 964 965 /** Number of symbols composing the right hand side of rule #RULE. */ 966 static inline int 967 yyrhsLength (yyRuleNum yyrule) 968 { 969 return yyr2[yyrule]; 970 } 971 972 static void 973 yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) 974 { 975 if (yys->yyresolved) 976 yydestruct (yymsg, yystos[yys->yylrState], 977 &yys->yysemantics.yysval]b4_locations_if([, &yys->yyloc])[]b4_user_args[); 978 else 979 { 980 #if YYDEBUG 981 if (yydebug) 982 { 983 if (yys->yysemantics.yyfirstVal) 984 YYFPRINTF (stderr, "%s unresolved ", yymsg); 985 else 986 YYFPRINTF (stderr, "%s incomplete ", yymsg); 987 yy_symbol_print (stderr, yystos[yys->yylrState], 988 NULL]b4_locations_if([, &yys->yyloc])[]b4_user_args[); 989 YYFPRINTF (stderr, "\n"); 990 } 991 #endif 992 993 if (yys->yysemantics.yyfirstVal) 994 { 995 yySemanticOption *yyoption = yys->yysemantics.yyfirstVal; 996 yyGLRState *yyrh; 997 int yyn; 998 for (yyrh = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule); 999 yyn > 0; 1000 yyrh = yyrh->yypred, yyn -= 1) 1001 yydestroyGLRState (yymsg, yyrh]b4_user_args[); 1002 } 1003 } 1004 } 1005 1006 /** Left-hand-side symbol for rule #RULE. */ 1007 static inline yySymbol 1008 yylhsNonterm (yyRuleNum yyrule) 1009 { 1010 return yyr1[yyrule]; 1011 } 1012 1013 #define yyis_pact_ninf(yystate) \ 1014 ]m4_if(m4_eval(b4_pact_ninf < b4_pact_min), [1], 1015 [0], 1016 [((yystate) == YYPACT_NINF)])[ 1017 1018 /** True iff LR state STATE has only a default reduction (regardless 1019 * of token). */ 1020 static inline yybool 1021 yyisDefaultedState (yyStateNum yystate) 1022 { 1023 return yyis_pact_ninf (yypact[yystate]); 1024 } 1025 1026 /** The default reduction for STATE, assuming it has one. */ 1027 static inline yyRuleNum 1028 yydefaultAction (yyStateNum yystate) 1029 { 1030 return yydefact[yystate]; 1031 } 1032 1033 #define yyis_table_ninf(yytable_value) \ 1034 ]m4_if(m4_eval(b4_table_ninf < b4_table_min), [1], 1035 [YYID (0)], 1036 [((yytable_value) == YYTABLE_NINF)])[ 1037 1038 /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN. 1039 * Result R means 1040 * R < 0: Reduce on rule -R. 1041 * R = 0: Error. 1042 * R > 0: Shift to state R. 1043 * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of 1044 * conflicting reductions. 1045 */ 1046 static inline void 1047 yygetLRActions (yyStateNum yystate, int yytoken, 1048 int* yyaction, const short int** yyconflicts) 1049 { 1050 int yyindex = yypact[yystate] + yytoken; 1051 if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken) 1052 { 1053 *yyaction = -yydefact[yystate]; 1054 *yyconflicts = yyconfl; 1055 } 1056 else if (! yyis_table_ninf (yytable[yyindex])) 1057 { 1058 *yyaction = yytable[yyindex]; 1059 *yyconflicts = yyconfl + yyconflp[yyindex]; 1060 } 1061 else 1062 { 1063 *yyaction = 0; 1064 *yyconflicts = yyconfl + yyconflp[yyindex]; 1065 } 1066 } 1067 1068 static inline yyStateNum 1069 yyLRgotoState (yyStateNum yystate, yySymbol yylhs) 1070 { 1071 int yyr; 1072 yyr = yypgoto[yylhs - YYNTOKENS] + yystate; 1073 if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate) 1074 return yytable[yyr]; 1075 else 1076 return yydefgoto[yylhs - YYNTOKENS]; 1077 } 1078 1079 static inline yybool 1080 yyisShiftAction (int yyaction) 1081 { 1082 return 0 < yyaction; 1083 } 1084 1085 static inline yybool 1086 yyisErrorAction (int yyaction) 1087 { 1088 return yyaction == 0; 1089 } 1090 1091 /* GLRStates */ 1092 1093 /** Return a fresh GLRStackItem. Callers should call 1094 * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient 1095 * headroom. */ 1096 1097 static inline yyGLRStackItem* 1098 yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState) 1099 { 1100 yyGLRStackItem* yynewItem = yystackp->yynextFree; 1101 yystackp->yyspaceLeft -= 1; 1102 yystackp->yynextFree += 1; 1103 yynewItem->yystate.yyisState = yyisState; 1104 return yynewItem; 1105 } 1106 1107 /** Add a new semantic action that will execute the action for rule 1108 * RULENUM on the semantic values in RHS to the list of 1109 * alternative actions for STATE. Assumes that RHS comes from 1110 * stack #K of *STACKP. */ 1111 static void 1112 yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate, 1113 yyGLRState* rhs, yyRuleNum yyrule) 1114 { 1115 yySemanticOption* yynewOption = 1116 &yynewGLRStackItem (yystackp, yyfalse)->yyoption; 1117 yynewOption->yystate = rhs; 1118 yynewOption->yyrule = yyrule; 1119 if (yystackp->yytops.yylookaheadNeeds[yyk]) 1120 { 1121 yynewOption->yyrawchar = yychar; 1122 yynewOption->yyval = yylval; 1123 yynewOption->yyloc = yylloc; 1124 } 1125 else 1126 yynewOption->yyrawchar = YYEMPTY; 1127 yynewOption->yynext = yystate->yysemantics.yyfirstVal; 1128 yystate->yysemantics.yyfirstVal = yynewOption; 1129 1130 YY_RESERVE_GLRSTACK (yystackp); 1131 } 1132 1133 /* GLRStacks */ 1134 1135 /** Initialize SET to a singleton set containing an empty stack. */ 1136 static yybool 1137 yyinitStateSet (yyGLRStateSet* yyset) 1138 { 1139 yyset->yysize = 1; 1140 yyset->yycapacity = 16; 1141 yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]); 1142 if (! yyset->yystates) 1143 return yyfalse; 1144 yyset->yystates[0] = NULL; 1145 yyset->yylookaheadNeeds = 1146 (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]); 1147 if (! yyset->yylookaheadNeeds) 1148 { 1149 YYFREE (yyset->yystates); 1150 return yyfalse; 1151 } 1152 return yytrue; 1153 } 1154 1155 static void yyfreeStateSet (yyGLRStateSet* yyset) 1156 { 1157 YYFREE (yyset->yystates); 1158 YYFREE (yyset->yylookaheadNeeds); 1159 } 1160 1161 /** Initialize STACK to a single empty stack, with total maximum 1162 * capacity for all stacks of SIZE. */ 1163 static yybool 1164 yyinitGLRStack (yyGLRStack* yystackp, size_t yysize) 1165 { 1166 yystackp->yyerrState = 0; 1167 yynerrs = 0; 1168 yystackp->yyspaceLeft = yysize; 1169 yystackp->yyitems = 1170 (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]); 1171 if (!yystackp->yyitems) 1172 return yyfalse; 1173 yystackp->yynextFree = yystackp->yyitems; 1174 yystackp->yysplitPoint = NULL; 1175 yystackp->yylastDeleted = NULL; 1176 return yyinitStateSet (&yystackp->yytops); 1177 } 1178 1179 1180 #if YYSTACKEXPANDABLE 1181 # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ 1182 &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE 1183 1184 /** If STACK is expandable, extend it. WARNING: Pointers into the 1185 stack from outside should be considered invalid after this call. 1186 We always expand when there are 1 or fewer items left AFTER an 1187 allocation, so that we can avoid having external pointers exist 1188 across an allocation. */ 1189 static void 1190 yyexpandGLRStack (yyGLRStack* yystackp) 1191 { 1192 yyGLRStackItem* yynewItems; 1193 yyGLRStackItem* yyp0, *yyp1; 1194 size_t yysize, yynewSize; 1195 size_t yyn; 1196 yysize = yystackp->yynextFree - yystackp->yyitems; 1197 if (YYMAXDEPTH - YYHEADROOM < yysize) 1198 yyMemoryExhausted (yystackp); 1199 yynewSize = 2*yysize; 1200 if (YYMAXDEPTH < yynewSize) 1201 yynewSize = YYMAXDEPTH; 1202 yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]); 1203 if (! yynewItems) 1204 yyMemoryExhausted (yystackp); 1205 for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize; 1206 0 < yyn; 1207 yyn -= 1, yyp0 += 1, yyp1 += 1) 1208 { 1209 *yyp1 = *yyp0; 1210 if (*(yybool *) yyp0) 1211 { 1212 yyGLRState* yys0 = &yyp0->yystate; 1213 yyGLRState* yys1 = &yyp1->yystate; 1214 if (yys0->yypred != NULL) 1215 yys1->yypred = 1216 YYRELOC (yyp0, yyp1, yys0->yypred, yystate); 1217 if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL) 1218 yys1->yysemantics.yyfirstVal = 1219 YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); 1220 } 1221 else 1222 { 1223 yySemanticOption* yyv0 = &yyp0->yyoption; 1224 yySemanticOption* yyv1 = &yyp1->yyoption; 1225 if (yyv0->yystate != NULL) 1226 yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); 1227 if (yyv0->yynext != NULL) 1228 yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); 1229 } 1230 } 1231 if (yystackp->yysplitPoint != NULL) 1232 yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, 1233 yystackp->yysplitPoint, yystate); 1234 1235 for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1) 1236 if (yystackp->yytops.yystates[yyn] != NULL) 1237 yystackp->yytops.yystates[yyn] = 1238 YYRELOC (yystackp->yyitems, yynewItems, 1239 yystackp->yytops.yystates[yyn], yystate); 1240 YYFREE (yystackp->yyitems); 1241 yystackp->yyitems = yynewItems; 1242 yystackp->yynextFree = yynewItems + yysize; 1243 yystackp->yyspaceLeft = yynewSize - yysize; 1244 } 1245 #endif 1246 1247 static void 1248 yyfreeGLRStack (yyGLRStack* yystackp) 1249 { 1250 YYFREE (yystackp->yyitems); 1251 yyfreeStateSet (&yystackp->yytops); 1252 } 1253 1254 /** Assuming that S is a GLRState somewhere on STACK, update the 1255 * splitpoint of STACK, if needed, so that it is at least as deep as 1256 * S. */ 1257 static inline void 1258 yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) 1259 { 1260 if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys) 1261 yystackp->yysplitPoint = yys; 1262 } 1263 1264 /** Invalidate stack #K in STACK. */ 1265 static inline void 1266 yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk) 1267 { 1268 if (yystackp->yytops.yystates[yyk] != NULL) 1269 yystackp->yylastDeleted = yystackp->yytops.yystates[yyk]; 1270 yystackp->yytops.yystates[yyk] = NULL; 1271 } 1272 1273 /** Undelete the last stack that was marked as deleted. Can only be 1274 done once after a deletion, and only when all other stacks have 1275 been deleted. */ 1276 static void 1277 yyundeleteLastStack (yyGLRStack* yystackp) 1278 { 1279 if (yystackp->yylastDeleted == NULL || yystackp->yytops.yysize != 0) 1280 return; 1281 yystackp->yytops.yystates[0] = yystackp->yylastDeleted; 1282 yystackp->yytops.yysize = 1; 1283 YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); 1284 yystackp->yylastDeleted = NULL; 1285 } 1286 1287 static inline void 1288 yyremoveDeletes (yyGLRStack* yystackp) 1289 { 1290 size_t yyi, yyj; 1291 yyi = yyj = 0; 1292 while (yyj < yystackp->yytops.yysize) 1293 { 1294 if (yystackp->yytops.yystates[yyi] == NULL) 1295 { 1296 if (yyi == yyj) 1297 { 1298 YYDPRINTF ((stderr, "Removing dead stacks.\n")); 1299 } 1300 yystackp->yytops.yysize -= 1; 1301 } 1302 else 1303 { 1304 yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi]; 1305 /* In the current implementation, it's unnecessary to copy 1306 yystackp->yytops.yylookaheadNeeds[yyi] since, after 1307 yyremoveDeletes returns, the parser immediately either enters 1308 deterministic operation or shifts a token. However, it doesn't 1309 hurt, and the code might evolve to need it. */ 1310 yystackp->yytops.yylookaheadNeeds[yyj] = 1311 yystackp->yytops.yylookaheadNeeds[yyi]; 1312 if (yyj != yyi) 1313 { 1314 YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n", 1315 (unsigned long int) yyi, (unsigned long int) yyj)); 1316 } 1317 yyj += 1; 1318 } 1319 yyi += 1; 1320 } 1321 } 1322 1323 /** Shift to a new state on stack #K of STACK, corresponding to LR state 1324 * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */ 1325 static inline void 1326 yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, 1327 size_t yyposn, 1328 YYSTYPE* yyvalp, YYLTYPE* yylocp) 1329 { 1330 yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; 1331 1332 yynewState->yylrState = yylrState; 1333 yynewState->yyposn = yyposn; 1334 yynewState->yyresolved = yytrue; 1335 yynewState->yypred = yystackp->yytops.yystates[yyk]; 1336 yynewState->yysemantics.yysval = *yyvalp; 1337 yynewState->yyloc = *yylocp; 1338 yystackp->yytops.yystates[yyk] = yynewState; 1339 1340 YY_RESERVE_GLRSTACK (yystackp); 1341 } 1342 1343 /** Shift stack #K of YYSTACK, to a new state corresponding to LR 1344 * state YYLRSTATE, at input position YYPOSN, with the (unresolved) 1345 * semantic value of YYRHS under the action for YYRULE. */ 1346 static inline void 1347 yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, 1348 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule) 1349 { 1350 yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; 1351 1352 yynewState->yylrState = yylrState; 1353 yynewState->yyposn = yyposn; 1354 yynewState->yyresolved = yyfalse; 1355 yynewState->yypred = yystackp->yytops.yystates[yyk]; 1356 yynewState->yysemantics.yyfirstVal = NULL; 1357 yystackp->yytops.yystates[yyk] = yynewState; 1358 1359 /* Invokes YY_RESERVE_GLRSTACK. */ 1360 yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule); 1361 } 1362 1363 /** Pop the symbols consumed by reduction #RULE from the top of stack 1364 * #K of STACK, and perform the appropriate semantic action on their 1365 * semantic values. Assumes that all ambiguities in semantic values 1366 * have been previously resolved. Set *VALP to the resulting value, 1367 * and *LOCP to the computed location (if any). Return value is as 1368 * for userAction. */ 1369 static inline YYRESULTTAG 1370 yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, 1371 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) 1372 { 1373 int yynrhs = yyrhsLength (yyrule); 1374 1375 if (yystackp->yysplitPoint == NULL) 1376 { 1377 /* Standard special case: single stack. */ 1378 yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; 1379 YYASSERT (yyk == 0); 1380 yystackp->yynextFree -= yynrhs; 1381 yystackp->yyspaceLeft += yynrhs; 1382 yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; 1383 return yyuserAction (yyrule, yynrhs, rhs, 1384 yyvalp, yylocp, yystackp]b4_user_args[); 1385 } 1386 else 1387 { 1388 /* At present, doAction is never called in nondeterministic 1389 * mode, so this branch is never taken. It is here in 1390 * anticipation of a future feature that will allow immediate 1391 * evaluation of selected actions in nondeterministic mode. */ 1392 int yyi; 1393 yyGLRState* yys; 1394 yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; 1395 yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred 1396 = yystackp->yytops.yystates[yyk];]b4_locations_if([[ 1397 if (yynrhs == 0) 1398 /* Set default location. */ 1399 yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[ 1400 for (yyi = 0; yyi < yynrhs; yyi += 1) 1401 { 1402 yys = yys->yypred; 1403 YYASSERT (yys); 1404 } 1405 yyupdateSplit (yystackp, yys); 1406 yystackp->yytops.yystates[yyk] = yys; 1407 return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, 1408 yyvalp, yylocp, yystackp]b4_user_args[); 1409 } 1410 } 1411 1412 #if !YYDEBUG 1413 # define YY_REDUCE_PRINT(Args) 1414 #else 1415 # define YY_REDUCE_PRINT(Args) \ 1416 do { \ 1417 if (yydebug) \ 1418 yy_reduce_print Args; \ 1419 } while (YYID (0)) 1420 1421 /*----------------------------------------------------------. 1422 | Report that the RULE is going to be reduced on stack #K. | 1423 `----------------------------------------------------------*/ 1424 1425 /*ARGSUSED*/ static inline void 1426 yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, 1427 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) 1428 { 1429 int yynrhs = yyrhsLength (yyrule); 1430 yybool yynormal __attribute__ ((__unused__)) = 1431 (yystackp->yysplitPoint == NULL); 1432 yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; 1433 int yylow = 1; 1434 int yyi; 1435 YYUSE (yyvalp); 1436 YYUSE (yylocp); 1437 ]b4_parse_param_use[]dnl 1438 [ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n", 1439 (unsigned long int) yyk, yyrule - 1, 1440 (unsigned long int) yyrline[yyrule]); 1441 /* The symbols being reduced. */ 1442 for (yyi = 0; yyi < yynrhs; yyi++) 1443 { 1444 fprintf (stderr, " $%d = ", yyi + 1); 1445 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1446 &]b4_rhs_value(yynrhs, yyi + 1)[ 1447 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl 1448 b4_user_args[); 1449 fprintf (stderr, "\n"); 1450 } 1451 } 1452 #endif 1453 1454 /** Pop items off stack #K of STACK according to grammar rule RULE, 1455 * and push back on the resulting nonterminal symbol. Perform the 1456 * semantic action associated with RULE and store its value with the 1457 * newly pushed state, if FORCEEVAL or if STACK is currently 1458 * unambiguous. Otherwise, store the deferred semantic action with 1459 * the new state. If the new state would have an identical input 1460 * position, LR state, and predecessor to an existing state on the stack, 1461 * it is identified with that existing state, eliminating stack #K from 1462 * the STACK. In this case, the (necessarily deferred) semantic value is 1463 * added to the options for the existing state's semantic value. 1464 */ 1465 static inline YYRESULTTAG 1466 yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, 1467 yybool yyforceEval]b4_user_formals[) 1468 { 1469 size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn; 1470 1471 if (yyforceEval || yystackp->yysplitPoint == NULL) 1472 { 1473 YYSTYPE yysval; 1474 YYLTYPE yyloc; 1475 1476 YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval, &yyloc]b4_user_args[)); 1477 YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval, 1478 &yyloc]b4_user_args[)); 1479 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc); 1480 yyglrShift (yystackp, yyk, 1481 yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, 1482 yylhsNonterm (yyrule)), 1483 yyposn, &yysval, &yyloc); 1484 } 1485 else 1486 { 1487 size_t yyi; 1488 int yyn; 1489 yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk]; 1490 yyStateNum yynewLRState; 1491 1492 for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule); 1493 0 < yyn; yyn -= 1) 1494 { 1495 yys = yys->yypred; 1496 YYASSERT (yys); 1497 } 1498 yyupdateSplit (yystackp, yys); 1499 yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); 1500 YYDPRINTF ((stderr, 1501 "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n", 1502 (unsigned long int) yyk, yyrule - 1, yynewLRState)); 1503 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) 1504 if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL) 1505 { 1506 yyGLRState* yyp, *yysplit = yystackp->yysplitPoint; 1507 yyp = yystackp->yytops.yystates[yyi]; 1508 while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) 1509 { 1510 if (yyp->yylrState == yynewLRState && yyp->yypred == yys) 1511 { 1512 yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); 1513 yymarkStackDeleted (yystackp, yyk); 1514 YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n", 1515 (unsigned long int) yyk, 1516 (unsigned long int) yyi)); 1517 return yyok; 1518 } 1519 yyp = yyp->yypred; 1520 } 1521 } 1522 yystackp->yytops.yystates[yyk] = yys; 1523 yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule); 1524 } 1525 return yyok; 1526 } 1527 1528 static size_t 1529 yysplitStack (yyGLRStack* yystackp, size_t yyk) 1530 { 1531 if (yystackp->yysplitPoint == NULL) 1532 { 1533 YYASSERT (yyk == 0); 1534 yystackp->yysplitPoint = yystackp->yytops.yystates[yyk]; 1535 } 1536 if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity) 1537 { 1538 yyGLRState** yynewStates; 1539 yybool* yynewLookaheadNeeds; 1540 1541 yynewStates = NULL; 1542 1543 if (yystackp->yytops.yycapacity 1544 > (YYSIZEMAX / (2 * sizeof yynewStates[0]))) 1545 yyMemoryExhausted (yystackp); 1546 yystackp->yytops.yycapacity *= 2; 1547 1548 yynewStates = 1549 (yyGLRState**) YYREALLOC (yystackp->yytops.yystates, 1550 (yystackp->yytops.yycapacity 1551 * sizeof yynewStates[0])); 1552 if (yynewStates == NULL) 1553 yyMemoryExhausted (yystackp); 1554 yystackp->yytops.yystates = yynewStates; 1555 1556 yynewLookaheadNeeds = 1557 (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, 1558 (yystackp->yytops.yycapacity 1559 * sizeof yynewLookaheadNeeds[0])); 1560 if (yynewLookaheadNeeds == NULL) 1561 yyMemoryExhausted (yystackp); 1562 yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; 1563 } 1564 yystackp->yytops.yystates[yystackp->yytops.yysize] 1565 = yystackp->yytops.yystates[yyk]; 1566 yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize] 1567 = yystackp->yytops.yylookaheadNeeds[yyk]; 1568 yystackp->yytops.yysize += 1; 1569 return yystackp->yytops.yysize-1; 1570 } 1571 1572 /** True iff Y0 and Y1 represent identical options at the top level. 1573 * That is, they represent the same rule applied to RHS symbols 1574 * that produce the same terminal symbols. */ 1575 static yybool 1576 yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1) 1577 { 1578 if (yyy0->yyrule == yyy1->yyrule) 1579 { 1580 yyGLRState *yys0, *yys1; 1581 int yyn; 1582 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, 1583 yyn = yyrhsLength (yyy0->yyrule); 1584 yyn > 0; 1585 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) 1586 if (yys0->yyposn != yys1->yyposn) 1587 return yyfalse; 1588 return yytrue; 1589 } 1590 else 1591 return yyfalse; 1592 } 1593 1594 /** Assuming identicalOptions (Y0,Y1), destructively merge the 1595 * alternative semantic values for the RHS-symbols of Y1 and Y0. */ 1596 static void 1597 yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) 1598 { 1599 yyGLRState *yys0, *yys1; 1600 int yyn; 1601 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate, 1602 yyn = yyrhsLength (yyy0->yyrule); 1603 yyn > 0; 1604 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) 1605 { 1606 if (yys0 == yys1) 1607 break; 1608 else if (yys0->yyresolved) 1609 { 1610 yys1->yyresolved = yytrue; 1611 yys1->yysemantics.yysval = yys0->yysemantics.yysval; 1612 } 1613 else if (yys1->yyresolved) 1614 { 1615 yys0->yyresolved = yytrue; 1616 yys0->yysemantics.yysval = yys1->yysemantics.yysval; 1617 } 1618 else 1619 { 1620 yySemanticOption** yyz0p; 1621 yySemanticOption* yyz1; 1622 yyz0p = &yys0->yysemantics.yyfirstVal; 1623 yyz1 = yys1->yysemantics.yyfirstVal; 1624 while (YYID (yytrue)) 1625 { 1626 if (yyz1 == *yyz0p || yyz1 == NULL) 1627 break; 1628 else if (*yyz0p == NULL) 1629 { 1630 *yyz0p = yyz1; 1631 break; 1632 } 1633 else if (*yyz0p < yyz1) 1634 { 1635 yySemanticOption* yyz = *yyz0p; 1636 *yyz0p = yyz1; 1637 yyz1 = yyz1->yynext; 1638 (*yyz0p)->yynext = yyz; 1639 } 1640 yyz0p = &(*yyz0p)->yynext; 1641 } 1642 yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal; 1643 } 1644 } 1645 } 1646 1647 /** Y0 and Y1 represent two possible actions to take in a given 1648 * parsing state; return 0 if no combination is possible, 1649 * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ 1650 static int 1651 yypreference (yySemanticOption* y0, yySemanticOption* y1) 1652 { 1653 yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; 1654 int p0 = yydprec[r0], p1 = yydprec[r1]; 1655 1656 if (p0 == p1) 1657 { 1658 if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) 1659 return 0; 1660 else 1661 return 1; 1662 } 1663 if (p0 == 0 || p1 == 0) 1664 return 0; 1665 if (p0 < p1) 1666 return 3; 1667 if (p1 < p0) 1668 return 2; 1669 return 0; 1670 } 1671 1672 static YYRESULTTAG yyresolveValue (yyGLRState* yys, 1673 yyGLRStack* yystackp]b4_user_formals[); 1674 1675 1676 /** Resolve the previous N states starting at and including state S. If result 1677 * != yyok, some states may have been left unresolved possibly with empty 1678 * semantic option chains. Regardless of whether result = yyok, each state 1679 * has been left with consistent data so that yydestroyGLRState can be invoked 1680 * if necessary. */ 1681 static YYRESULTTAG 1682 yyresolveStates (yyGLRState* yys, int yyn, 1683 yyGLRStack* yystackp]b4_user_formals[) 1684 { 1685 if (0 < yyn) 1686 { 1687 YYASSERT (yys->yypred); 1688 YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[)); 1689 if (! yys->yyresolved) 1690 YYCHK (yyresolveValue (yys, yystackp]b4_user_args[)); 1691 } 1692 return yyok; 1693 } 1694 1695 /** Resolve the states for the RHS of OPT, perform its user action, and return 1696 * the semantic value and location. Regardless of whether result = yyok, all 1697 * RHS states have been destroyed (assuming the user action destroys all RHS 1698 * semantic values if invoked). */ 1699 static YYRESULTTAG 1700 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, 1701 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) 1702 { 1703 yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; 1704 int yynrhs; 1705 int yychar_current; 1706 YYSTYPE yylval_current; 1707 YYLTYPE yylloc_current; 1708 YYRESULTTAG yyflag; 1709 1710 yynrhs = yyrhsLength (yyopt->yyrule); 1711 yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[); 1712 if (yyflag != yyok) 1713 { 1714 yyGLRState *yys; 1715 for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1) 1716 yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); 1717 return yyflag; 1718 } 1719 1720 yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[ 1721 if (yynrhs == 0) 1722 /* Set default location. */ 1723 yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ 1724 yychar_current = yychar; 1725 yylval_current = yylval; 1726 yylloc_current = yylloc; 1727 yychar = yyopt->yyrawchar; 1728 yylval = yyopt->yyval; 1729 yylloc = yyopt->yyloc; 1730 yyflag = yyuserAction (yyopt->yyrule, yynrhs, 1731 yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, 1732 yyvalp, yylocp, yystackp]b4_user_args[); 1733 yychar = yychar_current; 1734 yylval = yylval_current; 1735 yylloc = yylloc_current; 1736 return yyflag; 1737 } 1738 1739 #if YYDEBUG 1740 static void 1741 yyreportTree (yySemanticOption* yyx, int yyindent) 1742 { 1743 int yynrhs = yyrhsLength (yyx->yyrule); 1744 int yyi; 1745 yyGLRState* yys; 1746 yyGLRState* yystates[1 + YYMAXRHS]; 1747 yyGLRState yyleftmost_state; 1748 1749 for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) 1750 yystates[yyi] = yys; 1751 if (yys == NULL) 1752 { 1753 yyleftmost_state.yyposn = 0; 1754 yystates[0] = &yyleftmost_state; 1755 } 1756 else 1757 yystates[0] = yys; 1758 1759 if (yyx->yystate->yyposn < yys->yyposn + 1) 1760 YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n", 1761 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), 1762 yyx->yyrule - 1); 1763 else 1764 YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n", 1765 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), 1766 yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1), 1767 (unsigned long int) yyx->yystate->yyposn); 1768 for (yyi = 1; yyi <= yynrhs; yyi += 1) 1769 { 1770 if (yystates[yyi]->yyresolved) 1771 { 1772 if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) 1773 YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "", 1774 yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1])); 1775 else 1776 YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "", 1777 yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]), 1778 (unsigned long int) (yystates[yyi - 1]->yyposn + 1), 1779 (unsigned long int) yystates[yyi]->yyposn); 1780 } 1781 else 1782 yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); 1783 } 1784 } 1785 #endif 1786 1787 /*ARGSUSED*/ static YYRESULTTAG 1788 yyreportAmbiguity (yySemanticOption* yyx0, 1789 yySemanticOption* yyx1]b4_pure_formals[) 1790 { 1791 YYUSE (yyx0); 1792 YYUSE (yyx1); 1793 1794 #if YYDEBUG 1795 YYFPRINTF (stderr, "Ambiguity detected.\n"); 1796 YYFPRINTF (stderr, "Option 1,\n"); 1797 yyreportTree (yyx0, 2); 1798 YYFPRINTF (stderr, "\nOption 2,\n"); 1799 yyreportTree (yyx1, 2); 1800 YYFPRINTF (stderr, "\n"); 1801 #endif 1802 1803 yyerror (]b4_yyerror_args[YY_("syntax is ambiguous")); 1804 return yyabort; 1805 } 1806 1807 /** Starting at and including state S1, resolve the location for each of the 1808 * previous N1 states that is unresolved. The first semantic option of a state 1809 * is always chosen. */ 1810 static void 1811 yyresolveLocations (yyGLRState* yys1, int yyn1, 1812 yyGLRStack *yystackp]b4_user_formals[) 1813 { 1814 if (0 < yyn1) 1815 { 1816 yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[); 1817 if (!yys1->yyresolved) 1818 { 1819 yySemanticOption *yyoption; 1820 yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; 1821 int yynrhs; 1822 int yychar_current; 1823 YYSTYPE yylval_current; 1824 YYLTYPE yylloc_current; 1825 yyoption = yys1->yysemantics.yyfirstVal; 1826 YYASSERT (yyoption != NULL); 1827 yynrhs = yyrhsLength (yyoption->yyrule); 1828 if (yynrhs > 0) 1829 { 1830 yyGLRState *yys; 1831 int yyn; 1832 yyresolveLocations (yyoption->yystate, yynrhs, 1833 yystackp]b4_user_args[); 1834 for (yys = yyoption->yystate, yyn = yynrhs; 1835 yyn > 0; 1836 yys = yys->yypred, yyn -= 1) 1837 yyrhsloc[yyn].yystate.yyloc = yys->yyloc; 1838 } 1839 else 1840 { 1841 /* Both yyresolveAction and yyresolveLocations traverse the GSS 1842 in reverse rightmost order. It is only necessary to invoke 1843 yyresolveLocations on a subforest for which yyresolveAction 1844 would have been invoked next had an ambiguity not been 1845 detected. Thus the location of the previous state (but not 1846 necessarily the previous state itself) is guaranteed to be 1847 resolved already. */ 1848 yyGLRState *yyprevious = yyoption->yystate; 1849 yyrhsloc[0].yystate.yyloc = yyprevious->yyloc; 1850 } 1851 yychar_current = yychar; 1852 yylval_current = yylval; 1853 yylloc_current = yylloc; 1854 yychar = yyoption->yyrawchar; 1855 yylval = yyoption->yyval; 1856 yylloc = yyoption->yyloc; 1857 YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); 1858 yychar = yychar_current; 1859 yylval = yylval_current; 1860 yylloc = yylloc_current; 1861 } 1862 } 1863 } 1864 1865 /** Resolve the ambiguity represented in state S, perform the indicated 1866 * actions, and set the semantic value of S. If result != yyok, the chain of 1867 * semantic options in S has been cleared instead or it has been left 1868 * unmodified except that redundant options may have been removed. Regardless 1869 * of whether result = yyok, S has been left with consistent data so that 1870 * yydestroyGLRState can be invoked if necessary. */ 1871 static YYRESULTTAG 1872 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) 1873 { 1874 yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal; 1875 yySemanticOption* yybest; 1876 yySemanticOption** yypp; 1877 yybool yymerge; 1878 YYSTYPE yysval; 1879 YYRESULTTAG yyflag; 1880 YYLTYPE *yylocp = &yys->yyloc; 1881 1882 yybest = yyoptionList; 1883 yymerge = yyfalse; 1884 for (yypp = &yyoptionList->yynext; *yypp != NULL; ) 1885 { 1886 yySemanticOption* yyp = *yypp; 1887 1888 if (yyidenticalOptions (yybest, yyp)) 1889 { 1890 yymergeOptionSets (yybest, yyp); 1891 *yypp = yyp->yynext; 1892 } 1893 else 1894 { 1895 switch (yypreference (yybest, yyp)) 1896 { 1897 case 0: 1898 yyresolveLocations (yys, 1, yystackp]b4_user_args[); 1899 return yyreportAmbiguity (yybest, yyp]b4_pure_args[); 1900 break; 1901 case 1: 1902 yymerge = yytrue; 1903 break; 1904 case 2: 1905 break; 1906 case 3: 1907 yybest = yyp; 1908 yymerge = yyfalse; 1909 break; 1910 default: 1911 /* This cannot happen so it is not worth a YYASSERT (yyfalse), 1912 but some compilers complain if the default case is 1913 omitted. */ 1914 break; 1915 } 1916 yypp = &yyp->yynext; 1917 } 1918 } 1919 1920 if (yymerge) 1921 { 1922 yySemanticOption* yyp; 1923 int yyprec = yydprec[yybest->yyrule]; 1924 yyflag = yyresolveAction (yybest, yystackp, &yysval, 1925 yylocp]b4_user_args[); 1926 if (yyflag == yyok) 1927 for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) 1928 { 1929 if (yyprec == yydprec[yyp->yyrule]) 1930 { 1931 YYSTYPE yysval_other; 1932 YYLTYPE yydummy; 1933 yyflag = yyresolveAction (yyp, yystackp, &yysval_other, 1934 &yydummy]b4_user_args[); 1935 if (yyflag != yyok) 1936 { 1937 yydestruct ("Cleanup: discarding incompletely merged value for", 1938 yystos[yys->yylrState], 1939 &yysval]b4_locations_if([, yylocp])[]b4_user_args[); 1940 break; 1941 } 1942 yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); 1943 } 1944 } 1945 } 1946 else 1947 yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[); 1948 1949 if (yyflag == yyok) 1950 { 1951 yys->yyresolved = yytrue; 1952 yys->yysemantics.yysval = yysval; 1953 } 1954 else 1955 yys->yysemantics.yyfirstVal = NULL; 1956 return yyflag; 1957 } 1958 1959 static YYRESULTTAG 1960 yyresolveStack (yyGLRStack* yystackp]b4_user_formals[) 1961 { 1962 if (yystackp->yysplitPoint != NULL) 1963 { 1964 yyGLRState* yys; 1965 int yyn; 1966 1967 for (yyn = 0, yys = yystackp->yytops.yystates[0]; 1968 yys != yystackp->yysplitPoint; 1969 yys = yys->yypred, yyn += 1) 1970 continue; 1971 YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp 1972 ]b4_user_args[)); 1973 } 1974 return yyok; 1975 } 1976 1977 static void 1978 yycompressStack (yyGLRStack* yystackp) 1979 { 1980 yyGLRState* yyp, *yyq, *yyr; 1981 1982 if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL) 1983 return; 1984 1985 for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL; 1986 yyp != yystackp->yysplitPoint; 1987 yyr = yyp, yyp = yyq, yyq = yyp->yypred) 1988 yyp->yypred = yyr; 1989 1990 yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems; 1991 yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1; 1992 yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems; 1993 yystackp->yysplitPoint = NULL; 1994 yystackp->yylastDeleted = NULL; 1995 1996 while (yyr != NULL) 1997 { 1998 yystackp->yynextFree->yystate = *yyr; 1999 yyr = yyr->yypred; 2000 yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate; 2001 yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate; 2002 yystackp->yynextFree += 1; 2003 yystackp->yyspaceLeft -= 1; 2004 } 2005 } 2006 2007 static YYRESULTTAG 2008 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, 2009 size_t yyposn]b4_pure_formals[) 2010 { 2011 int yyaction; 2012 const short int* yyconflicts; 2013 yyRuleNum yyrule; 2014 2015 while (yystackp->yytops.yystates[yyk] != NULL) 2016 { 2017 yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState; 2018 YYDPRINTF ((stderr, "Stack %lu Entering state %d\n", 2019 (unsigned long int) yyk, yystate)); 2020 2021 YYASSERT (yystate != YYFINAL); 2022 2023 if (yyisDefaultedState (yystate)) 2024 { 2025 yyrule = yydefaultAction (yystate); 2026 if (yyrule == 0) 2027 { 2028 YYDPRINTF ((stderr, "Stack %lu dies.\n", 2029 (unsigned long int) yyk)); 2030 yymarkStackDeleted (yystackp, yyk); 2031 return yyok; 2032 } 2033 YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[)); 2034 } 2035 else 2036 { 2037 yySymbol yytoken; 2038 yystackp->yytops.yylookaheadNeeds[yyk] = yytrue; 2039 if (yychar == YYEMPTY) 2040 { 2041 YYDPRINTF ((stderr, "Reading a token: ")); 2042 yychar = YYLEX; 2043 yytoken = YYTRANSLATE (yychar); 2044 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2045 } 2046 else 2047 yytoken = YYTRANSLATE (yychar); 2048 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); 2049 2050 while (*yyconflicts != 0) 2051 { 2052 size_t yynewStack = yysplitStack (yystackp, yyk); 2053 YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n", 2054 (unsigned long int) yynewStack, 2055 (unsigned long int) yyk)); 2056 YYCHK (yyglrReduce (yystackp, yynewStack, 2057 *yyconflicts, yyfalse]b4_user_args[)); 2058 YYCHK (yyprocessOneStack (yystackp, yynewStack, 2059 yyposn]b4_pure_args[)); 2060 yyconflicts += 1; 2061 } 2062 2063 if (yyisShiftAction (yyaction)) 2064 break; 2065 else if (yyisErrorAction (yyaction)) 2066 { 2067 YYDPRINTF ((stderr, "Stack %lu dies.\n", 2068 (unsigned long int) yyk)); 2069 yymarkStackDeleted (yystackp, yyk); 2070 break; 2071 } 2072 else 2073 YYCHK (yyglrReduce (yystackp, yyk, -yyaction, 2074 yyfalse]b4_user_args[)); 2075 } 2076 } 2077 return yyok; 2078 } 2079 2080 /*ARGSUSED*/ static void 2081 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) 2082 { 2083 if (yystackp->yyerrState == 0) 2084 { 2085 #if YYERROR_VERBOSE 2086 int yyn; 2087 yyn = yypact[yystackp->yytops.yystates[0]->yylrState]; 2088 if (YYPACT_NINF < yyn && yyn <= YYLAST) 2089 { 2090 yySymbol yytoken = YYTRANSLATE (yychar); 2091 size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken)); 2092 size_t yysize = yysize0; 2093 size_t yysize1; 2094 yybool yysize_overflow = yyfalse; 2095 char* yymsg = NULL; 2096 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 2097 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 2098 int yyx; 2099 char *yyfmt; 2100 char const *yyf; 2101 static char const yyunexpected[] = "syntax error, unexpected %s"; 2102 static char const yyexpecting[] = ", expecting %s"; 2103 static char const yyor[] = " or %s"; 2104 char yyformat[sizeof yyunexpected 2105 + sizeof yyexpecting - 1 2106 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 2107 * (sizeof yyor - 1))]; 2108 char const *yyprefix = yyexpecting; 2109 2110 /* Start YYX at -YYN if negative to avoid negative indexes in 2111 YYCHECK. */ 2112 int yyxbegin = yyn < 0 ? -yyn : 0; 2113 2114 /* Stay within bounds of both yycheck and yytname. */ 2115 int yychecklim = YYLAST - yyn + 1; 2116 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 2117 int yycount = 1; 2118 2119 yyarg[0] = yytokenName (yytoken); 2120 yyfmt = yystpcpy (yyformat, yyunexpected); 2121 2122 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2123 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 2124 { 2125 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 2126 { 2127 yycount = 1; 2128 yysize = yysize0; 2129 yyformat[sizeof yyunexpected - 1] = '\0'; 2130 break; 2131 } 2132 yyarg[yycount++] = yytokenName (yyx); 2133 yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx)); 2134 yysize_overflow |= yysize1 < yysize; 2135 yysize = yysize1; 2136 yyfmt = yystpcpy (yyfmt, yyprefix); 2137 yyprefix = yyor; 2138 } 2139 2140 yyf = YY_(yyformat); 2141 yysize1 = yysize + strlen (yyf); 2142 yysize_overflow |= yysize1 < yysize; 2143 yysize = yysize1; 2144 2145 if (!yysize_overflow) 2146 yymsg = (char *) YYMALLOC (yysize); 2147 2148 if (yymsg) 2149 { 2150 char *yyp = yymsg; 2151 int yyi = 0; 2152 while ((*yyp = *yyf)) 2153 { 2154 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 2155 { 2156 yyp += yytnamerr (yyp, yyarg[yyi++]); 2157 yyf += 2; 2158 } 2159 else 2160 { 2161 yyp++; 2162 yyf++; 2163 } 2164 } 2165 yyerror (]b4_lyyerror_args[yymsg); 2166 YYFREE (yymsg); 2167 } 2168 else 2169 { 2170 yyerror (]b4_lyyerror_args[YY_("syntax error")); 2171 yyMemoryExhausted (yystackp); 2172 } 2173 } 2174 else 2175 #endif /* YYERROR_VERBOSE */ 2176 yyerror (]b4_lyyerror_args[YY_("syntax error")); 2177 yynerrs += 1; 2178 } 2179 } 2180 2181 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP, 2182 yylval, and yylloc are the syntactic category, semantic value, and location 2183 of the look-ahead. */ 2184 /*ARGSUSED*/ static void 2185 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) 2186 { 2187 size_t yyk; 2188 int yyj; 2189 2190 if (yystackp->yyerrState == 3) 2191 /* We just shifted the error token and (perhaps) took some 2192 reductions. Skip tokens until we can proceed. */ 2193 while (YYID (yytrue)) 2194 { 2195 yySymbol yytoken; 2196 if (yychar == YYEOF) 2197 yyFail (yystackp][]b4_lpure_args[, NULL); 2198 if (yychar != YYEMPTY) 2199 {]b4_locations_if([[ 2200 /* We throw away the lookahead, but the error range 2201 of the shifted error token must take it into account. */ 2202 yyGLRState *yys = yystackp->yytops.yystates[0]; 2203 yyGLRStackItem yyerror_range[3]; 2204 yyerror_range[1].yystate.yyloc = yys->yyloc; 2205 yyerror_range[2].yystate.yyloc = yylloc; 2206 YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ 2207 yytoken = YYTRANSLATE (yychar); 2208 yydestruct ("Error: discarding", 2209 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); 2210 } 2211 YYDPRINTF ((stderr, "Reading a token: ")); 2212 yychar = YYLEX; 2213 yytoken = YYTRANSLATE (yychar); 2214 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2215 yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; 2216 if (yyis_pact_ninf (yyj)) 2217 return; 2218 yyj += yytoken; 2219 if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) 2220 { 2221 if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) 2222 return; 2223 } 2224 else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj])) 2225 return; 2226 } 2227 2228 /* Reduce to one stack. */ 2229 for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1) 2230 if (yystackp->yytops.yystates[yyk] != NULL) 2231 break; 2232 if (yyk >= yystackp->yytops.yysize) 2233 yyFail (yystackp][]b4_lpure_args[, NULL); 2234 for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1) 2235 yymarkStackDeleted (yystackp, yyk); 2236 yyremoveDeletes (yystackp); 2237 yycompressStack (yystackp); 2238 2239 /* Now pop stack until we find a state that shifts the error token. */ 2240 yystackp->yyerrState = 3; 2241 while (yystackp->yytops.yystates[0] != NULL) 2242 { 2243 yyGLRState *yys = yystackp->yytops.yystates[0]; 2244 yyj = yypact[yys->yylrState]; 2245 if (! yyis_pact_ninf (yyj)) 2246 { 2247 yyj += YYTERROR; 2248 if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR 2249 && yyisShiftAction (yytable[yyj])) 2250 { 2251 /* Shift the error token having adjusted its location. */ 2252 YYLTYPE yyerrloc;]b4_locations_if([[ 2253 yystackp->yyerror_range[2].yystate.yyloc = yylloc; 2254 YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ 2255 YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], 2256 &yylval, &yyerrloc); 2257 yyglrShift (yystackp, 0, yytable[yyj], 2258 yys->yyposn, &yylval, &yyerrloc); 2259 yys = yystackp->yytops.yystates[0]; 2260 break; 2261 } 2262 } 2263 ]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ 2264 yydestroyGLRState ("Error: popping", yys]b4_user_args[); 2265 yystackp->yytops.yystates[0] = yys->yypred; 2266 yystackp->yynextFree -= 1; 2267 yystackp->yyspaceLeft += 1; 2268 } 2269 if (yystackp->yytops.yystates[0] == NULL) 2270 yyFail (yystackp][]b4_lpure_args[, NULL); 2271 } 2272 2273 #define YYCHK1(YYE) \ 2274 do { \ 2275 switch (YYE) { \ 2276 case yyok: \ 2277 break; \ 2278 case yyabort: \ 2279 goto yyabortlab; \ 2280 case yyaccept: \ 2281 goto yyacceptlab; \ 2282 case yyerr: \ 2283 goto yyuser_error; \ 2284 default: \ 2285 goto yybuglab; \ 2286 } \ 2287 } while (YYID (0)) 2288 2289 2290 /*----------. 2291 | yyparse. | 2292 `----------*/ 2293 2294 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[ 2295 { 2296 int yyresult; 2297 yyGLRStack yystack; 2298 yyGLRStack* const yystackp = &yystack; 2299 size_t yyposn; 2300 2301 YYDPRINTF ((stderr, "Starting parse\n")); 2302 2303 yychar = YYEMPTY; 2304 yylval = yyval_default; 2305 ]b4_locations_if([ 2306 #if YYLTYPE_IS_TRIVIAL 2307 yylloc.first_line = yylloc.last_line = 1; 2308 yylloc.first_column = yylloc.last_column = 0; 2309 #endif 2310 ]) 2311 m4_ifdef([b4_initial_action], [ 2312 m4_pushdef([b4_at_dollar], [yylloc])dnl 2313 m4_pushdef([b4_dollar_dollar], [yylval])dnl 2314 /* User initialization code. */ 2315 b4_initial_action 2316 m4_popdef([b4_dollar_dollar])dnl 2317 m4_popdef([b4_at_dollar])dnl 2318 /* Line __line__ of glr.c. */ 2319 b4_syncline([@oline@], [@ofile@])])dnl 2320 [ 2321 if (! yyinitGLRStack (yystackp, YYINITDEPTH)) 2322 goto yyexhaustedlab; 2323 switch (YYSETJMP (yystack.yyexception_buffer)) 2324 { 2325 case 0: break; 2326 case 1: goto yyabortlab; 2327 case 2: goto yyexhaustedlab; 2328 default: goto yybuglab; 2329 } 2330 yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc); 2331 yyposn = 0; 2332 2333 while (YYID (yytrue)) 2334 { 2335 /* For efficiency, we have two loops, the first of which is 2336 specialized to deterministic operation (single stack, no 2337 potential ambiguity). */ 2338 /* Standard mode */ 2339 while (YYID (yytrue)) 2340 { 2341 yyRuleNum yyrule; 2342 int yyaction; 2343 const short int* yyconflicts; 2344 2345 yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; 2346 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2347 if (yystate == YYFINAL) 2348 goto yyacceptlab; 2349 if (yyisDefaultedState (yystate)) 2350 { 2351 yyrule = yydefaultAction (yystate); 2352 if (yyrule == 0) 2353 { 2354 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ 2355 yyreportSyntaxError (&yystack]b4_user_args[); 2356 goto yyuser_error; 2357 } 2358 YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[)); 2359 } 2360 else 2361 { 2362 yySymbol yytoken; 2363 if (yychar == YYEMPTY) 2364 { 2365 YYDPRINTF ((stderr, "Reading a token: ")); 2366 yychar = YYLEX; 2367 yytoken = YYTRANSLATE (yychar); 2368 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2369 } 2370 else 2371 yytoken = YYTRANSLATE (yychar); 2372 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); 2373 if (*yyconflicts != 0) 2374 break; 2375 if (yyisShiftAction (yyaction)) 2376 { 2377 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2378 if (yychar != YYEOF) 2379 yychar = YYEMPTY; 2380 yyposn += 1; 2381 yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc); 2382 if (0 < yystack.yyerrState) 2383 yystack.yyerrState -= 1; 2384 } 2385 else if (yyisErrorAction (yyaction)) 2386 { 2387 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ 2388 yyreportSyntaxError (&yystack]b4_user_args[); 2389 goto yyuser_error; 2390 } 2391 else 2392 YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); 2393 } 2394 } 2395 2396 while (YYID (yytrue)) 2397 { 2398 yySymbol yytoken_to_shift; 2399 size_t yys; 2400 2401 for (yys = 0; yys < yystack.yytops.yysize; yys += 1) 2402 yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY; 2403 2404 /* yyprocessOneStack returns one of three things: 2405 2406 - An error flag. If the caller is yyprocessOneStack, it 2407 immediately returns as well. When the caller is finally 2408 yyparse, it jumps to an error label via YYCHK1. 2409 2410 - yyok, but yyprocessOneStack has invoked yymarkStackDeleted 2411 (&yystack, yys), which sets the top state of yys to NULL. Thus, 2412 yyparse's following invocation of yyremoveDeletes will remove 2413 the stack. 2414 2415 - yyok, when ready to shift a token. 2416 2417 Except in the first case, yyparse will invoke yyremoveDeletes and 2418 then shift the next token onto all remaining stacks. This 2419 synchronization of the shift (that is, after all preceding 2420 reductions on all stacks) helps prevent double destructor calls 2421 on yylval in the event of memory exhaustion. */ 2422 2423 for (yys = 0; yys < yystack.yytops.yysize; yys += 1) 2424 YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[)); 2425 yyremoveDeletes (&yystack); 2426 if (yystack.yytops.yysize == 0) 2427 { 2428 yyundeleteLastStack (&yystack); 2429 if (yystack.yytops.yysize == 0) 2430 yyFail (&yystack][]b4_lpure_args[, YY_("syntax error")); 2431 YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); 2432 YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); 2433 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ 2434 yyreportSyntaxError (&yystack]b4_user_args[); 2435 goto yyuser_error; 2436 } 2437 2438 /* If any yyglrShift call fails, it will fail after shifting. Thus, 2439 a copy of yylval will already be on stack 0 in the event of a 2440 failure in the following loop. Thus, yychar is set to YYEMPTY 2441 before the loop to make sure the user destructor for yylval isn't 2442 called twice. */ 2443 yytoken_to_shift = YYTRANSLATE (yychar); 2444 yychar = YYEMPTY; 2445 yyposn += 1; 2446 for (yys = 0; yys < yystack.yytops.yysize; yys += 1) 2447 { 2448 int yyaction; 2449 const short int* yyconflicts; 2450 yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState; 2451 yygetLRActions (yystate, yytoken_to_shift, &yyaction, 2452 &yyconflicts); 2453 /* Note that yyconflicts were handled by yyprocessOneStack. */ 2454 YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys)); 2455 YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); 2456 yyglrShift (&yystack, yys, yyaction, yyposn, 2457 &yylval, &yylloc); 2458 YYDPRINTF ((stderr, "Stack %lu now in state #%d\n", 2459 (unsigned long int) yys, 2460 yystack.yytops.yystates[yys]->yylrState)); 2461 } 2462 2463 if (yystack.yytops.yysize == 1) 2464 { 2465 YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); 2466 YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); 2467 yycompressStack (&yystack); 2468 break; 2469 } 2470 } 2471 continue; 2472 yyuser_error: 2473 yyrecoverSyntaxError (&yystack]b4_user_args[); 2474 yyposn = yystack.yytops.yystates[0]->yyposn; 2475 } 2476 2477 yyacceptlab: 2478 yyresult = 0; 2479 goto yyreturn; 2480 2481 yybuglab: 2482 YYASSERT (yyfalse); 2483 goto yyabortlab; 2484 2485 yyabortlab: 2486 yyresult = 1; 2487 goto yyreturn; 2488 2489 yyexhaustedlab: 2490 yyerror (]b4_lyyerror_args[YY_("memory exhausted")); 2491 yyresult = 2; 2492 goto yyreturn; 2493 2494 yyreturn: 2495 if (yychar != YYEOF && yychar != YYEMPTY) 2496 yydestruct ("Cleanup: discarding lookahead", 2497 YYTRANSLATE (yychar), 2498 &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); 2499 2500 /* If the stack is well-formed, pop the stack until it is empty, 2501 destroying its entries as we go. But free the stack regardless 2502 of whether it is well-formed. */ 2503 if (yystack.yyitems) 2504 { 2505 yyGLRState** yystates = yystack.yytops.yystates; 2506 if (yystates) 2507 { 2508 size_t yysize = yystack.yytops.yysize; 2509 size_t yyk; 2510 for (yyk = 0; yyk < yysize; yyk += 1) 2511 if (yystates[yyk]) 2512 { 2513 while (yystates[yyk]) 2514 { 2515 yyGLRState *yys = yystates[yyk]; 2516 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] 2517 )[ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); 2518 yystates[yyk] = yys->yypred; 2519 yystack.yynextFree -= 1; 2520 yystack.yyspaceLeft += 1; 2521 } 2522 break; 2523 } 2524 } 2525 yyfreeGLRStack (&yystack); 2526 } 2527 2528 /* Make sure YYID is used. */ 2529 return YYID (yyresult); 2530 } 2531 2532 /* DEBUGGING ONLY */ 2533 #ifdef YYDEBUG 2534 static void yypstack (yyGLRStack* yystackp, size_t yyk) 2535 __attribute__ ((__unused__)); 2536 static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__)); 2537 2538 static void 2539 yy_yypstack (yyGLRState* yys) 2540 { 2541 if (yys->yypred) 2542 { 2543 yy_yypstack (yys->yypred); 2544 fprintf (stderr, " -> "); 2545 } 2546 fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn); 2547 } 2548 2549 static void 2550 yypstates (yyGLRState* yyst) 2551 { 2552 if (yyst == NULL) 2553 fprintf (stderr, "<null>"); 2554 else 2555 yy_yypstack (yyst); 2556 fprintf (stderr, "\n"); 2557 } 2558 2559 static void 2560 yypstack (yyGLRStack* yystackp, size_t yyk) 2561 { 2562 yypstates (yystackp->yytops.yystates[yyk]); 2563 } 2564 2565 #define YYINDEX(YYX) \ 2566 ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems) 2567 2568 2569 static void 2570 yypdumpstack (yyGLRStack* yystackp) 2571 { 2572 yyGLRStackItem* yyp; 2573 size_t yyi; 2574 for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1) 2575 { 2576 fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystackp->yyitems)); 2577 if (*(yybool *) yyp) 2578 { 2579 fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld", 2580 yyp->yystate.yyresolved, yyp->yystate.yylrState, 2581 (unsigned long int) yyp->yystate.yyposn, 2582 (long int) YYINDEX (yyp->yystate.yypred)); 2583 if (! yyp->yystate.yyresolved) 2584 fprintf (stderr, ", firstVal: %ld", 2585 (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); 2586 } 2587 else 2588 { 2589 fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld", 2590 yyp->yyoption.yyrule - 1, 2591 (long int) YYINDEX (yyp->yyoption.yystate), 2592 (long int) YYINDEX (yyp->yyoption.yynext)); 2593 } 2594 fprintf (stderr, "\n"); 2595 } 2596 fprintf (stderr, "Tops:"); 2597 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) 2598 fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi, 2599 (long int) YYINDEX (yystackp->yytops.yystates[yyi])); 2600 fprintf (stderr, "\n"); 2601 } 2602 #endif 2603 ] 2604 2605 b4_epilogue 2606 b4_defines_if( 2607 [@output @output_header_name@ 2608 b4_copyright([Skeleton interface for Bison GLR parsers in C], 2609 [2002, 2003, 2004, 2005, 2006]) 2610 2611 b4_shared_declarations 2612 2613 extern YYSTYPE b4_prefix[]lval; 2614 2615 b4_locations_if([b4_pure_if([], 2616 [extern YYLTYPE b4_prefix[]lloc;]) 2617 ]) 2618 ]) 2619
