# Yes, this is quite ugly...
m4_define([b4_lex_param],
m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
-b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl
+b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl
m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
# Optional effective arguments passed to yyerror: user args plus yylloc, and
# a trailing comma.
m4_define([b4_yyerror_args],
-[b4_pure_if([b4_location_if([yylocp, ])])dnl
+[b4_pure_if([b4_locations_if([yylocp, ])])dnl
m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
# b4_lyyerror_args
# ----------------
-# Same as above, but on the look-ahead, hence &yylloc instead of yylocp.
+# Same as above, but on the lookahead, hence &yylloc instead of yylocp.
m4_define([b4_lyyerror_args],
-[b4_pure_if([b4_location_if([&yylloc, ])])dnl
+[b4_pure_if([b4_locations_if([&yylloc, ])])dnl
m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
# ------------
# Same as b4_yyerror_args, but with a leading comma.
m4_define([b4_pure_args],
-[b4_pure_if([b4_location_if([, yylocp])])[]b4_user_args])
+[b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args])
# b4_lpure_args
# -------------
-# Same as above, but on the look-ahead, hence &yylloc instead of yylocp.
+# Same as above, but on the lookahead, hence &yylloc instead of yylocp.
m4_define([b4_lpure_args],
-[b4_pure_if([b4_location_if([, &yylloc])])[]b4_user_args])
+[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args])
# b4_pure_formals
# ---------------
# Arguments passed to yyerror: user formals plus yylocp.
m4_define([b4_pure_formals],
-[b4_pure_if([b4_location_if([, YYLTYPE *yylocp])])[]b4_user_formals])
+[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals])
## ----------------- ##
m4_changecom()
m4_divert(0)dnl
@output @output_parser_name@
-b4_copyright([Skeleton parser for GLR parsing with Bison],
+b4_copyright([Skeleton implementation for Bison GLR parsers in C],
[2002, 2003, 2004, 2005, 2006])
[
-/* This is the parser code for GLR (Generalized LR) parser. */
+/* C GLR parser skeleton written by Paul Hilfinger. */
]b4_identification
-m4_if(b4_prefix[], [yy], [],
+m4_if(b4_prefix, [yy], [],
[/* Substitute the variable and function names. */
#define yyparse b4_prefix[]parse
#define yylex b4_prefix[]lex
#define yychar b4_prefix[]char
#define yydebug b4_prefix[]debug
#define yynerrs b4_prefix[]nerrs
-#define yylloc b4_prefix[]lloc])
+#define yylloc b4_prefix[]lloc])[
+
+/* Copy the first part of user declarations. */
+]b4_user_pre_prologue
dnl # b4_shared_declarations
dnl # ----------------------
dnl # Declaration that might either go into the header (if --defines)
dnl # or open coded in the parser body.
m4_define([b4_shared_declarations],
-[b4_token_enums(b4_tokens)[
+[m4_ifdef([b4_requires],
+[[/* Copy the %requires blocks. */
+]b4_user_requires])[]dnl
-/* Copy the first part of user declarations. */
-]b4_pre_prologue[
+b4_token_enums(b4_tokens)
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+[#ifndef YYSTYPE
]m4_ifdef([b4_stype],
-[typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])
-b4_stype
-/* Line __line__ of glr.c. */
-b4_syncline([@oline@], [@ofile@])
- YYSTYPE;],
-[typedef int YYSTYPE;])[
-# define YYSTYPE_IS_DECLARED 1
-# define YYSTYPE_IS_TRIVIAL 1
+[[typedef union ]b4_union_name[
+]b4_user_stype[
+ YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1]],
+[m4_if(b4_tag_seen_flag, 0,
+[[typedef int YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1]])])[
#endif
-#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
typedef struct YYLTYPE
{
-]b4_location_if([
+]b4_locations_if([
int first_line;
int first_column;
int last_line;
# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif
-]])
-m4_if(b4_defines_flag, 0,
- [b4_shared_declarations],
- [#include @output_header_name@])[
+]m4_ifdef([b4_provides],
+[[/* Copy the %provides blocks. */
+]b4_user_provides])[]dnl
+])
+
+b4_defines_if([#include @output_header_name@],
+ [b4_shared_declarations])[
/* Enabling traces. */
#ifndef YYDEBUG
-# define YYDEBUG ]b4_debug[
+# define YYDEBUG ]b4_debug_flag[
#endif
/* Enabling verbose error messages. */
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
-# define YYERROR_VERBOSE ]b4_error_verbose[
+# define YYERROR_VERBOSE ]b4_error_verbose_flag[
#endif
/* Enabling the token table. */
static YYSTYPE yyval_default;
/* Copy the second part of user declarations. */
-]b4_post_prologue[
+]b4_user_post_prologue[
-]/* Line __line__ of glr.c. */
-b4_syncline([@oline@], [@ofile@])
-[
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <stdarg.h>
#ifndef YY_
# if YYENABLE_NLS
#endif
/* Suppress unused-variable warnings by "using" E. */
-#if !defined (lint) || defined (__GNUC__)
+#if ! defined lint || defined __GNUC__
# define YYUSE(e) ((void) (e))
#else
# define YYUSE(e) /* empty */
#ifndef __attribute__
/* This feature is available in gcc versions 2.5 and later. */
-# if (!defined (__GNUC__) || __GNUC__ < 2 \
+# if (! defined __GNUC__ || __GNUC__ < 2 \
|| (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__)
# define __attribute__(Spec) /* empty */
# endif
#endif
-]b4_location_if([#define YYOPTIONAL_LOC(Name) Name],[
+]b4_locations_if([#define YYOPTIONAL_LOC(Name) Name],[
#ifdef __cplusplus
# define YYOPTIONAL_LOC(Name) /* empty */
#else
#define YYMAXUTOK ]b4_user_token_number_max[
#define YYTRANSLATE(YYX) \
- ((YYX <= 0) ? YYEOF : \
- (unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
If N is 0, then set CURRENT to the empty location which ends
the previous symbol: RHS[0] (always defined). */
-]b4_location_if([[
+]b4_locations_if([[
#define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
#if YYDEBUG
-#if ! defined (YYFPRINTF)
+# ifndef YYFPRINTF
# define YYFPRINTF fprintf
-#endif
+# endif
# define YYDPRINTF(Args) \
do { \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, Type, \
- Value]b4_location_if([, Location])[]b4_user_args[); \
+ Value]b4_locations_if([, Location])[]b4_user_args[); \
YYFPRINTF (stderr, "\n"); \
} \
} while (YYID (0))
#define YYHEADROOM 2
#ifndef YYSTACKEXPANDABLE
-# if (! defined (__cplusplus) \
- || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
- && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))
+# if (! defined __cplusplus \
+ || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+ && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
# define YYSTACKEXPANDABLE 1
# else
# define YYSTACKEXPANDABLE 0
#if YYERROR_VERBOSE
# ifndef yystpcpy
-# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
# define yystpcpy stpcpy
# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
struct yyGLRStack {
int yyerrState;
-]b4_location_if([[ /* To compute the location of the error token. */
+]b4_locations_if([[ /* To compute the location of the error token. */
yyGLRStackItem yyerror_range[3];]])[
]b4_pure_if(
[
YYSTYPE yyval;
YYLTYPE yyloc;
])[
- yySymbol* yytokenp;
YYJMP_BUF yyexception_buffer;
yyGLRStackItem* yyitems;
yyGLRStackItem* yynextFree;
# undef YYERROR
# define YYERROR return yyerrok, yyerr
# undef YYRECOVERING
-# define YYRECOVERING (yystackp->yyerrState != 0)
+# define YYRECOVERING() (yystackp->yyerrState != 0)
# undef yyclearin
-# define yyclearin (yychar = *(yystackp->yytokenp) = YYEMPTY)
+# define yyclearin (yychar = YYEMPTY)
# undef YYFILL
# define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
# undef YYBACKUP
*yyvalp = yyval_default;
else
*yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
- YYLLOC_DEFAULT (*yylocp, yyvsp - yyrhslen, yyrhslen);
-]b4_location_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
+ YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
+]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
]])[
switch (yyn)
{
- ]b4_actions
-/* Line __line__ of glr.c. */
-b4_syncline([@oline@], [@ofile@])[
+ ]b4_user_actions[
default: break;
}
{
if (yys->yyresolved)
yydestruct (yymsg, yystos[yys->yylrState],
- &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[]b4_user_args[);
+ &yys->yysemantics.yysval]b4_locations_if([, &yys->yyloc])[]b4_user_args[);
else
{
#if YYDEBUG
if (yydebug)
{
- YYFPRINTF (stderr, "%s unresolved ", yymsg);
+ if (yys->yysemantics.yyfirstVal)
+ YYFPRINTF (stderr, "%s unresolved ", yymsg);
+ else
+ YYFPRINTF (stderr, "%s incomplete ", yymsg);
yy_symbol_print (stderr, yystos[yys->yylrState],
- NULL]b4_location_if([, &yys->yyloc])[]b4_user_args[);
+ NULL]b4_locations_if([, &yys->yyloc])[]b4_user_args[);
YYFPRINTF (stderr, "\n");
}
#endif
size_t yysize, yynewSize;
size_t yyn;
yysize = yystackp->yynextFree - yystackp->yyitems;
- if (YYMAXDEPTH <= yysize)
+ if (YYMAXDEPTH - YYHEADROOM < yysize)
yyMemoryExhausted (yystackp);
yynewSize = 2*yysize;
if (YYMAXDEPTH < yynewSize)
yyGLRState* yys;
yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred
- = yystackp->yytops.yystates[yyk];]b4_location_if([[
+ = yystackp->yytops.yystates[yyk];]b4_locations_if([[
if (yynrhs == 0)
/* Set default location. */
yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[
fprintf (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&]b4_rhs_value(yynrhs, yyi + 1)[
- ]b4_location_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
+ ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
b4_user_args[);
fprintf (stderr, "\n");
}
}
static YYRESULTTAG yyresolveValue (yyGLRState* yys,
- yyGLRStack* yystackp, YYSTYPE* yyvalp,
- YYLTYPE* yylocp]b4_user_formals[);
+ yyGLRStack* yystackp]b4_user_formals[);
+
+/** Resolve the previous N states starting at and including state S. If result
+ * != yyok, some states may have been left unresolved possibly with empty
+ * semantic option chains. Regardless of whether result = yyok, each state
+ * has been left with consistent data so that yydestroyGLRState can be invoked
+ * if necessary. */
static YYRESULTTAG
yyresolveStates (yyGLRState* yys, int yyn,
yyGLRStack* yystackp]b4_user_formals[)
YYASSERT (yys->yypred);
YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[));
if (! yys->yyresolved)
- {
- YYSTYPE yysval;
- YYRESULTTAG yyflag = yyresolveValue (yys, yystackp, &yysval,
- &yys->yyloc]b4_user_args[);
- if (yyflag != yyok)
- {
- yys->yysemantics.yyfirstVal = NULL;
- return yyflag;
- }
- yys->yysemantics.yysval = yysval;
- yys->yyresolved = yytrue;
- }
+ YYCHK (yyresolveValue (yys, yystackp]b4_user_args[));
}
return yyok;
}
+/** Resolve the states for the RHS of OPT, perform its user action, and return
+ * the semantic value and location. Regardless of whether result = yyok, all
+ * RHS states have been destroyed (assuming the user action destroys all RHS
+ * semantic values if invoked). */
static YYRESULTTAG
yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
int yychar_current;
YYSTYPE yylval_current;
YYLTYPE yylloc_current;
- YYRESULTTAG yyresult;
+ YYRESULTTAG yyflag;
yynrhs = yyrhsLength (yyopt->yyrule);
- YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[));
- yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_location_if([[
+ yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[);
+ if (yyflag != yyok)
+ {
+ yyGLRState *yys;
+ for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1)
+ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
+ return yyflag;
+ }
+
+ yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[
if (yynrhs == 0)
/* Set default location. */
yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
yychar = yyopt->yyrawchar;
yylval = yyopt->yyval;
yylloc = yyopt->yyloc;
- yyresult = yyuserAction (yyopt->yyrule, yynrhs,
+ yyflag = yyuserAction (yyopt->yyrule, yynrhs,
yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
yyvalp, yylocp, yystackp]b4_user_args[);
yychar = yychar_current;
yylval = yylval_current;
yylloc = yylloc_current;
- return yyresult;
+ return yyflag;
}
#if YYDEBUG
int yynrhs = yyrhsLength (yyx->yyrule);
int yyi;
yyGLRState* yys;
- yyGLRState* yystates[YYMAXRHS];
+ yyGLRState* yystates[1 + YYMAXRHS];
yyGLRState yyleftmost_state;
for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
if (yyx->yystate->yyposn < yys->yyposn + 1)
YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
- yyx->yyrule);
+ yyx->yyrule - 1);
else
YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
- yyx->yyrule, (unsigned long int) (yys->yyposn + 1),
+ yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1),
(unsigned long int) yyx->yystate->yyposn);
for (yyi = 1; yyi <= yynrhs; yyi += 1)
{
}
#endif
-static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
- yyGLRStack* yystackp]b4_pure_formals[)
- __attribute__ ((__noreturn__));
-/*ARGSUSED*/ static void
-yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
- yyGLRStack* yystackp]b4_pure_formals[)
+/*ARGSUSED*/ static YYRESULTTAG
+yyreportAmbiguity (yySemanticOption* yyx0,
+ yySemanticOption* yyx1]b4_pure_formals[)
{
YYUSE (yyx0);
YYUSE (yyx1);
yyreportTree (yyx1, 2);
YYFPRINTF (stderr, "\n");
#endif
- yyFail (yystackp][]b4_pure_args[, YY_("syntax is ambiguous"));
+
+ yyerror (]b4_yyerror_args[YY_("syntax is ambiguous"));
+ return yyabort;
}
+/** Starting at and including state S1, resolve the location for each of the
+ * previous N1 states that is unresolved. The first semantic option of a state
+ * is always chosen. */
+static void
+yyresolveLocations (yyGLRState* yys1, int yyn1,
+ yyGLRStack *yystackp]b4_user_formals[)
+{
+ if (0 < yyn1)
+ {
+ yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[);
+ if (!yys1->yyresolved)
+ {
+ yySemanticOption *yyoption;
+ yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
+ int yynrhs;
+ int yychar_current;
+ YYSTYPE yylval_current;
+ YYLTYPE yylloc_current;
+ yyoption = yys1->yysemantics.yyfirstVal;
+ YYASSERT (yyoption != NULL);
+ yynrhs = yyrhsLength (yyoption->yyrule);
+ if (yynrhs > 0)
+ {
+ yyGLRState *yys;
+ int yyn;
+ yyresolveLocations (yyoption->yystate, yynrhs,
+ yystackp]b4_user_args[);
+ for (yys = yyoption->yystate, yyn = yynrhs;
+ yyn > 0;
+ yys = yys->yypred, yyn -= 1)
+ yyrhsloc[yyn].yystate.yyloc = yys->yyloc;
+ }
+ else
+ {
+ /* Both yyresolveAction and yyresolveLocations traverse the GSS
+ in reverse rightmost order. It is only necessary to invoke
+ yyresolveLocations on a subforest for which yyresolveAction
+ would have been invoked next had an ambiguity not been
+ detected. Thus the location of the previous state (but not
+ necessarily the previous state itself) is guaranteed to be
+ resolved already. */
+ yyGLRState *yyprevious = yyoption->yystate;
+ yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
+ }
+ yychar_current = yychar;
+ yylval_current = yylval;
+ yylloc_current = yylloc;
+ yychar = yyoption->yyrawchar;
+ yylval = yyoption->yyval;
+ yylloc = yyoption->yyloc;
+ YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
+ yychar = yychar_current;
+ yylval = yylval_current;
+ yylloc = yylloc_current;
+ }
+ }
+}
/** Resolve the ambiguity represented in state S, perform the indicated
- * actions, and return the result. */
+ * actions, and set the semantic value of S. If result != yyok, the chain of
+ * semantic options in S has been cleared instead or it has been left
+ * unmodified except that redundant options may have been removed. Regardless
+ * of whether result = yyok, S has been left with consistent data so that
+ * yydestroyGLRState can be invoked if necessary. */
static YYRESULTTAG
-yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp, YYSTYPE* yyvalp,
- YYLTYPE* yylocp]b4_user_formals[)
+yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
{
yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
yySemanticOption* yybest;
yySemanticOption** yypp;
yybool yymerge;
+ YYSTYPE yysval;
+ YYRESULTTAG yyflag;
+ YYLTYPE *yylocp = &yys->yyloc;
yybest = yyoptionList;
yymerge = yyfalse;
switch (yypreference (yybest, yyp))
{
case 0:
- yyreportAmbiguity (yybest, yyp, yystackp]b4_pure_args[);
+ yyresolveLocations (yys, 1, yystackp]b4_user_args[);
+ return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
break;
case 1:
yymerge = yytrue;
{
yySemanticOption* yyp;
int yyprec = yydprec[yybest->yyrule];
- YYCHK (yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[));
- for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
- {
- if (yyprec == yydprec[yyp->yyrule])
- {
- YYSTYPE yyval1;
- YYLTYPE yydummy;
- YYRESULTTAG yyflag = yyresolveAction (yyp, yystackp, &yyval1,
- &yydummy]b4_user_args[);
- if (yyflag != yyok)
- {
- yydestruct ("Cleanup: discarding merged value",
- yystos[yys->yylrState],
- yyvalp]b4_location_if([, yylocp])[]b4_user_args[);
- return yyflag;
- }
- yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1);
- }
- }
- return yyok;
+ yyflag = yyresolveAction (yybest, yystackp, &yysval,
+ yylocp]b4_user_args[);
+ if (yyflag == yyok)
+ for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
+ {
+ if (yyprec == yydprec[yyp->yyrule])
+ {
+ YYSTYPE yysval_other;
+ YYLTYPE yydummy;
+ yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
+ &yydummy]b4_user_args[);
+ if (yyflag != yyok)
+ {
+ yydestruct ("Cleanup: discarding incompletely merged value for",
+ yystos[yys->yylrState],
+ &yysval]b4_locations_if([, yylocp])[]b4_user_args[);
+ break;
+ }
+ yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
+ }
+ }
}
else
- return yyresolveAction (yybest, yystackp, yyvalp, yylocp]b4_user_args[);
+ yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
+
+ if (yyflag == yyok)
+ {
+ yys->yyresolved = yytrue;
+ yys->yysemantics.yysval = yysval;
+ }
+ else
+ yys->yysemantics.yyfirstVal = NULL;
+ return yyflag;
}
static YYRESULTTAG
int yyaction;
const short int* yyconflicts;
yyRuleNum yyrule;
- yySymbol* const yytokenp = yystackp->yytokenp;
while (yystackp->yytops.yystates[yyk] != NULL)
{
}
else
{
+ yySymbol yytoken;
yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
- if (*yytokenp == YYEMPTY)
+ if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
- *yytokenp = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc);
}
- yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
+
+ if (yychar <= YYEOF)
+ {
+ yychar = yytoken = YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+ }
+
+ yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
while (*yyconflicts != 0)
{
if (yystackp->yyerrState == 0)
{
#if YYERROR_VERBOSE
- yySymbol* const yytokenp = yystackp->yytokenp;
int yyn;
yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
- if (YYPACT_NINF < yyn && yyn < YYLAST)
+ if (YYPACT_NINF < yyn && yyn <= YYLAST)
{
- size_t yysize0 = yytnamerr (NULL, yytokenName (*yytokenp));
+ yySymbol yytoken = YYTRANSLATE (yychar);
+ size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
size_t yysize = yysize0;
size_t yysize1;
yybool yysize_overflow = yyfalse;
int yyxbegin = yyn < 0 ? -yyn : 0;
/* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn;
+ int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yycount = 1;
- yyarg[0] = yytokenName (*yytokenp);
+ yyarg[0] = yytokenName (yytoken);
yyfmt = yystpcpy (yyformat, yyunexpected);
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
/* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
yylval, and yylloc are the syntactic category, semantic value, and location
- of the look-ahead. */
+ of the lookahead. */
/*ARGSUSED*/ static void
yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
{
- yySymbol* const yytokenp = yystackp->yytokenp;
size_t yyk;
int yyj;
reductions. Skip tokens until we can proceed. */
while (YYID (yytrue))
{
- if (*yytokenp == YYEOF)
+ yySymbol yytoken;
+ if (yychar == YYEOF)
yyFail (yystackp][]b4_lpure_args[, NULL);
- if (*yytokenp != YYEMPTY)
- {]b4_location_if([[
+ if (yychar != YYEMPTY)
+ {]b4_locations_if([[
/* We throw away the lookahead, but the error range
of the shifted error token must take it into account. */
yyGLRState *yys = yystackp->yytops.yystates[0];
yyGLRStackItem yyerror_range[3];
yyerror_range[1].yystate.yyloc = yys->yyloc;
yyerror_range[2].yystate.yyloc = yylloc;
- YYLLOC_DEFAULT (yys->yyloc, yyerror_range, 2);]])[
+ YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
+ yytoken = YYTRANSLATE (yychar);
yydestruct ("Error: discarding",
- *yytokenp, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+ yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
}
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
- *yytokenp = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc);
+ if (yychar <= YYEOF)
+ {
+ yychar = yytoken = YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+ }
yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
if (yyis_pact_ninf (yyj))
return;
- yyj += *yytokenp;
- if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp)
+ yyj += yytoken;
+ if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken)
{
if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
return;
&& yyisShiftAction (yytable[yyj]))
{
/* Shift the error token having adjusted its location. */
- YYLTYPE yyerrloc;]b4_location_if([[
+ YYLTYPE yyerrloc;]b4_locations_if([[
yystackp->yyerror_range[2].yystate.yyloc = yylloc;
- YYLLOC_DEFAULT (yyerrloc, yystackp->yyerror_range, 2);]])[
+ YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
&yylval, &yyerrloc);
yyglrShift (yystackp, 0, yytable[yyj],
break;
}
}
-]b4_location_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
- yydestroyGLRState ("Error: popping", yys]b4_user_args[);
+]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
+ if (yys->yypred != NULL)
+ yydestroyGLRState ("Error: popping", yys]b4_user_args[);
yystackp->yytops.yystates[0] = yys->yypred;
yystackp->yynextFree -= 1;
yystackp->yyspaceLeft += 1;
]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
{
int yyresult;
- yySymbol yytoken;
yyGLRStack yystack;
yyGLRStack* const yystackp = &yystack;
size_t yyposn;
YYDPRINTF ((stderr, "Starting parse\n"));
yychar = YYEMPTY;
- yytoken = YYEMPTY;
yylval = yyval_default;
-]b4_location_if([
+]b4_locations_if([
#if YYLTYPE_IS_TRIVIAL
- yylloc.first_line = yylloc.last_line = 1;
- yylloc.first_column = yylloc.last_column = 0;
+ yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
+ yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
#endif
])
m4_ifdef([b4_initial_action], [
m4_pushdef([b4_at_dollar], [yylloc])dnl
m4_pushdef([b4_dollar_dollar], [yylval])dnl
/* User initialization code. */
- b4_initial_action
+ b4_user_initial_action
m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])dnl
-/* Line __line__ of glr.c. */
-b4_syncline([@oline@], [@ofile@])])dnl
+m4_popdef([b4_at_dollar])])dnl
[
if (! yyinitGLRStack (yystackp, YYINITDEPTH))
goto yyexhaustedlab;
case 2: goto yyexhaustedlab;
default: goto yybuglab;
}
- yystack.yytokenp = &yytoken;
yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
yyposn = 0;
yyrule = yydefaultAction (yystate);
if (yyrule == 0)
{
-]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
+]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
yyreportSyntaxError (&yystack]b4_user_args[);
goto yyuser_error;
}
}
else
{
- if (yytoken == YYEMPTY)
+ yySymbol yytoken;
+ if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
+ }
+
+ if (yychar <= YYEOF)
+ {
+ yychar = yytoken = YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
+
yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
if (*yyconflicts != 0)
break;
if (yyisShiftAction (yyaction))
{
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- if (yytoken != YYEOF)
- {
- yychar = YYEMPTY;
- yytoken = YYEMPTY;
- }
+ yychar = YYEMPTY;
yyposn += 1;
yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
if (0 < yystack.yyerrState)
}
else if (yyisErrorAction (yyaction))
{
-]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
+]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
yyreportSyntaxError (&yystack]b4_user_args[);
goto yyuser_error;
}
{
yySymbol yytoken_to_shift;
size_t yys;
- size_t yyn = yystack.yytops.yysize;
- for (yys = 0; yys < yyn; yys += 1)
+ for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
/* yyprocessOneStack returns one of three things:
Except in the first case, yyparse will invoke yyremoveDeletes and
then shift the next token onto all remaining stacks. This
synchronization of the shift (that is, after all preceding
- reductions on all stacks) helps prevents double destructor calls
+ reductions on all stacks) helps prevent double destructor calls
on yylval in the event of memory exhaustion. */
- for (yys = 0; yys < yyn; yys += 1)
+ for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
yyremoveDeletes (&yystack);
- yyn = yystack.yytops.yysize;
+ if (yystack.yytops.yysize == 0)
+ {
+ yyundeleteLastStack (&yystack);
+ if (yystack.yytops.yysize == 0)
+ yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
+ YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
+ YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
+]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
+ yyreportSyntaxError (&yystack]b4_user_args[);
+ goto yyuser_error;
+ }
/* If any yyglrShift call fails, it will fail after shifting. Thus,
a copy of yylval will already be on stack 0 in the event of a
- failure in the following loop. Thus, yytoken is set to YYEMPTY
+ failure in the following loop. Thus, yychar is set to YYEMPTY
before the loop to make sure the user destructor for yylval isn't
called twice. */
- yytoken_to_shift = yytoken;
+ yytoken_to_shift = YYTRANSLATE (yychar);
yychar = YYEMPTY;
- yytoken = YYEMPTY;
yyposn += 1;
- for (yys = 0; yys < yyn; yys += 1)
+ for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
{
int yyaction;
const short int* yyconflicts;
(unsigned long int) yys,
yystack.yytops.yystates[yys]->yylrState));
}
- if (yystack.yytops.yysize == 0)
- {
- yyundeleteLastStack (&yystack);
- if (yystack.yytops.yysize == 0)
- yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
- YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
- YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
-]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
- yyreportSyntaxError (&yystack]b4_user_args[);
- goto yyuser_error;
- }
- else if (yystack.yytops.yysize == 1)
+
+ if (yystack.yytops.yysize == 1)
{
YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
goto yyreturn;
yyreturn:
- if (yytoken != YYEOF && yytoken != YYEMPTY)
+ if (yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead",
- yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+ YYTRANSLATE (yychar),
+ &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
/* If the stack is well-formed, pop the stack until it is empty,
destroying its entries as we go. But free the stack regardless
while (yystates[yyk])
{
yyGLRState *yys = yystates[yyk];
-]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
-)[ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
+]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
+)[ if (yys->yypred != NULL)
+ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
yystates[yyk] = yys->yypred;
yystack.yynextFree -= 1;
yystack.yyspaceLeft += 1;
yyfreeGLRStack (&yystack);
}
- return yyresult;
+ /* Make sure YYID is used. */
+ return YYID (yyresult);
}
/* DEBUGGING ONLY */
else
{
fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
- yyp->yyoption.yyrule,
+ yyp->yyoption.yyrule - 1,
(long int) YYINDEX (yyp->yyoption.yystate),
(long int) YYINDEX (yyp->yyoption.yynext));
}
]
b4_epilogue
-m4_if(b4_defines_flag, 0, [],
+b4_defines_if(
[@output @output_header_name@
-b4_copyright([Skeleton parser for GLR parsing with Bison],
- [2002, 2003, 2004, 2005, 2006])[
-
-/* C GLR parser skeleton written by Paul Hilfinger. */
-]
+b4_copyright([Skeleton interface for Bison GLR parsers in C],
+ [2002, 2003, 2004, 2005, 2006])
b4_shared_declarations
extern YYSTYPE b4_prefix[]lval;
-b4_location_if([b4_pure_if([],
+b4_locations_if([b4_pure_if([],
[extern YYLTYPE b4_prefix[]lloc;])
])
])
projects / bison.git / blobdiff