3 # GLR skeleton for Bison
5 # Copyright (C) 2002-2012 Free Software Foundation, Inc.
7 # This program is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation, either version 3 of the License, or
10 # (at your option) any later version.
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU General Public License for more details.
17 # You should have received a copy of the GNU General Public License
18 # along with this program. If not, see <http://www.gnu.org/licenses/>.
21 # If we are loaded by glr.cc, do not override c++.m4 definitions by
23 m4_if(b4_skeleton
, ["glr.c"],
24 [m4_include(b4_pkgdatadir
/[c
.m4
])])
26 ## ---------------- ##
28 ## ---------------- ##
31 m4_define_default([b4_stack_depth_max
], [10000])
32 m4_define_default([b4_stack_depth_init
], [200])
36 ## ------------------------ ##
37 ## Pure/impure interfaces. ##
38 ## ------------------------ ##
40 b4_define_flag_if([pure
])
41 # If glr.cc is including this file and thus has already set b4_pure_flag,
42 # do not change the value of b4_pure_flag, and do not record a use of api.pure.
43 m4_ifndef([b4_pure_flag
],
44 [b4_percent_define_default([[api
.pure
]], [[false]])
45 m4_define([b4_pure_flag
],
46 [b4_percent_define_flag_if([[api
.pure
]], [[1]], [[0]])])])
50 # The possible parse-params formal arguments preceded by a comma.
52 # This is not shared with yacc.c in c.m4 because GLR relies on ISO C
53 # formal argument declarations.
54 m4_define([b4_user_formals
],
55 [m4_ifset([b4_parse_param
], [, b4_formals(b4_parse_param
)])])
60 # Optional effective arguments passed to yyerror: user args plus yylloc, and
62 m4_define([b4_yyerror_args
],
63 [b4_pure_if([b4_locations_if([yylocp
, ])])dnl
64 m4_ifset([b4_parse_param
], [b4_args(b4_parse_param
), ])])
69 # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
70 m4_define([b4_lyyerror_args
],
71 [b4_pure_if([b4_locations_if([&yylloc
, ])])dnl
72 m4_ifset([b4_parse_param
], [b4_args(b4_parse_param
), ])])
77 # Same as b4_yyerror_args, but with a leading comma.
78 m4_define([b4_pure_args
],
79 [b4_pure_if([b4_locations_if([, yylocp
])])[]b4_user_args
])
84 # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
85 m4_define([b4_lpure_args
],
86 [b4_pure_if([b4_locations_if([, &yylloc
])])[]b4_user_args
])
92 # Arguments passed to yyerror: user formals plus yylocp with leading comma.
93 m4_define([b4_pure_formals
],
94 [b4_pure_if([b4_locations_if([, YYLTYPE
*yylocp
])])[]b4_user_formals
])
97 # b4_locuser_formals(LOC = yylocp)
98 # --------------------------------
99 m4_define([b4_locuser_formals
],
100 [b4_locations_if([, YYLTYPE
*m4_default([$
1], [yylocp
])])[]b4_user_formals
])
103 # b4_locuser_args(LOC = yylocp)
104 # -----------------------------
105 m4_define([b4_locuser_args
],
106 [b4_locations_if([, m4_default([$
1], [yylocp
])])[]b4_user_args
])
110 ## ----------------- ##
111 ## Semantic Values. ##
112 ## ----------------- ##
115 # b4_lhs_value([TYPE])
116 # --------------------
117 # Expansion of $<TYPE>$.
118 m4_define([b4_lhs_value
],
119 [b4_symbol_value([(*yyvalp
)], [$
1])])
122 # b4_rhs_data(RULE-LENGTH, NUM)
123 # -----------------------------
124 # Expand to the semantic stack place that contains value and location
125 # of symbol number NUM in a rule of length RULE-LENGTH.
126 m4_define([b4_rhs_data
],
127 [((yyGLRStackItem
const *)yyvsp
)@
{YYFILL (b4_subtract([$
2], [$
1]))@
}.yystate
])
130 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
131 # --------------------------------------
132 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
134 m4_define([b4_rhs_value
],
135 [b4_symbol_value([b4_rhs_data([$
1], [$
2]).yysemantics
.yysval
], [$
3])])
146 m4_define([b4_lhs_location
],
150 # b4_rhs_location(RULE-LENGTH, NUM)
151 # ---------------------------------
152 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
154 m4_define([b4_rhs_location
],
155 [(b4_rhs_data([$
1], [$
2]).yyloc
)])
162 # b4_shared_declarations
163 # ----------------------
164 # Declaration that might either go into the header (if --defines)
165 # or open coded in the parser body. glr.cc has its own definition.
166 m4_if(b4_skeleton
, ["glr.c"],
167 [m4_define([b4_shared_declarations
],
169 ]b4_percent_code_get([[requires]])[
171 ]b4_declare_yylstype
[
172 ]b4_function_declare(b4_prefix
[parse
], [int], b4_parse_param
)[
173 ]b4_percent_code_get([[provides]])[]dnl
181 b4_output_begin([b4_parser_file_name
])
182 b4_copyright([Skeleton implementation
for Bison GLR parsers in C
],
185 /* C GLR parser skeleton written by Paul Hilfinger. */
189 b4_percent_code_get([[top]])[
190 ]m4_if(b4_api_prefix
, [yy
], [],
191 [[/* Substitute the type names. */
192 #define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[
193 #define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[
194 ]m4_if(b4_prefix
, [yy
], [],
195 [[/* Substitute the variable and function names. */
196 #define yyparse ]b4_prefix[parse
197 #define yylex ]b4_prefix[lex
198 #define yyerror ]b4_prefix[error
199 #define yylval ]b4_prefix[lval
200 #define yychar ]b4_prefix[char
201 #define yydebug ]b4_prefix[debug
202 #define yynerrs ]b4_prefix[nerrs]b4_locations_if([[
203 #define yylloc ]b4_prefix[lloc]])])[
205 /* First part of user declarations. */
206 ]b4_user_pre_prologue
[
210 ]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
211 [b4_shared_declarations
])[
213 /* Enabling verbose error messages. */
214 #ifdef YYERROR_VERBOSE
215 # undef YYERROR_VERBOSE
216 # define YYERROR_VERBOSE 1
218 # define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
221 /* Default (constant) value used for initialization for null
222 right-hand sides. Unlike the standard yacc.c template, here we set
223 the default value of $$ to a zeroed-out value. Since the default
224 value is undefined, this behavior is technically correct. */
225 static YYSTYPE yyval_default
;]b4_locations_if([[
226 static YYLTYPE yyloc_default
][]b4_yyloc_default
;])[
228 /* Copy the second part of user declarations. */
229 ]b4_user_post_prologue
230 b4_percent_code_get
[]dnl
237 # if defined YYENABLE_NLS && YYENABLE_NLS
239 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
240 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
244 # define YY_(Msgid) Msgid
248 /* Suppress unused-variable warnings by "using" E. */
250 # define YYUSE(E) ((void) (E))
252 # define YYUSE(E) /* empty */
259 # define YYMALLOC malloc
262 # define YYREALLOC realloc
265 #define YYSIZEMAX ((size_t) -1)
270 typedef unsigned char yybool
;
277 # define YYJMP_BUF jmp_buf
278 # define YYSETJMP(Env) setjmp (Env)
280 # define YYLONGJMP(Env, Val) (longjmp (Env, Val), YYASSERT (0))
287 #ifndef __attribute__
288 /* This feature is available in gcc versions 2.5 and later. */
289 # if (! defined __GNUC__ || __GNUC__ < 2 \
290 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
291 # define __attribute__(Spec) /* empty */
296 # define YYASSERT(Condition) ((void) ((Condition) || (abort (), 0)))
299 /* YYFINAL -- State number of the termination state. */
300 #define YYFINAL ]b4_final_state_number[
301 /* YYLAST -- Last index in YYTABLE. */
302 #define YYLAST ]b4_last[
304 /* YYNTOKENS -- Number of terminals. */
305 #define YYNTOKENS ]b4_tokens_number[
306 /* YYNNTS -- Number of nonterminals. */
307 #define YYNNTS ]b4_nterms_number[
308 /* YYNRULES -- Number of rules. */
309 #define YYNRULES ]b4_rules_number[
310 /* YYNRULES -- Number of states. */
311 #define YYNSTATES ]b4_states_number[
312 /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
313 #define YYMAXRHS ]b4_r2_max[
314 /* YYMAXLEFT -- Maximum number of symbols to the left of a handle
315 accessed by $0, $-1, etc., in any rule. */
316 #define YYMAXLEFT ]b4_max_left_semantic_context[
318 /* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */
319 #define YYUNDEFTOK ]b4_undef_token_number[
320 #define YYMAXUTOK ]b4_user_token_number_max[
322 #define YYTRANSLATE(YYX) \
323 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
325 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
326 static const ]b4_int_type_for([b4_translate
])[ yytranslate
[] =
331 #if ]b4_api_PREFIX[DEBUG
332 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
333 static const ]b4_int_type_for([b4_rline
])[ yyrline
[] =
339 #if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[
340 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
341 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
342 static const char *const yytname
[] =
348 #define YYPACT_NINF ]b4_pact_ninf[
349 #define YYTABLE_NINF ]b4_table_ninf[
351 ]b4_parser_tables_define
[
353 /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */
354 static const ]b4_int_type_for([b4_dprec
])[ yydprec
[] =
359 /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */
360 static const ]b4_int_type_for([b4_merger
])[ yymerger
[] =
365 /* YYIMMEDIATE[RULE-NUM] -- True iff rule #RULE-NUM is not to be deferred, as
366 in the case of predicates. */
367 static const yybool yyimmediate
[] =
372 /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of
373 list of conflicting reductions corresponding to action entry for
374 state STATE-NUM in yytable. 0 means no conflicts. The list in
375 yyconfl is terminated by a rule number of 0. */
376 static const ]b4_int_type_for([b4_conflict_list_heads
])[ yyconflp
[] =
378 ]b4_conflict_list_heads
[
381 /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
382 0, pointed into by YYCONFLP. */
383 ]dnl Do
not use b4_int_type_for here
, since there are places where
384 dnl pointers onto yyconfl are taken
, whose type is
"short int *".
385 dnl We probably ought to introduce a type
for confl
.
386 [static const short int yyconfl
[] =
388 ]b4_conflicting_rules
[
391 /* Error token number */
395 ]b4_yylloc_default_define
[
396 # define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
398 ]b4_yy_location_print_define
[
403 #define yynerrs (yystackp->yyerrcnt)
405 #define yychar (yystackp->yyrawchar)
407 #define yylval (yystackp->yyval)
409 #define yylloc (yystackp->yyloc)
410 m4_if(b4_prefix
[], [yy
], [],
411 [#define b4_prefix[]nerrs yynerrs
412 #define b4_prefix[]char yychar
413 #define b4_prefix[]lval yylval
414 #define b4_prefix[]lloc yylloc])],
415 [YYSTYPE yylval
;]b4_locations_if([[
421 static const int YYEOF
= 0;
422 static const int YYEMPTY
= -2;
424 typedef enum { yyok
, yyaccept
, yyabort
, yyerr
} YYRESULTTAG
;
428 YYRESULTTAG yychk_flag = YYE; \
429 if (yychk_flag != yyok) \
433 #if ]b4_api_PREFIX[DEBUG
436 # define YYFPRINTF fprintf
439 # define YYDPRINTF(Args) \
445 ]b4_yy_symbol_print_define
[
447 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
451 YYFPRINTF (stderr, "%s ", Title); \
452 yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \
453 YYFPRINTF (stderr, "\n"); \
457 /* Nonzero means print parse trace. It is left uninitialized so that
458 multiple parsers can coexist. */
462 static void yypstack (struct yyGLRStack
* yystackp
, size_t yyk
)
463 __attribute__ ((__unused__
));
464 static void yypdumpstack (struct yyGLRStack
* yystackp
)
465 __attribute__ ((__unused__
));
467 #else /* !]b4_api_PREFIX[DEBUG */
469 # define YYDPRINTF(Args)
470 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
472 #endif /* !]b4_api_PREFIX[DEBUG */
474 /* YYINITDEPTH -- initial size of the parser's stacks. */
476 # define YYINITDEPTH ]b4_stack_depth_init[
479 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
480 if the built-in stack extension method is used).
482 Do not make this value too large; the results are undefined if
483 SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem)
484 evaluated with infinite-precision integer arithmetic. */
487 # define YYMAXDEPTH ]b4_stack_depth_max[
490 /* Minimum number of free items on the stack allowed after an
491 allocation. This is to allow allocation and initialization
492 to be completed by functions that call yyexpandGLRStack before the
493 stack is expanded, thus insuring that all necessary pointers get
494 properly redirected to new data. */
497 #ifndef YYSTACKEXPANDABLE
498 # define YYSTACKEXPANDABLE 1
501 #if YYSTACKEXPANDABLE
502 # define YY_RESERVE_GLRSTACK(Yystack) \
504 if (Yystack->yyspaceLeft < YYHEADROOM) \
505 yyexpandGLRStack (Yystack); \
508 # define YY_RESERVE_GLRSTACK(Yystack) \
510 if (Yystack->yyspaceLeft < YYHEADROOM) \
511 yyMemoryExhausted (Yystack); \
519 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
520 # define yystpcpy stpcpy
522 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
525 yystpcpy (char *yydest
, const char *yysrc
)
528 const char *yys
= yysrc
;
530 while ((*yyd
++ = *yys
++) != '\0')
539 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
540 quotes and backslashes, so that it's suitable for yyerror. The
541 heuristic is that double-quoting is unnecessary unless the string
542 contains an apostrophe, a comma, or backslash (other than
543 backslash-backslash). YYSTR is taken from yytname. If YYRES is
544 null, do not copy; instead, return the length of what the result
547 yytnamerr (char *yyres
, const char *yystr
)
552 char const *yyp
= yystr
;
559 goto do_not_strip_quotes
;
563 goto do_not_strip_quotes
;
576 do_not_strip_quotes
: ;
580 return strlen (yystr
);
582 return yystpcpy (yyres
, yystr
) - yyres
;
586 #endif /* !YYERROR_VERBOSE */
588 /** State numbers, as in LALR(1) machine */
589 typedef int yyStateNum
;
591 /** Rule numbers, as in LALR(1) machine */
592 typedef int yyRuleNum
;
594 /** Grammar symbol */
595 typedef int yySymbol
;
597 /** Item references, as in LALR(1) machine */
598 typedef short int yyItemNum
;
600 typedef struct yyGLRState yyGLRState
;
601 typedef struct yyGLRStateSet yyGLRStateSet
;
602 typedef struct yySemanticOption yySemanticOption
;
603 typedef union yyGLRStackItem yyGLRStackItem
;
604 typedef struct yyGLRStack yyGLRStack
;
607 /** Type tag: always true. */
609 /** Type tag for yysemantics. If true, yysval applies, otherwise
610 * yyfirstVal applies. */
612 /** Number of corresponding LALR(1) machine state. */
613 yyStateNum yylrState
;
614 /** Preceding state in this stack */
616 /** Source position of the last token produced by my symbol */
619 /** First in a chain of alternative reductions producing the
620 * non-terminal corresponding to this state, threaded through
622 yySemanticOption
* yyfirstVal
;
623 /** Semantic value for this state. */
625 } yysemantics
;]b4_locations_if([[
626 /** Source location for this state. */
630 struct yyGLRStateSet
{
631 yyGLRState
** yystates
;
632 /** During nondeterministic operation, yylookaheadNeeds tracks which
633 * stacks have actually needed the current lookahead. During deterministic
634 * operation, yylookaheadNeeds[0] is not maintained since it would merely
635 * duplicate yychar != YYEMPTY. */
636 yybool
* yylookaheadNeeds
;
637 size_t yysize
, yycapacity
;
640 struct yySemanticOption
{
641 /** Type tag: always false. */
643 /** Rule number for this reduction */
645 /** The last RHS state in the list of states to be reduced. */
647 /** The lookahead for this reduction. */
649 YYSTYPE yyval
;]b4_locations_if([[
651 /** Next sibling in chain of options. To facilitate merging,
652 * options are chained in decreasing order by address. */
653 yySemanticOption
* yynext
;
656 /** Type of the items in the GLR stack. The yyisState field
657 * indicates which item of the union is valid. */
658 union yyGLRStackItem
{
660 yySemanticOption yyoption
;
665 ]b4_locations_if([[ /* To compute the location of the error token. */
666 yyGLRStackItem yyerror_range
[3];]])[
671 YYSTYPE yyval
;]b4_locations_if([[
674 YYJMP_BUF yyexception_buffer
;
675 yyGLRStackItem
* yyitems
;
676 yyGLRStackItem
* yynextFree
;
678 yyGLRState
* yysplitPoint
;
679 yyGLRState
* yylastDeleted
;
680 yyGLRStateSet yytops
;
683 #if YYSTACKEXPANDABLE
684 static void yyexpandGLRStack (yyGLRStack
* yystackp
);
687 static void yyFail (yyGLRStack
* yystackp
]b4_pure_formals
[, const char* yymsg
)
688 __attribute__ ((__noreturn__
));
690 yyFail (yyGLRStack
* yystackp
]b4_pure_formals
[, const char* yymsg
)
692 if (yymsg
!= YY_NULL
)
693 yyerror (]b4_yyerror_args
[yymsg
);
694 YYLONGJMP (yystackp
->yyexception_buffer
, 1);
697 static void yyMemoryExhausted (yyGLRStack
* yystackp
)
698 __attribute__ ((__noreturn__
));
700 yyMemoryExhausted (yyGLRStack
* yystackp
)
702 YYLONGJMP (yystackp
->yyexception_buffer
, 2);
705 #if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE
706 /** A printable representation of TOKEN. */
707 static inline const char*
708 yytokenName (yySymbol yytoken
)
710 if (yytoken
== YYEMPTY
)
713 return yytname
[yytoken
];
717 /** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting
718 * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred
719 * containing the pointer to the next state in the chain. */
720 static void yyfillin (yyGLRStackItem
*, int, int) __attribute__ ((__unused__
));
722 yyfillin (yyGLRStackItem
*yyvsp
, int yylow0
, int yylow1
)
725 yyGLRState
*s
= yyvsp
[yylow0
].yystate
.yypred
;
726 for (i
= yylow0
-1; i
>= yylow1
; i
-= 1)
728 #if ]b4_api_PREFIX[DEBUG
729 yyvsp
[i
].yystate
.yylrState
= s
->yylrState
;
731 yyvsp
[i
].yystate
.yyresolved
= s
->yyresolved
;
733 yyvsp
[i
].yystate
.yysemantics
.yysval
= s
->yysemantics
.yysval
;
735 /* The effect of using yysval or yyloc (in an immediate rule) is
737 yyvsp
[i
].yystate
.yysemantics
.yyfirstVal
= YY_NULL
;]b4_locations_if([[
738 yyvsp
[i
].yystate
.yyloc
= s
->yyloc
;]])[
739 s
= yyvsp
[i
].yystate
.yypred
= s
->yypred
;
743 /* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in
744 * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1.
745 * For convenience, always return YYLOW1. */
746 static inline int yyfill (yyGLRStackItem
*, int *, int, yybool
)
747 __attribute__ ((__unused__
));
749 yyfill (yyGLRStackItem
*yyvsp
, int *yylow
, int yylow1
, yybool yynormal
)
751 if (!yynormal
&& yylow1
< *yylow
)
753 yyfillin (yyvsp
, *yylow
, yylow1
);
759 /** Perform user action for rule number YYN, with RHS length YYRHSLEN,
760 * and top stack item YYVSP. YYLVALP points to place to put semantic
761 * value ($$), and yylocp points to place for location information
762 * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT,
763 * yyerr for YYERROR, yyabort for YYABORT. */
765 yyuserAction (yyRuleNum yyn
, int yyrhslen
, yyGLRStackItem
* yyvsp
,
766 yyGLRStack
* yystackp
,
767 YYSTYPE
* yyvalp
]b4_locuser_formals
[)
769 yybool yynormal
__attribute__ ((__unused__
)) =
770 (yystackp
->yysplitPoint
== YY_NULL
);
772 ]b4_parse_param_use([yyvalp
], [yylocp
])dnl
774 # define yyerrok (yystackp->yyerrState = 0)
776 # define YYACCEPT return yyaccept
778 # define YYABORT return yyabort
780 # define YYERROR return yyerrok, yyerr
782 # define YYRECOVERING() (yystackp->yyerrState != 0)
784 # define yyclearin (yychar = YYEMPTY)
786 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
788 # define YYBACKUP(Token, Value) \
789 return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \
794 *yyvalp
= yyval_default
;
796 *yyvalp
= yyvsp
[YYFILL (1-yyrhslen
)].yystate
.yysemantics
.yysval
;]b4_locations_if([[
797 YYLLOC_DEFAULT ((*yylocp
), (yyvsp
- yyrhslen
), yyrhslen
);
798 yystackp
->yyerror_range
[1].yystate
.yyloc
= *yylocp
;
818 yyuserMerge (int yyn
, YYSTYPE
* yy0
, YYSTYPE
* yy1
)
830 /* Bison grammar-table manipulation. */
832 ]b4_yydestruct_define
[
834 /** Number of symbols composing the right hand side of rule #RULE. */
836 yyrhsLength (yyRuleNum yyrule
)
842 yydestroyGLRState (char const *yymsg
, yyGLRState
*yys
]b4_user_formals
[)
845 yydestruct (yymsg
, yystos
[yys
->yylrState
],
846 &yys
->yysemantics
.yysval
]b4_locuser_args([&yys
->yyloc
])[);
849 #if ]b4_api_PREFIX[DEBUG
852 if (yys
->yysemantics
.yyfirstVal
)
853 YYFPRINTF (stderr
, "%s unresolved ", yymsg
);
855 YYFPRINTF (stderr
, "%s incomplete ", yymsg
);
856 yy_symbol_print (stderr
, yystos
[yys
->yylrState
],
857 YY_NULL
]b4_locuser_args([&yys
->yyloc
])[);
858 YYFPRINTF (stderr
, "\n");
862 if (yys
->yysemantics
.yyfirstVal
)
864 yySemanticOption
*yyoption
= yys
->yysemantics
.yyfirstVal
;
867 for (yyrh
= yyoption
->yystate
, yyn
= yyrhsLength (yyoption
->yyrule
);
869 yyrh
= yyrh
->yypred
, yyn
-= 1)
870 yydestroyGLRState (yymsg
, yyrh
]b4_user_args
[);
875 /** Left-hand-side symbol for rule #YYRULE. */
876 static inline yySymbol
877 yylhsNonterm (yyRuleNum yyrule
)
882 #define yypact_value_is_default(Yystate) \
883 ]b4_table_value_equals([[pact]], [[Yystate]], [b4_pact_ninf])[
885 /** True iff LR state YYSTATE has only a default reduction (regardless
888 yyisDefaultedState (yyStateNum yystate
)
890 return yypact_value_is_default (yypact
[yystate
]);
893 /** The default reduction for YYSTATE, assuming it has one. */
894 static inline yyRuleNum
895 yydefaultAction (yyStateNum yystate
)
897 return yydefact
[yystate
];
900 #define yytable_value_is_error(Yytable_value) \
901 ]b4_table_value_equals([[table]], [[Yytable_value]], [b4_table_ninf])[
903 /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
905 * R < 0: Reduce on rule -R.
907 * R > 0: Shift to state R.
908 * Set *YYCONFLICTS to a pointer into yyconfl to a 0-terminated list
909 * of conflicting reductions.
912 yygetLRActions (yyStateNum yystate
, int yytoken
,
913 int* yyaction
, const short int** yyconflicts
)
915 int yyindex
= yypact
[yystate
] + yytoken
;
916 if (yypact_value_is_default (yypact
[yystate
])
917 || yyindex
< 0 || YYLAST
< yyindex
|| yycheck
[yyindex
] != yytoken
)
919 *yyaction
= -yydefact
[yystate
];
920 *yyconflicts
= yyconfl
;
922 else if (! yytable_value_is_error (yytable
[yyindex
]))
924 *yyaction
= yytable
[yyindex
];
925 *yyconflicts
= yyconfl
+ yyconflp
[yyindex
];
930 *yyconflicts
= yyconfl
+ yyconflp
[yyindex
];
934 static inline yyStateNum
935 yyLRgotoState (yyStateNum yystate
, yySymbol yylhs
)
937 int yyr
= yypgoto
[yylhs
- YYNTOKENS
] + yystate
;
938 if (0 <= yyr
&& yyr
<= YYLAST
&& yycheck
[yyr
] == yystate
)
941 return yydefgoto
[yylhs
- YYNTOKENS
];
945 yyisShiftAction (int yyaction
)
951 yyisErrorAction (int yyaction
)
953 return yyaction
== 0;
958 /** Return a fresh GLRStackItem in YYSTACKP. The item is an LR state
959 * if YYISSTATE, and otherwise a semantic option. Callers should call
960 * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient
963 static inline yyGLRStackItem
*
964 yynewGLRStackItem (yyGLRStack
* yystackp
, yybool yyisState
)
966 yyGLRStackItem
* yynewItem
= yystackp
->yynextFree
;
967 yystackp
->yyspaceLeft
-= 1;
968 yystackp
->yynextFree
+= 1;
969 yynewItem
->yystate
.yyisState
= yyisState
;
973 /** Add a new semantic action that will execute the action for rule
974 * YYRULE on the semantic values in YYRHS to the list of
975 * alternative actions for YYSTATE. Assumes that YYRHS comes from
976 * stack #YYK of *YYSTACKP. */
978 yyaddDeferredAction (yyGLRStack
* yystackp
, size_t yyk
, yyGLRState
* yystate
,
979 yyGLRState
* yyrhs
, yyRuleNum yyrule
)
981 yySemanticOption
* yynewOption
=
982 &yynewGLRStackItem (yystackp
, yyfalse
)->yyoption
;
983 yynewOption
->yystate
= yyrhs
;
984 yynewOption
->yyrule
= yyrule
;
985 if (yystackp
->yytops
.yylookaheadNeeds
[yyk
])
987 yynewOption
->yyrawchar
= yychar
;
988 yynewOption
->yyval
= yylval
;]b4_locations_if([
989 yynewOption
->yyloc
= yylloc
;])[
992 yynewOption
->yyrawchar
= YYEMPTY
;
993 yynewOption
->yynext
= yystate
->yysemantics
.yyfirstVal
;
994 yystate
->yysemantics
.yyfirstVal
= yynewOption
;
996 YY_RESERVE_GLRSTACK (yystackp
);
1001 /** Initialize YYSET to a singleton set containing an empty stack. */
1003 yyinitStateSet (yyGLRStateSet
* yyset
)
1006 yyset
->yycapacity
= 16;
1007 yyset
->yystates
= (yyGLRState
**) YYMALLOC (16 * sizeof yyset
->yystates
[0]);
1008 if (! yyset
->yystates
)
1010 yyset
->yystates
[0] = YY_NULL
;
1011 yyset
->yylookaheadNeeds
=
1012 (yybool
*) YYMALLOC (16 * sizeof yyset
->yylookaheadNeeds
[0]);
1013 if (! yyset
->yylookaheadNeeds
)
1015 YYFREE (yyset
->yystates
);
1021 static void yyfreeStateSet (yyGLRStateSet
* yyset
)
1023 YYFREE (yyset
->yystates
);
1024 YYFREE (yyset
->yylookaheadNeeds
);
1027 /** Initialize *YYSTACKP to a single empty stack, with total maximum
1028 * capacity for all stacks of YYSIZE. */
1030 yyinitGLRStack (yyGLRStack
* yystackp
, size_t yysize
)
1032 yystackp
->yyerrState
= 0;
1034 yystackp
->yyspaceLeft
= yysize
;
1036 (yyGLRStackItem
*) YYMALLOC (yysize
* sizeof yystackp
->yynextFree
[0]);
1037 if (!yystackp
->yyitems
)
1039 yystackp
->yynextFree
= yystackp
->yyitems
;
1040 yystackp
->yysplitPoint
= YY_NULL
;
1041 yystackp
->yylastDeleted
= YY_NULL
;
1042 return yyinitStateSet (&yystackp
->yytops
);
1046 #if YYSTACKEXPANDABLE
1047 # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
1048 &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE
1050 /** If *YYSTACKP is expandable, extend it. WARNING: Pointers into the
1051 stack from outside should be considered invalid after this call.
1052 We always expand when there are 1 or fewer items left AFTER an
1053 allocation, so that we can avoid having external pointers exist
1054 across an allocation. */
1056 yyexpandGLRStack (yyGLRStack
* yystackp
)
1058 yyGLRStackItem
* yynewItems
;
1059 yyGLRStackItem
* yyp0
, *yyp1
;
1062 size_t yysize
= yystackp
->yynextFree
- yystackp
->yyitems
;
1063 if (YYMAXDEPTH
- YYHEADROOM
< yysize
)
1064 yyMemoryExhausted (yystackp
);
1065 yynewSize
= 2*yysize
;
1066 if (YYMAXDEPTH
< yynewSize
)
1067 yynewSize
= YYMAXDEPTH
;
1068 yynewItems
= (yyGLRStackItem
*) YYMALLOC (yynewSize
* sizeof yynewItems
[0]);
1070 yyMemoryExhausted (yystackp
);
1071 for (yyp0
= yystackp
->yyitems
, yyp1
= yynewItems
, yyn
= yysize
;
1073 yyn
-= 1, yyp0
+= 1, yyp1
+= 1)
1076 if (*(yybool
*) yyp0
)
1078 yyGLRState
* yys0
= &yyp0
->yystate
;
1079 yyGLRState
* yys1
= &yyp1
->yystate
;
1080 if (yys0
->yypred
!= YY_NULL
)
1082 YYRELOC (yyp0
, yyp1
, yys0
->yypred
, yystate
);
1083 if (! yys0
->yyresolved
&& yys0
->yysemantics
.yyfirstVal
!= YY_NULL
)
1084 yys1
->yysemantics
.yyfirstVal
=
1085 YYRELOC (yyp0
, yyp1
, yys0
->yysemantics
.yyfirstVal
, yyoption
);
1089 yySemanticOption
* yyv0
= &yyp0
->yyoption
;
1090 yySemanticOption
* yyv1
= &yyp1
->yyoption
;
1091 if (yyv0
->yystate
!= YY_NULL
)
1092 yyv1
->yystate
= YYRELOC (yyp0
, yyp1
, yyv0
->yystate
, yystate
);
1093 if (yyv0
->yynext
!= YY_NULL
)
1094 yyv1
->yynext
= YYRELOC (yyp0
, yyp1
, yyv0
->yynext
, yyoption
);
1097 if (yystackp
->yysplitPoint
!= YY_NULL
)
1098 yystackp
->yysplitPoint
= YYRELOC (yystackp
->yyitems
, yynewItems
,
1099 yystackp
->yysplitPoint
, yystate
);
1101 for (yyn
= 0; yyn
< yystackp
->yytops
.yysize
; yyn
+= 1)
1102 if (yystackp
->yytops
.yystates
[yyn
] != YY_NULL
)
1103 yystackp
->yytops
.yystates
[yyn
] =
1104 YYRELOC (yystackp
->yyitems
, yynewItems
,
1105 yystackp
->yytops
.yystates
[yyn
], yystate
);
1106 YYFREE (yystackp
->yyitems
);
1107 yystackp
->yyitems
= yynewItems
;
1108 yystackp
->yynextFree
= yynewItems
+ yysize
;
1109 yystackp
->yyspaceLeft
= yynewSize
- yysize
;
1114 yyfreeGLRStack (yyGLRStack
* yystackp
)
1116 YYFREE (yystackp
->yyitems
);
1117 yyfreeStateSet (&yystackp
->yytops
);
1120 /** Assuming that YYS is a GLRState somewhere on *YYSTACKP, update the
1121 * splitpoint of *YYSTACKP, if needed, so that it is at least as deep as
1124 yyupdateSplit (yyGLRStack
* yystackp
, yyGLRState
* yys
)
1126 if (yystackp
->yysplitPoint
!= YY_NULL
&& yystackp
->yysplitPoint
> yys
)
1127 yystackp
->yysplitPoint
= yys
;
1130 /** Invalidate stack #YYK in *YYSTACKP. */
1132 yymarkStackDeleted (yyGLRStack
* yystackp
, size_t yyk
)
1134 if (yystackp
->yytops
.yystates
[yyk
] != YY_NULL
)
1135 yystackp
->yylastDeleted
= yystackp
->yytops
.yystates
[yyk
];
1136 yystackp
->yytops
.yystates
[yyk
] = YY_NULL
;
1139 /** Undelete the last stack in *YYSTACKP that was marked as deleted. Can
1140 only be done once after a deletion, and only when all other stacks have
1143 yyundeleteLastStack (yyGLRStack
* yystackp
)
1145 if (yystackp
->yylastDeleted
== YY_NULL
|| yystackp
->yytops
.yysize
!= 0)
1147 yystackp
->yytops
.yystates
[0] = yystackp
->yylastDeleted
;
1148 yystackp
->yytops
.yysize
= 1;
1149 YYDPRINTF ((stderr
, "Restoring last deleted stack as stack #0.\n"));
1150 yystackp
->yylastDeleted
= YY_NULL
;
1154 yyremoveDeletes (yyGLRStack
* yystackp
)
1158 while (yyj
< yystackp
->yytops
.yysize
)
1160 if (yystackp
->yytops
.yystates
[yyi
] == YY_NULL
)
1164 YYDPRINTF ((stderr
, "Removing dead stacks.\n"));
1166 yystackp
->yytops
.yysize
-= 1;
1170 yystackp
->yytops
.yystates
[yyj
] = yystackp
->yytops
.yystates
[yyi
];
1171 /* In the current implementation, it's unnecessary to copy
1172 yystackp->yytops.yylookaheadNeeds[yyi] since, after
1173 yyremoveDeletes returns, the parser immediately either enters
1174 deterministic operation or shifts a token. However, it doesn't
1175 hurt, and the code might evolve to need it. */
1176 yystackp
->yytops
.yylookaheadNeeds
[yyj
] =
1177 yystackp
->yytops
.yylookaheadNeeds
[yyi
];
1180 YYDPRINTF ((stderr
, "Rename stack %lu -> %lu.\n",
1181 (unsigned long int) yyi
, (unsigned long int) yyj
));
1189 /** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR
1190 * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic
1191 * value *YYVALP and source location *YYLOCP. */
1193 yyglrShift (yyGLRStack
* yystackp
, size_t yyk
, yyStateNum yylrState
,
1195 YYSTYPE
* yyvalp
]b4_locations_if([, YYLTYPE
* yylocp
])[)
1197 yyGLRState
* yynewState
= &yynewGLRStackItem (yystackp
, yytrue
)->yystate
;
1199 yynewState
->yylrState
= yylrState
;
1200 yynewState
->yyposn
= yyposn
;
1201 yynewState
->yyresolved
= yytrue
;
1202 yynewState
->yypred
= yystackp
->yytops
.yystates
[yyk
];
1203 yynewState
->yysemantics
.yysval
= *yyvalp
;]b4_locations_if([
1204 yynewState
->yyloc
= *yylocp
;])[
1205 yystackp
->yytops
.yystates
[yyk
] = yynewState
;
1207 YY_RESERVE_GLRSTACK (yystackp
);
1210 /** Shift stack #YYK of *YYSTACKP, to a new state corresponding to LR
1211 * state YYLRSTATE, at input position YYPOSN, with the (unresolved)
1212 * semantic value of YYRHS under the action for YYRULE. */
1214 yyglrShiftDefer (yyGLRStack
* yystackp
, size_t yyk
, yyStateNum yylrState
,
1215 size_t yyposn
, yyGLRState
* yyrhs
, yyRuleNum yyrule
)
1217 yyGLRState
* yynewState
= &yynewGLRStackItem (yystackp
, yytrue
)->yystate
;
1219 yynewState
->yylrState
= yylrState
;
1220 yynewState
->yyposn
= yyposn
;
1221 yynewState
->yyresolved
= yyfalse
;
1222 yynewState
->yypred
= yystackp
->yytops
.yystates
[yyk
];
1223 yynewState
->yysemantics
.yyfirstVal
= YY_NULL
;
1224 yystackp
->yytops
.yystates
[yyk
] = yynewState
;
1226 /* Invokes YY_RESERVE_GLRSTACK. */
1227 yyaddDeferredAction (yystackp
, yyk
, yynewState
, yyrhs
, yyrule
);
1230 #if !]b4_api_PREFIX[DEBUG
1231 # define YY_REDUCE_PRINT(Args)
1233 # define YY_REDUCE_PRINT(Args) \
1236 yy_reduce_print Args; \
1239 /*----------------------------------------------------------------------.
1240 | Report that stack #YYK of *YYSTACKP is going to be reduced by YYRULE. |
1241 `----------------------------------------------------------------------*/
1244 yy_reduce_print (int yynormal
, yyGLRStackItem
* yyvsp
, size_t yyk
,
1245 yyRuleNum yyrule
]b4_user_formals
[)
1247 int yynrhs
= yyrhsLength (yyrule
);]b4_locations_if([
1250 YYFPRINTF (stderr
, "Reducing stack %lu by rule %d (line %lu):\n",
1251 (unsigned long int) yyk
, yyrule
- 1,
1252 (unsigned long int) yyrline
[yyrule
]);
1254 yyfillin (yyvsp
, 1, -yynrhs
);
1255 /* The symbols being reduced. */
1256 for (yyi
= 0; yyi
< yynrhs
; yyi
++)
1258 YYFPRINTF (stderr
, " $%d = ", yyi
+ 1);
1259 yy_symbol_print (stderr
,
1260 yystos
[yyvsp
[yyi
- yynrhs
+ 1].yystate
.yylrState
],
1261 &yyvsp
[yyi
- yynrhs
+ 1].yystate
.yysemantics
.yysval
1262 ]b4_locations_if([, &]b4_rhs_location(yynrhs
, yyi
+ 1))[]dnl
1264 if (!yyvsp
[yyi
- yynrhs
+ 1].yystate
.yyresolved
)
1265 YYFPRINTF (stderr
, " (unresolved)");
1266 YYFPRINTF (stderr
, "\n");
1271 /** Pop the symbols consumed by reduction #YYRULE from the top of stack
1272 * #YYK of *YYSTACKP, and perform the appropriate semantic action on their
1273 * semantic values. Assumes that all ambiguities in semantic values
1274 * have been previously resolved. Set *YYVALP to the resulting value,
1275 * and *YYLOCP to the computed location (if any). Return value is as
1276 * for userAction. */
1277 static inline YYRESULTTAG
1278 yydoAction (yyGLRStack
* yystackp
, size_t yyk
, yyRuleNum yyrule
,
1279 YYSTYPE
* yyvalp
]b4_locuser_formals
[)
1281 int yynrhs
= yyrhsLength (yyrule
);
1283 if (yystackp
->yysplitPoint
== YY_NULL
)
1285 /* Standard special case: single stack. */
1286 yyGLRStackItem
* yyrhs
= (yyGLRStackItem
*) yystackp
->yytops
.yystates
[yyk
];
1287 YYASSERT (yyk
== 0);
1288 yystackp
->yynextFree
-= yynrhs
;
1289 yystackp
->yyspaceLeft
+= yynrhs
;
1290 yystackp
->yytops
.yystates
[0] = & yystackp
->yynextFree
[-1].yystate
;
1291 YY_REDUCE_PRINT ((1, yyrhs
, yyk
, yyrule
]b4_user_args
[));
1292 return yyuserAction (yyrule
, yynrhs
, yyrhs
, yystackp
,
1293 yyvalp
]b4_locuser_args
[);
1299 yyGLRStackItem yyrhsVals
[YYMAXRHS
+ YYMAXLEFT
+ 1];
1300 yys
= yyrhsVals
[YYMAXRHS
+ YYMAXLEFT
].yystate
.yypred
1301 = yystackp
->yytops
.yystates
[yyk
];]b4_locations_if([[
1303 /* Set default location. */
1304 yyrhsVals
[YYMAXRHS
+ YYMAXLEFT
- 1].yystate
.yyloc
= yys
->yyloc
;]])[
1305 for (yyi
= 0; yyi
< yynrhs
; yyi
+= 1)
1310 yyupdateSplit (yystackp
, yys
);
1311 yystackp
->yytops
.yystates
[yyk
] = yys
;
1312 YY_REDUCE_PRINT ((0, yyrhsVals
+ YYMAXRHS
+ YYMAXLEFT
- 1, yyk
, yyrule
]b4_user_args
[));
1313 return yyuserAction (yyrule
, yynrhs
, yyrhsVals
+ YYMAXRHS
+ YYMAXLEFT
- 1,
1314 yystackp
, yyvalp
]b4_locuser_args
[);
1318 /** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE,
1319 * and push back on the resulting nonterminal symbol. Perform the
1320 * semantic action associated with YYRULE and store its value with the
1321 * newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently
1322 * unambiguous. Otherwise, store the deferred semantic action with
1323 * the new state. If the new state would have an identical input
1324 * position, LR state, and predecessor to an existing state on the stack,
1325 * it is identified with that existing state, eliminating stack #YYK from
1326 * *YYSTACKP. In this case, the semantic value is
1327 * added to the options for the existing state's semantic value.
1329 static inline YYRESULTTAG
1330 yyglrReduce (yyGLRStack
* yystackp
, size_t yyk
, yyRuleNum yyrule
,
1331 yybool yyforceEval
]b4_user_formals
[)
1333 size_t yyposn
= yystackp
->yytops
.yystates
[yyk
]->yyposn
;
1335 if (yyforceEval
|| yystackp
->yysplitPoint
== YY_NULL
)
1338 YYSTYPE yysval
;]b4_locations_if([
1341 yyflag
= yydoAction (yystackp
, yyk
, yyrule
, &yysval
]b4_locuser_args([&yyloc
])[);
1342 if (yyflag
== yyerr
&& yystackp
->yysplitPoint
!= YY_NULL
)
1344 YYDPRINTF ((stderr
, "Parse on stack %lu rejected by rule #%d.\n",
1345 (unsigned long int) yyk
, yyrule
- 1));
1349 YY_SYMBOL_PRINT ("-> $$ =", yyr1
[yyrule
], &yysval
, &yyloc
);
1350 yyglrShift (yystackp
, yyk
,
1351 yyLRgotoState (yystackp
->yytops
.yystates
[yyk
]->yylrState
,
1352 yylhsNonterm (yyrule
)),
1353 yyposn
, &yysval
]b4_locations_if([, &yyloc
])[);
1359 yyGLRState
* yys
, *yys0
= yystackp
->yytops
.yystates
[yyk
];
1360 yyStateNum yynewLRState
;
1362 for (yys
= yystackp
->yytops
.yystates
[yyk
], yyn
= yyrhsLength (yyrule
);
1368 yyupdateSplit (yystackp
, yys
);
1369 yynewLRState
= yyLRgotoState (yys
->yylrState
, yylhsNonterm (yyrule
));
1371 "Reduced stack %lu by rule #%d; action deferred. "
1372 "Now in state %d.\n",
1373 (unsigned long int) yyk
, yyrule
- 1, yynewLRState
));
1374 for (yyi
= 0; yyi
< yystackp
->yytops
.yysize
; yyi
+= 1)
1375 if (yyi
!= yyk
&& yystackp
->yytops
.yystates
[yyi
] != YY_NULL
)
1377 yyGLRState
*yysplit
= yystackp
->yysplitPoint
;
1378 yyGLRState
*yyp
= yystackp
->yytops
.yystates
[yyi
];
1379 while (yyp
!= yys
&& yyp
!= yysplit
&& yyp
->yyposn
>= yyposn
)
1381 if (yyp
->yylrState
== yynewLRState
&& yyp
->yypred
== yys
)
1383 yyaddDeferredAction (yystackp
, yyk
, yyp
, yys0
, yyrule
);
1384 yymarkStackDeleted (yystackp
, yyk
);
1385 YYDPRINTF ((stderr
, "Merging stack %lu into stack %lu.\n",
1386 (unsigned long int) yyk
,
1387 (unsigned long int) yyi
));
1393 yystackp
->yytops
.yystates
[yyk
] = yys
;
1394 yyglrShiftDefer (yystackp
, yyk
, yynewLRState
, yyposn
, yys0
, yyrule
);
1400 yysplitStack (yyGLRStack
* yystackp
, size_t yyk
)
1402 if (yystackp
->yysplitPoint
== YY_NULL
)
1404 YYASSERT (yyk
== 0);
1405 yystackp
->yysplitPoint
= yystackp
->yytops
.yystates
[yyk
];
1407 if (yystackp
->yytops
.yysize
>= yystackp
->yytops
.yycapacity
)
1409 yyGLRState
** yynewStates
;
1410 yybool
* yynewLookaheadNeeds
;
1412 yynewStates
= YY_NULL
;
1414 if (yystackp
->yytops
.yycapacity
1415 > (YYSIZEMAX
/ (2 * sizeof yynewStates
[0])))
1416 yyMemoryExhausted (yystackp
);
1417 yystackp
->yytops
.yycapacity
*= 2;
1420 (yyGLRState
**) YYREALLOC (yystackp
->yytops
.yystates
,
1421 (yystackp
->yytops
.yycapacity
1422 * sizeof yynewStates
[0]));
1423 if (yynewStates
== YY_NULL
)
1424 yyMemoryExhausted (yystackp
);
1425 yystackp
->yytops
.yystates
= yynewStates
;
1427 yynewLookaheadNeeds
=
1428 (yybool
*) YYREALLOC (yystackp
->yytops
.yylookaheadNeeds
,
1429 (yystackp
->yytops
.yycapacity
1430 * sizeof yynewLookaheadNeeds
[0]));
1431 if (yynewLookaheadNeeds
== YY_NULL
)
1432 yyMemoryExhausted (yystackp
);
1433 yystackp
->yytops
.yylookaheadNeeds
= yynewLookaheadNeeds
;
1435 yystackp
->yytops
.yystates
[yystackp
->yytops
.yysize
]
1436 = yystackp
->yytops
.yystates
[yyk
];
1437 yystackp
->yytops
.yylookaheadNeeds
[yystackp
->yytops
.yysize
]
1438 = yystackp
->yytops
.yylookaheadNeeds
[yyk
];
1439 yystackp
->yytops
.yysize
+= 1;
1440 return yystackp
->yytops
.yysize
-1;
1443 /** True iff YYY0 and YYY1 represent identical options at the top level.
1444 * That is, they represent the same rule applied to RHS symbols
1445 * that produce the same terminal symbols. */
1447 yyidenticalOptions (yySemanticOption
* yyy0
, yySemanticOption
* yyy1
)
1449 if (yyy0
->yyrule
== yyy1
->yyrule
)
1451 yyGLRState
*yys0
, *yys1
;
1453 for (yys0
= yyy0
->yystate
, yys1
= yyy1
->yystate
,
1454 yyn
= yyrhsLength (yyy0
->yyrule
);
1456 yys0
= yys0
->yypred
, yys1
= yys1
->yypred
, yyn
-= 1)
1457 if (yys0
->yyposn
!= yys1
->yyposn
)
1465 /** Assuming identicalOptions (YYY0,YYY1), destructively merge the
1466 * alternative semantic values for the RHS-symbols of YYY1 and YYY0. */
1468 yymergeOptionSets (yySemanticOption
* yyy0
, yySemanticOption
* yyy1
)
1470 yyGLRState
*yys0
, *yys1
;
1472 for (yys0
= yyy0
->yystate
, yys1
= yyy1
->yystate
,
1473 yyn
= yyrhsLength (yyy0
->yyrule
);
1475 yys0
= yys0
->yypred
, yys1
= yys1
->yypred
, yyn
-= 1)
1479 else if (yys0
->yyresolved
)
1481 yys1
->yyresolved
= yytrue
;
1482 yys1
->yysemantics
.yysval
= yys0
->yysemantics
.yysval
;
1484 else if (yys1
->yyresolved
)
1486 yys0
->yyresolved
= yytrue
;
1487 yys0
->yysemantics
.yysval
= yys1
->yysemantics
.yysval
;
1491 yySemanticOption
** yyz0p
= &yys0
->yysemantics
.yyfirstVal
;
1492 yySemanticOption
* yyz1
= yys1
->yysemantics
.yyfirstVal
;
1495 if (yyz1
== *yyz0p
|| yyz1
== YY_NULL
)
1497 else if (*yyz0p
== YY_NULL
)
1502 else if (*yyz0p
< yyz1
)
1504 yySemanticOption
* yyz
= *yyz0p
;
1506 yyz1
= yyz1
->yynext
;
1507 (*yyz0p
)->yynext
= yyz
;
1509 yyz0p
= &(*yyz0p
)->yynext
;
1511 yys1
->yysemantics
.yyfirstVal
= yys0
->yysemantics
.yyfirstVal
;
1516 /** Y0 and Y1 represent two possible actions to take in a given
1517 * parsing state; return 0 if no combination is possible,
1518 * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
1520 yypreference (yySemanticOption
* y0
, yySemanticOption
* y1
)
1522 yyRuleNum r0
= y0
->yyrule
, r1
= y1
->yyrule
;
1523 int p0
= yydprec
[r0
], p1
= yydprec
[r1
];
1527 if (yymerger
[r0
] == 0 || yymerger
[r0
] != yymerger
[r1
])
1532 if (p0
== 0 || p1
== 0)
1541 static YYRESULTTAG
yyresolveValue (yyGLRState
* yys
,
1542 yyGLRStack
* yystackp
]b4_user_formals
[);
1545 /** Resolve the previous YYN states starting at and including state YYS
1546 * on *YYSTACKP. If result != yyok, some states may have been left
1547 * unresolved possibly with empty semantic option chains. Regardless
1548 * of whether result = yyok, each state has been left with consistent
1549 * data so that yydestroyGLRState can be invoked if necessary. */
1551 yyresolveStates (yyGLRState
* yys
, int yyn
,
1552 yyGLRStack
* yystackp
]b4_user_formals
[)
1556 YYASSERT (yys
->yypred
);
1557 YYCHK (yyresolveStates (yys
->yypred
, yyn
-1, yystackp
]b4_user_args
[));
1558 if (! yys
->yyresolved
)
1559 YYCHK (yyresolveValue (yys
, yystackp
]b4_user_args
[));
1564 /** Resolve the states for the RHS of YYOPT on *YYSTACKP, perform its
1565 * user action, and return the semantic value and location in *YYVALP
1566 * and *YYLOCP. Regardless of whether result = yyok, all RHS states
1567 * have been destroyed (assuming the user action destroys all RHS
1568 * semantic values if invoked). */
1570 yyresolveAction (yySemanticOption
* yyopt
, yyGLRStack
* yystackp
,
1571 YYSTYPE
* yyvalp
]b4_locuser_formals
[)
1573 yyGLRStackItem yyrhsVals
[YYMAXRHS
+ YYMAXLEFT
+ 1];
1574 int yynrhs
= yyrhsLength (yyopt
->yyrule
);
1575 YYRESULTTAG yyflag
=
1576 yyresolveStates (yyopt
->yystate
, yynrhs
, yystackp
]b4_user_args
[);
1580 for (yys
= yyopt
->yystate
; yynrhs
> 0; yys
= yys
->yypred
, yynrhs
-= 1)
1581 yydestroyGLRState ("Cleanup: popping", yys
]b4_user_args
[);
1585 yyrhsVals
[YYMAXRHS
+ YYMAXLEFT
].yystate
.yypred
= yyopt
->yystate
;]b4_locations_if([[
1587 /* Set default location. */
1588 yyrhsVals
[YYMAXRHS
+ YYMAXLEFT
- 1].yystate
.yyloc
= yyopt
->yystate
->yyloc
;]])[
1590 int yychar_current
= yychar
;
1591 YYSTYPE yylval_current
= yylval
;]b4_locations_if([
1592 YYLTYPE yylloc_current
= yylloc
;])[
1593 yychar
= yyopt
->yyrawchar
;
1594 yylval
= yyopt
->yyval
;]b4_locations_if([
1595 yylloc
= yyopt
->yyloc
;])[
1596 yyflag
= yyuserAction (yyopt
->yyrule
, yynrhs
,
1597 yyrhsVals
+ YYMAXRHS
+ YYMAXLEFT
- 1,
1598 yystackp
, yyvalp
]b4_locuser_args
[);
1599 yychar
= yychar_current
;
1600 yylval
= yylval_current
;]b4_locations_if([
1601 yylloc
= yylloc_current
;])[
1606 #if ]b4_api_PREFIX[DEBUG
1608 yyreportTree (yySemanticOption
* yyx
, int yyindent
)
1610 int yynrhs
= yyrhsLength (yyx
->yyrule
);
1613 yyGLRState
* yystates
[1 + YYMAXRHS
];
1614 yyGLRState yyleftmost_state
;
1616 for (yyi
= yynrhs
, yys
= yyx
->yystate
; 0 < yyi
; yyi
-= 1, yys
= yys
->yypred
)
1617 yystates
[yyi
] = yys
;
1620 yyleftmost_state
.yyposn
= 0;
1621 yystates
[0] = &yyleftmost_state
;
1626 if (yyx
->yystate
->yyposn
< yys
->yyposn
+ 1)
1627 YYFPRINTF (stderr
, "%*s%s -> <Rule %d, empty>\n",
1628 yyindent
, "", yytokenName (yylhsNonterm (yyx
->yyrule
)),
1631 YYFPRINTF (stderr
, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
1632 yyindent
, "", yytokenName (yylhsNonterm (yyx
->yyrule
)),
1633 yyx
->yyrule
- 1, (unsigned long int) (yys
->yyposn
+ 1),
1634 (unsigned long int) yyx
->yystate
->yyposn
);
1635 for (yyi
= 1; yyi
<= yynrhs
; yyi
+= 1)
1637 if (yystates
[yyi
]->yyresolved
)
1639 if (yystates
[yyi
-1]->yyposn
+1 > yystates
[yyi
]->yyposn
)
1640 YYFPRINTF (stderr
, "%*s%s <empty>\n", yyindent
+2, "",
1641 yytokenName (yystos
[yystates
[yyi
]->yylrState
]));
1643 YYFPRINTF (stderr
, "%*s%s <tokens %lu .. %lu>\n", yyindent
+2, "",
1644 yytokenName (yystos
[yystates
[yyi
]->yylrState
]),
1645 (unsigned long int) (yystates
[yyi
-1]->yyposn
+ 1),
1646 (unsigned long int) yystates
[yyi
]->yyposn
);
1649 yyreportTree (yystates
[yyi
]->yysemantics
.yyfirstVal
, yyindent
+2);
1655 yyreportAmbiguity (yySemanticOption
* yyx0
,
1656 yySemanticOption
* yyx1
]b4_pure_formals
[)
1661 #if ]b4_api_PREFIX[DEBUG
1662 YYFPRINTF (stderr
, "Ambiguity detected.\n");
1663 YYFPRINTF (stderr
, "Option 1,\n");
1664 yyreportTree (yyx0
, 2);
1665 YYFPRINTF (stderr
, "\nOption 2,\n");
1666 yyreportTree (yyx1
, 2);
1667 YYFPRINTF (stderr
, "\n");
1670 yyerror (]b4_yyerror_args
[YY_("syntax is ambiguous"));
1672 }]b4_locations_if([[
1674 /** Resolve the locations for each of the YYN1 states in *YYSTACKP,
1675 * ending at YYS1. Has no effect on previously resolved states.
1676 * The first semantic option of a state is always chosen. */
1678 yyresolveLocations (yyGLRState
* yys1
, int yyn1
,
1679 yyGLRStack
*yystackp
]b4_user_formals
[)
1683 yyresolveLocations (yys1
->yypred
, yyn1
- 1, yystackp
]b4_user_args
[);
1684 if (!yys1
->yyresolved
)
1686 yyGLRStackItem yyrhsloc
[1 + YYMAXRHS
];
1688 yySemanticOption
*yyoption
= yys1
->yysemantics
.yyfirstVal
;
1689 YYASSERT (yyoption
!= YY_NULL
);
1690 yynrhs
= yyrhsLength (yyoption
->yyrule
);
1695 yyresolveLocations (yyoption
->yystate
, yynrhs
,
1696 yystackp
]b4_user_args
[);
1697 for (yys
= yyoption
->yystate
, yyn
= yynrhs
;
1699 yys
= yys
->yypred
, yyn
-= 1)
1700 yyrhsloc
[yyn
].yystate
.yyloc
= yys
->yyloc
;
1704 /* Both yyresolveAction and yyresolveLocations traverse the GSS
1705 in reverse rightmost order. It is only necessary to invoke
1706 yyresolveLocations on a subforest for which yyresolveAction
1707 would have been invoked next had an ambiguity not been
1708 detected. Thus the location of the previous state (but not
1709 necessarily the previous state itself) is guaranteed to be
1710 resolved already. */
1711 yyGLRState
*yyprevious
= yyoption
->yystate
;
1712 yyrhsloc
[0].yystate
.yyloc
= yyprevious
->yyloc
;
1715 int yychar_current
= yychar
;
1716 YYSTYPE yylval_current
= yylval
;
1717 YYLTYPE yylloc_current
= yylloc
;
1718 yychar
= yyoption
->yyrawchar
;
1719 yylval
= yyoption
->yyval
;
1720 yylloc
= yyoption
->yyloc
;
1721 YYLLOC_DEFAULT ((yys1
->yyloc
), yyrhsloc
, yynrhs
);
1722 yychar
= yychar_current
;
1723 yylval
= yylval_current
;
1724 yylloc
= yylloc_current
;
1730 /** Resolve the ambiguity represented in state YYS in *YYSTACKP,
1731 * perform the indicated actions, and set the semantic value of YYS.
1732 * If result != yyok, the chain of semantic options in YYS has been
1733 * cleared instead or it has been left unmodified except that
1734 * redundant options may have been removed. Regardless of whether
1735 * result = yyok, YYS has been left with consistent data so that
1736 * yydestroyGLRState can be invoked if necessary. */
1738 yyresolveValue (yyGLRState
* yys
, yyGLRStack
* yystackp
]b4_user_formals
[)
1740 yySemanticOption
* yyoptionList
= yys
->yysemantics
.yyfirstVal
;
1741 yySemanticOption
* yybest
= yyoptionList
;
1742 yySemanticOption
** yypp
;
1743 yybool yymerge
= yyfalse
;
1745 YYRESULTTAG yyflag
;]b4_locations_if([
1746 YYLTYPE
*yylocp
= &yys
->yyloc
;])[
1748 for (yypp
= &yyoptionList
->yynext
; *yypp
!= YY_NULL
; )
1750 yySemanticOption
* yyp
= *yypp
;
1752 if (yyidenticalOptions (yybest
, yyp
))
1754 yymergeOptionSets (yybest
, yyp
);
1755 *yypp
= yyp
->yynext
;
1759 switch (yypreference (yybest
, yyp
))
1761 case 0:]b4_locations_if([[
1762 yyresolveLocations (yys
, 1, yystackp
]b4_user_args
[);]])[
1763 return yyreportAmbiguity (yybest
, yyp
]b4_pure_args
[);
1775 /* This cannot happen so it is not worth a YYASSERT (yyfalse),
1776 but some compilers complain if the default case is
1780 yypp
= &yyp
->yynext
;
1786 yySemanticOption
* yyp
;
1787 int yyprec
= yydprec
[yybest
->yyrule
];
1788 yyflag
= yyresolveAction (yybest
, yystackp
, &yysval
]b4_locuser_args
[);
1790 for (yyp
= yybest
->yynext
; yyp
!= YY_NULL
; yyp
= yyp
->yynext
)
1792 if (yyprec
== yydprec
[yyp
->yyrule
])
1794 YYSTYPE yysval_other
;]b4_locations_if([
1796 yyflag
= yyresolveAction (yyp
, yystackp
, &yysval_other
]b4_locuser_args([&yydummy
])[);
1799 yydestruct ("Cleanup: discarding incompletely merged value for",
1800 yystos
[yys
->yylrState
],
1801 &yysval
]b4_locuser_args
[);
1804 yyuserMerge (yymerger
[yyp
->yyrule
], &yysval
, &yysval_other
);
1809 yyflag
= yyresolveAction (yybest
, yystackp
, &yysval
]b4_locuser_args([yylocp
])[);
1813 yys
->yyresolved
= yytrue
;
1814 yys
->yysemantics
.yysval
= yysval
;
1817 yys
->yysemantics
.yyfirstVal
= YY_NULL
;
1822 yyresolveStack (yyGLRStack
* yystackp
]b4_user_formals
[)
1824 if (yystackp
->yysplitPoint
!= YY_NULL
)
1829 for (yyn
= 0, yys
= yystackp
->yytops
.yystates
[0];
1830 yys
!= yystackp
->yysplitPoint
;
1831 yys
= yys
->yypred
, yyn
+= 1)
1833 YYCHK (yyresolveStates (yystackp
->yytops
.yystates
[0], yyn
, yystackp
1840 yycompressStack (yyGLRStack
* yystackp
)
1842 yyGLRState
* yyp
, *yyq
, *yyr
;
1844 if (yystackp
->yytops
.yysize
!= 1 || yystackp
->yysplitPoint
== YY_NULL
)
1847 for (yyp
= yystackp
->yytops
.yystates
[0], yyq
= yyp
->yypred
, yyr
= YY_NULL
;
1848 yyp
!= yystackp
->yysplitPoint
;
1849 yyr
= yyp
, yyp
= yyq
, yyq
= yyp
->yypred
)
1852 yystackp
->yyspaceLeft
+= yystackp
->yynextFree
- yystackp
->yyitems
;
1853 yystackp
->yynextFree
= ((yyGLRStackItem
*) yystackp
->yysplitPoint
) + 1;
1854 yystackp
->yyspaceLeft
-= yystackp
->yynextFree
- yystackp
->yyitems
;
1855 yystackp
->yysplitPoint
= YY_NULL
;
1856 yystackp
->yylastDeleted
= YY_NULL
;
1858 while (yyr
!= YY_NULL
)
1860 yystackp
->yynextFree
->yystate
= *yyr
;
1862 yystackp
->yynextFree
->yystate
.yypred
= &yystackp
->yynextFree
[-1].yystate
;
1863 yystackp
->yytops
.yystates
[0] = &yystackp
->yynextFree
->yystate
;
1864 yystackp
->yynextFree
+= 1;
1865 yystackp
->yyspaceLeft
-= 1;
1870 yyprocessOneStack (yyGLRStack
* yystackp
, size_t yyk
,
1871 size_t yyposn
]b4_pure_formals
[)
1873 while (yystackp
->yytops
.yystates
[yyk
] != YY_NULL
)
1875 yyStateNum yystate
= yystackp
->yytops
.yystates
[yyk
]->yylrState
;
1876 YYDPRINTF ((stderr
, "Stack %lu Entering state %d\n",
1877 (unsigned long int) yyk
, yystate
));
1879 YYASSERT (yystate
!= YYFINAL
);
1881 if (yyisDefaultedState (yystate
))
1884 yyRuleNum yyrule
= yydefaultAction (yystate
);
1887 YYDPRINTF ((stderr
, "Stack %lu dies.\n",
1888 (unsigned long int) yyk
));
1889 yymarkStackDeleted (yystackp
, yyk
);
1892 yyflag
= yyglrReduce (yystackp
, yyk
, yyrule
, yyimmediate
[yyrule
]]b4_user_args
[);
1893 if (yyflag
== yyerr
)
1897 "(predicate failure or explicit user error).\n",
1898 (unsigned long int) yyk
));
1899 yymarkStackDeleted (yystackp
, yyk
);
1909 const short int* yyconflicts
;
1911 yystackp
->yytops
.yylookaheadNeeds
[yyk
] = yytrue
;
1912 if (yychar
== YYEMPTY
)
1914 YYDPRINTF ((stderr
, "Reading a token: "));
1918 if (yychar
<= YYEOF
)
1920 yychar
= yytoken
= YYEOF
;
1921 YYDPRINTF ((stderr
, "Now at end of input.\n"));
1925 yytoken
= YYTRANSLATE (yychar
);
1926 YY_SYMBOL_PRINT ("Next token is", yytoken
, &yylval
, &yylloc
);
1929 yygetLRActions (yystate
, yytoken
, &yyaction
, &yyconflicts
);
1931 while (*yyconflicts
!= 0)
1934 size_t yynewStack
= yysplitStack (yystackp
, yyk
);
1935 YYDPRINTF ((stderr
, "Splitting off stack %lu from %lu.\n",
1936 (unsigned long int) yynewStack
,
1937 (unsigned long int) yyk
));
1938 yyflag
= yyglrReduce (yystackp
, yynewStack
,
1940 yyimmediate
[*yyconflicts
]]b4_user_args
[);
1942 YYCHK (yyprocessOneStack (yystackp
, yynewStack
,
1943 yyposn
]b4_pure_args
[));
1944 else if (yyflag
== yyerr
)
1946 YYDPRINTF ((stderr
, "Stack %lu dies.\n",
1947 (unsigned long int) yynewStack
));
1948 yymarkStackDeleted (yystackp
, yynewStack
);
1955 if (yyisShiftAction (yyaction
))
1957 else if (yyisErrorAction (yyaction
))
1959 YYDPRINTF ((stderr
, "Stack %lu dies.\n",
1960 (unsigned long int) yyk
));
1961 yymarkStackDeleted (yystackp
, yyk
);
1966 YYRESULTTAG yyflag
= yyglrReduce (yystackp
, yyk
, -yyaction
,
1967 yyimmediate
[-yyaction
]]b4_user_args
[);
1968 if (yyflag
== yyerr
)
1972 "(predicate failure or explicit user error).\n",
1973 (unsigned long int) yyk
));
1974 yymarkStackDeleted (yystackp
, yyk
);
1977 else if (yyflag
!= yyok
)
1986 yyreportSyntaxError (yyGLRStack
* yystackp
]b4_user_formals
[)
1988 if (yystackp
->yyerrState
!= 0)
1990 #if ! YYERROR_VERBOSE
1991 yyerror (]b4_lyyerror_args
[YY_("syntax error"));
1994 yySymbol yytoken
= yychar
== YYEMPTY
? YYEMPTY
: YYTRANSLATE (yychar
);
1995 size_t yysize0
= yytnamerr (YY_NULL
, yytokenName (yytoken
));
1996 size_t yysize
= yysize0
;
1997 yybool yysize_overflow
= yyfalse
;
1998 char* yymsg
= YY_NULL
;
1999 enum { YYERROR_VERBOSE_ARGS_MAXIMUM
= 5 };
2000 /* Internationalized format string. */
2001 const char *yyformat
= YY_NULL
;
2002 /* Arguments of yyformat. */
2003 char const *yyarg
[YYERROR_VERBOSE_ARGS_MAXIMUM
];
2004 /* Number of reported tokens (one for the "unexpected", one per
2008 /* There are many possibilities here to consider:
2009 - If this state is a consistent state with a default action, then
2010 the only way this function was invoked is if the default action
2011 is an error action. In that case, don't check for expected
2012 tokens because there are none.
2013 - The only way there can be no lookahead present (in yychar) is if
2014 this state is a consistent state with a default action. Thus,
2015 detecting the absence of a lookahead is sufficient to determine
2016 that there is no unexpected or expected token to report. In that
2017 case, just report a simple "syntax error".
2018 - Don't assume there isn't a lookahead just because this state is a
2019 consistent state with a default action. There might have been a
2020 previous inconsistent state, consistent state with a non-default
2021 action, or user semantic action that manipulated yychar.
2022 - Of course, the expected token list depends on states to have
2023 correct lookahead information, and it depends on the parser not
2024 to perform extra reductions after fetching a lookahead from the
2025 scanner and before detecting a syntax error. Thus, state merging
2026 (from LALR or IELR) and default reductions corrupt the expected
2027 token list. However, the list is correct for canonical LR with
2028 one exception: it will still contain any token that will not be
2029 accepted due to an error action in a later state.
2031 if (yytoken
!= YYEMPTY
)
2033 int yyn
= yypact
[yystackp
->yytops
.yystates
[0]->yylrState
];
2034 yyarg
[yycount
++] = yytokenName (yytoken
);
2035 if (!yypact_value_is_default (yyn
))
2037 /* Start YYX at -YYN if negative to avoid negative indexes in
2038 YYCHECK. In other words, skip the first -YYN actions for this
2039 state because they are default actions. */
2040 int yyxbegin
= yyn
< 0 ? -yyn
: 0;
2041 /* Stay within bounds of both yycheck and yytname. */
2042 int yychecklim
= YYLAST
- yyn
+ 1;
2043 int yyxend
= yychecklim
< YYNTOKENS
? yychecklim
: YYNTOKENS
;
2045 for (yyx
= yyxbegin
; yyx
< yyxend
; ++yyx
)
2046 if (yycheck
[yyx
+ yyn
] == yyx
&& yyx
!= YYTERROR
2047 && !yytable_value_is_error (yytable
[yyx
+ yyn
]))
2049 if (yycount
== YYERROR_VERBOSE_ARGS_MAXIMUM
)
2055 yyarg
[yycount
++] = yytokenName (yyx
);
2057 size_t yysz
= yysize
+ yytnamerr (YY_NULL
, yytokenName (yyx
));
2058 yysize_overflow
|= yysz
< yysize
;
2067 #define YYCASE_(N, S) \
2071 YYCASE_(0, YY_("syntax error"));
2072 YYCASE_(1, YY_("syntax error, unexpected %s"));
2073 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2074 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2075 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2076 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2081 size_t yysz
= yysize
+ strlen (yyformat
);
2082 yysize_overflow
|= yysz
< yysize
;
2086 if (!yysize_overflow
)
2087 yymsg
= (char *) YYMALLOC (yysize
);
2093 while ((*yyp
= *yyformat
))
2095 if (*yyp
== '%' && yyformat
[1] == 's' && yyi
< yycount
)
2097 yyp
+= yytnamerr (yyp
, yyarg
[yyi
++]);
2106 yyerror (]b4_lyyerror_args
[yymsg
);
2111 yyerror (]b4_lyyerror_args
[YY_("syntax error"));
2112 yyMemoryExhausted (yystackp
);
2115 #endif /* YYERROR_VERBOSE */
2119 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
2120 yylval, and yylloc are the syntactic category, semantic value, and location
2121 of the lookahead. */
2123 yyrecoverSyntaxError (yyGLRStack
* yystackp
]b4_user_formals
[)
2128 if (yystackp
->yyerrState
== 3)
2129 /* We just shifted the error token and (perhaps) took some
2130 reductions. Skip tokens until we can proceed. */
2134 if (yychar
== YYEOF
)
2135 yyFail (yystackp
][]b4_lpure_args
[, YY_NULL
);
2136 if (yychar
!= YYEMPTY
)
2137 {]b4_locations_if([[
2138 /* We throw away the lookahead, but the error range
2139 of the shifted error token must take it into account. */
2140 yyGLRState
*yys
= yystackp
->yytops
.yystates
[0];
2141 yyGLRStackItem yyerror_range
[3];
2142 yyerror_range
[1].yystate
.yyloc
= yys
->yyloc
;
2143 yyerror_range
[2].yystate
.yyloc
= yylloc
;
2144 YYLLOC_DEFAULT ((yys
->yyloc
), yyerror_range
, 2);]])[
2145 yytoken
= YYTRANSLATE (yychar
);
2146 yydestruct ("Error: discarding",
2147 yytoken
, &yylval
]b4_locuser_args([&yylloc
])[);
2149 YYDPRINTF ((stderr
, "Reading a token: "));
2151 if (yychar
<= YYEOF
)
2153 yychar
= yytoken
= YYEOF
;
2154 YYDPRINTF ((stderr
, "Now at end of input.\n"));
2158 yytoken
= YYTRANSLATE (yychar
);
2159 YY_SYMBOL_PRINT ("Next token is", yytoken
, &yylval
, &yylloc
);
2161 yyj
= yypact
[yystackp
->yytops
.yystates
[0]->yylrState
];
2162 if (yypact_value_is_default (yyj
))
2165 if (yyj
< 0 || YYLAST
< yyj
|| yycheck
[yyj
] != yytoken
)
2167 if (yydefact
[yystackp
->yytops
.yystates
[0]->yylrState
] != 0)
2170 else if (! yytable_value_is_error (yytable
[yyj
]))
2174 /* Reduce to one stack. */
2175 for (yyk
= 0; yyk
< yystackp
->yytops
.yysize
; yyk
+= 1)
2176 if (yystackp
->yytops
.yystates
[yyk
] != YY_NULL
)
2178 if (yyk
>= yystackp
->yytops
.yysize
)
2179 yyFail (yystackp
][]b4_lpure_args
[, YY_NULL
);
2180 for (yyk
+= 1; yyk
< yystackp
->yytops
.yysize
; yyk
+= 1)
2181 yymarkStackDeleted (yystackp
, yyk
);
2182 yyremoveDeletes (yystackp
);
2183 yycompressStack (yystackp
);
2185 /* Now pop stack until we find a state that shifts the error token. */
2186 yystackp
->yyerrState
= 3;
2187 while (yystackp
->yytops
.yystates
[0] != YY_NULL
)
2189 yyGLRState
*yys
= yystackp
->yytops
.yystates
[0];
2190 yyj
= yypact
[yys
->yylrState
];
2191 if (! yypact_value_is_default (yyj
))
2194 if (0 <= yyj
&& yyj
<= YYLAST
&& yycheck
[yyj
] == YYTERROR
2195 && yyisShiftAction (yytable
[yyj
]))
2197 /* Shift the error token. */]b4_locations_if([[
2198 /* First adjust its location.*/
2200 yystackp
->yyerror_range
[2].yystate
.yyloc
= yylloc
;
2201 YYLLOC_DEFAULT (yyerrloc
, (yystackp
->yyerror_range
), 2);]])[
2202 YY_SYMBOL_PRINT ("Shifting", yystos
[yytable
[yyj
]],
2203 &yylval
, &yyerrloc
);
2204 yyglrShift (yystackp
, 0, yytable
[yyj
],
2205 yys
->yyposn
, &yylval
]b4_locations_if([, &yyerrloc
])[);
2206 yys
= yystackp
->yytops
.yystates
[0];
2209 }]b4_locations_if([[
2210 yystackp
->yyerror_range
[1].yystate
.yyloc
= yys
->yyloc
;]])[
2211 if (yys
->yypred
!= YY_NULL
)
2212 yydestroyGLRState ("Error: popping", yys
]b4_user_args
[);
2213 yystackp
->yytops
.yystates
[0] = yys
->yypred
;
2214 yystackp
->yynextFree
-= 1;
2215 yystackp
->yyspaceLeft
+= 1;
2217 if (yystackp
->yytops
.yystates
[0] == YY_NULL
)
2218 yyFail (yystackp
][]b4_lpure_args
[, YY_NULL
);
2221 #define YYCHK1(YYE) \
2231 goto yyuser_error; \
2241 ]b4_function_define([yyparse
], [int], b4_parse_param
)[
2245 yyGLRStack
* const yystackp
= &yystack
;
2248 YYDPRINTF ((stderr
, "Starting parse\n"));
2251 yylval
= yyval_default
;]b4_locations_if([
2252 yylloc
= yyloc_default
;])[
2253 ]m4_ifdef([b4_initial_action
], [
2254 b4_dollar_pushdef([yylval
], [], [yylloc
])dnl
2255 /* User initialization code. */
2256 b4_user_initial_action
2257 b4_dollar_popdef
])[]dnl
2259 if (! yyinitGLRStack (yystackp
, YYINITDEPTH
))
2260 goto yyexhaustedlab
;
2261 switch (YYSETJMP (yystack
.yyexception_buffer
))
2264 case 1: goto yyabortlab
;
2265 case 2: goto yyexhaustedlab
;
2266 default: goto yybuglab
;
2268 yyglrShift (&yystack
, 0, 0, 0, &yylval
]b4_locations_if([, &yylloc
])[);
2273 /* For efficiency, we have two loops, the first of which is
2274 specialized to deterministic operation (single stack, no
2275 potential ambiguity). */
2281 const short int* yyconflicts
;
2283 yyStateNum yystate
= yystack
.yytops
.yystates
[0]->yylrState
;
2284 YYDPRINTF ((stderr
, "Entering state %d\n", yystate
));
2285 if (yystate
== YYFINAL
)
2287 if (yyisDefaultedState (yystate
))
2289 yyrule
= yydefaultAction (yystate
);
2292 ]b4_locations_if([[ yystack
.yyerror_range
[1].yystate
.yyloc
= yylloc
;]])[
2293 yyreportSyntaxError (&yystack
]b4_user_args
[);
2296 YYCHK1 (yyglrReduce (&yystack
, 0, yyrule
, yytrue
]b4_user_args
[));
2301 if (yychar
== YYEMPTY
)
2303 YYDPRINTF ((stderr
, "Reading a token: "));
2307 if (yychar
<= YYEOF
)
2309 yychar
= yytoken
= YYEOF
;
2310 YYDPRINTF ((stderr
, "Now at end of input.\n"));
2314 yytoken
= YYTRANSLATE (yychar
);
2315 YY_SYMBOL_PRINT ("Next token is", yytoken
, &yylval
, &yylloc
);
2318 yygetLRActions (yystate
, yytoken
, &yyaction
, &yyconflicts
);
2319 if (*yyconflicts
!= 0)
2321 if (yyisShiftAction (yyaction
))
2323 YY_SYMBOL_PRINT ("Shifting", yytoken
, &yylval
, &yylloc
);
2326 yyglrShift (&yystack
, 0, yyaction
, yyposn
, &yylval
]b4_locations_if([, &yylloc
])[);
2327 if (0 < yystack
.yyerrState
)
2328 yystack
.yyerrState
-= 1;
2330 else if (yyisErrorAction (yyaction
))
2332 ]b4_locations_if([[ yystack
.yyerror_range
[1].yystate
.yyloc
= yylloc
;]])[
2333 yyreportSyntaxError (&yystack
]b4_user_args
[);
2337 YYCHK1 (yyglrReduce (&yystack
, 0, -yyaction
, yytrue
]b4_user_args
[));
2343 yySymbol yytoken_to_shift
;
2346 for (yys
= 0; yys
< yystack
.yytops
.yysize
; yys
+= 1)
2347 yystackp
->yytops
.yylookaheadNeeds
[yys
] = yychar
!= YYEMPTY
;
2349 /* yyprocessOneStack returns one of three things:
2351 - An error flag. If the caller is yyprocessOneStack, it
2352 immediately returns as well. When the caller is finally
2353 yyparse, it jumps to an error label via YYCHK1.
2355 - yyok, but yyprocessOneStack has invoked yymarkStackDeleted
2356 (&yystack, yys), which sets the top state of yys to NULL. Thus,
2357 yyparse's following invocation of yyremoveDeletes will remove
2360 - yyok, when ready to shift a token.
2362 Except in the first case, yyparse will invoke yyremoveDeletes and
2363 then shift the next token onto all remaining stacks. This
2364 synchronization of the shift (that is, after all preceding
2365 reductions on all stacks) helps prevent double destructor calls
2366 on yylval in the event of memory exhaustion. */
2368 for (yys
= 0; yys
< yystack
.yytops
.yysize
; yys
+= 1)
2369 YYCHK1 (yyprocessOneStack (&yystack
, yys
, yyposn
]b4_lpure_args
[));
2370 yyremoveDeletes (&yystack
);
2371 if (yystack
.yytops
.yysize
== 0)
2373 yyundeleteLastStack (&yystack
);
2374 if (yystack
.yytops
.yysize
== 0)
2375 yyFail (&yystack
][]b4_lpure_args
[, YY_("syntax error"));
2376 YYCHK1 (yyresolveStack (&yystack
]b4_user_args
[));
2377 YYDPRINTF ((stderr
, "Returning to deterministic operation.\n"));
2378 ]b4_locations_if([[ yystack
.yyerror_range
[1].yystate
.yyloc
= yylloc
;]])[
2379 yyreportSyntaxError (&yystack
]b4_user_args
[);
2383 /* If any yyglrShift call fails, it will fail after shifting. Thus,
2384 a copy of yylval will already be on stack 0 in the event of a
2385 failure in the following loop. Thus, yychar is set to YYEMPTY
2386 before the loop to make sure the user destructor for yylval isn't
2388 yytoken_to_shift
= YYTRANSLATE (yychar
);
2391 for (yys
= 0; yys
< yystack
.yytops
.yysize
; yys
+= 1)
2394 const short int* yyconflicts
;
2395 yyStateNum yystate
= yystack
.yytops
.yystates
[yys
]->yylrState
;
2396 yygetLRActions (yystate
, yytoken_to_shift
, &yyaction
,
2398 /* Note that yyconflicts were handled by yyprocessOneStack. */
2399 YYDPRINTF ((stderr
, "On stack %lu, ", (unsigned long int) yys
));
2400 YY_SYMBOL_PRINT ("shifting", yytoken_to_shift
, &yylval
, &yylloc
);
2401 yyglrShift (&yystack
, yys
, yyaction
, yyposn
,
2402 &yylval
]b4_locations_if([, &yylloc
])[);
2403 YYDPRINTF ((stderr
, "Stack %lu now in state #%d\n",
2404 (unsigned long int) yys
,
2405 yystack
.yytops
.yystates
[yys
]->yylrState
));
2408 if (yystack
.yytops
.yysize
== 1)
2410 YYCHK1 (yyresolveStack (&yystack
]b4_user_args
[));
2411 YYDPRINTF ((stderr
, "Returning to deterministic operation.\n"));
2412 yycompressStack (&yystack
);
2418 yyrecoverSyntaxError (&yystack
]b4_user_args
[);
2419 yyposn
= yystack
.yytops
.yystates
[0]->yyposn
;
2435 yyerror (]b4_lyyerror_args
[YY_("memory exhausted"));
2440 if (yychar
!= YYEMPTY
)
2441 yydestruct ("Cleanup: discarding lookahead",
2442 YYTRANSLATE (yychar
), &yylval
]b4_locuser_args([&yylloc
])[);
2444 /* If the stack is well-formed, pop the stack until it is empty,
2445 destroying its entries as we go. But free the stack regardless
2446 of whether it is well-formed. */
2447 if (yystack
.yyitems
)
2449 yyGLRState
** yystates
= yystack
.yytops
.yystates
;
2452 size_t yysize
= yystack
.yytops
.yysize
;
2454 for (yyk
= 0; yyk
< yysize
; yyk
+= 1)
2457 while (yystates
[yyk
])
2459 yyGLRState
*yys
= yystates
[yyk
];
2460 ]b4_locations_if([[ yystack
.yyerror_range
[1].yystate
.yyloc
= yys
->yyloc
;]]
2461 )[ if (yys
->yypred
!= YY_NULL
)
2462 yydestroyGLRState ("Cleanup: popping", yys
]b4_user_args
[);
2463 yystates
[yyk
] = yys
->yypred
;
2464 yystack
.yynextFree
-= 1;
2465 yystack
.yyspaceLeft
+= 1;
2470 yyfreeGLRStack (&yystack
);
2476 /* DEBUGGING ONLY */
2477 #if ]b4_api_PREFIX[DEBUG
2479 yy_yypstack (yyGLRState
* yys
)
2483 yy_yypstack (yys
->yypred
);
2484 YYFPRINTF (stderr
, " -> ");
2486 YYFPRINTF (stderr
, "%d@@%lu", yys
->yylrState
,
2487 (unsigned long int) yys
->yyposn
);
2491 yypstates (yyGLRState
* yyst
)
2493 if (yyst
== YY_NULL
)
2494 YYFPRINTF (stderr
, "<null>");
2497 YYFPRINTF (stderr
, "\n");
2501 yypstack (yyGLRStack
* yystackp
, size_t yyk
)
2503 yypstates (yystackp
->yytops
.yystates
[yyk
]);
2506 #define YYINDEX(YYX) \
2507 ((YYX) == YY_NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
2511 yypdumpstack (yyGLRStack
* yystackp
)
2513 yyGLRStackItem
* yyp
;
2515 for (yyp
= yystackp
->yyitems
; yyp
< yystackp
->yynextFree
; yyp
+= 1)
2517 YYFPRINTF (stderr
, "%3lu. ",
2518 (unsigned long int) (yyp
- yystackp
->yyitems
));
2519 if (*(yybool
*) yyp
)
2521 YYFPRINTF (stderr
, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
2522 yyp
->yystate
.yyresolved
, yyp
->yystate
.yylrState
,
2523 (unsigned long int) yyp
->yystate
.yyposn
,
2524 (long int) YYINDEX (yyp
->yystate
.yypred
));
2525 if (! yyp
->yystate
.yyresolved
)
2526 YYFPRINTF (stderr
, ", firstVal: %ld",
2527 (long int) YYINDEX (yyp
->yystate
2528 .yysemantics
.yyfirstVal
));
2532 YYFPRINTF (stderr
, "Option. rule: %d, state: %ld, next: %ld",
2533 yyp
->yyoption
.yyrule
- 1,
2534 (long int) YYINDEX (yyp
->yyoption
.yystate
),
2535 (long int) YYINDEX (yyp
->yyoption
.yynext
));
2537 YYFPRINTF (stderr
, "\n");
2539 YYFPRINTF (stderr
, "Tops:");
2540 for (yyi
= 0; yyi
< yystackp
->yytops
.yysize
; yyi
+= 1)
2541 YYFPRINTF (stderr
, "%lu: %ld; ", (unsigned long int) yyi
,
2542 (long int) YYINDEX (yystackp
->yytops
.yystates
[yyi
]));
2543 YYFPRINTF (stderr
, "\n");
2549 # glr.cc produces its own header.
2550 m4_if(b4_skeleton
, ["glr.c"],
2552 [b4_output_begin([b4_spec_defines_file
])
2553 b4_copyright([Skeleton interface
for Bison GLR parsers in C
],
2556 ]b4_cpp_guard_open([b4_spec_defines_file
])[
2557 ]b4_shared_declarations
[
2558 ]b4_cpp_guard_close([b4_spec_defines_file
])[