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