m4_divert(0)dnl
@output @output_parser_name@
b4_copyright([Skeleton parser for GLR parsing with Bison],
- [2002, 2003, 2004, 2005])
+ [2002, 2003, 2004, 2005, 2006])
[
/* This is the parser code for GLR (Generalized LR) parser. */
/* Copy the first part of user declarations. */
]b4_pre_prologue[
-#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
]m4_ifdef([b4_stype],
-[b4_syncline([b4_stype_line], [b4_file_name])
-typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
+[typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])
+b4_stype
/* Line __line__ of glr.c. */
-b4_syncline([@oline@], [@ofile@])],
+b4_syncline([@oline@], [@ofile@])
+ YYSTYPE;],
[typedef int YYSTYPE;])[
# define YYSTYPE_IS_DECLARED 1
# 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([
#endif
/* Suppress unused-variable warnings by "using" E. */
-#ifndef lint
+#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
#if YYDEBUG
-#if ! defined (YYFPRINTF)
+# ifndef YYFPRINTF
# define YYFPRINTF fprintf
-#endif
+# endif
# define YYDPRINTF(Args) \
do { \
#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_location_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 yyGLRStateSet {
yyGLRState** yystates;
+ /** During nondeterministic operation, yylookaheadNeeds tracks which
+ * stacks have actually needed the current lookahead. During deterministic
+ * operation, yylookaheadNeeds[0] is not maintained since it would merely
+ * duplicate yychar != YYEMPTY. */
+ yybool* yylookaheadNeeds;
size_t yysize, yycapacity;
};
yyRuleNum yyrule;
/** The last RHS state in the list of states to be reduced. */
yyGLRState* yystate;
+ /** The lookahead for this reduction. */
+ int yyrawchar;
+ YYSTYPE yyval;
+ YYLTYPE yyloc;
/** Next sibling in chain of options. To facilitate merging,
* options are chained in decreasing order by address. */
yySemanticOption* yynext;
YYSTYPE yyval;
YYLTYPE yyloc;
])[
- yySymbol* yytokenp;
YYJMP_BUF yyexception_buffer;
yyGLRStackItem* yyitems;
yyGLRStackItem* yynextFree;
# undef YYRECOVERING
# 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);
+ YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
]b4_location_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
]])[
switch (yyn)
{
YYFPRINTF (stderr, "%s unresolved ", yymsg);
yy_symbol_print (stderr, yystos[yys->yylrState],
- &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[]b4_user_args[);
+ NULL]b4_location_if([, &yys->yyloc])[]b4_user_args[);
YYFPRINTF (stderr, "\n");
}
#endif
return yynewItem;
}
+/** Add a new semantic action that will execute the action for rule
+ * RULENUM on the semantic values in RHS to the list of
+ * alternative actions for STATE. Assumes that RHS comes from
+ * stack #K of *STACKP. */
static void
-yyaddDeferredAction (yyGLRStack* yystackp, yyGLRState* yystate,
+yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
yyGLRState* rhs, yyRuleNum yyrule)
{
yySemanticOption* yynewOption =
&yynewGLRStackItem (yystackp, yyfalse)->yyoption;
yynewOption->yystate = rhs;
yynewOption->yyrule = yyrule;
+ if (yystackp->yytops.yylookaheadNeeds[yyk])
+ {
+ yynewOption->yyrawchar = yychar;
+ yynewOption->yyval = yylval;
+ yynewOption->yyloc = yylloc;
+ }
+ else
+ yynewOption->yyrawchar = YYEMPTY;
yynewOption->yynext = yystate->yysemantics.yyfirstVal;
yystate->yysemantics.yyfirstVal = yynewOption;
if (! yyset->yystates)
return yyfalse;
yyset->yystates[0] = NULL;
+ yyset->yylookaheadNeeds =
+ (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
+ if (! yyset->yylookaheadNeeds)
+ {
+ YYFREE (yyset->yystates);
+ return yyfalse;
+ }
return yytrue;
}
static void yyfreeStateSet (yyGLRStateSet* yyset)
{
YYFREE (yyset->yystates);
+ YYFREE (yyset->yylookaheadNeeds);
}
/** Initialize STACK to a single empty stack, with total maximum
else
{
yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];
+ /* In the current implementation, it's unnecessary to copy
+ yystackp->yytops.yylookaheadNeeds[yyi] since, after
+ yyremoveDeletes returns, the parser immediately either enters
+ deterministic operation or shifts a token. However, it doesn't
+ hurt, and the code might evolve to need it. */
+ yystackp->yytops.yylookaheadNeeds[yyj] =
+ yystackp->yytops.yylookaheadNeeds[yyi];
if (yyj != yyi)
{
YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
yystackp->yytops.yystates[yyk] = yynewState;
/* Invokes YY_RESERVE_GLRSTACK. */
- yyaddDeferredAction (yystackp, yynewState, rhs, yyrule);
+ yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule);
}
/** Pop the symbols consumed by reduction #RULE from the top of stack
{
if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
{
- yyaddDeferredAction (yystackp, yyp, yys0, yyrule);
+ yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule);
yymarkStackDeleted (yystackp, yyk);
YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
(unsigned long int) yyk,
if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
{
yyGLRState** yynewStates;
- if (! ((yystackp->yytops.yycapacity
- <= (YYSIZEMAX / (2 * sizeof yynewStates[0])))
- && (yynewStates =
- (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
- ((yystackp->yytops.yycapacity *= 2)
- * sizeof yynewStates[0])))))
+ yybool* yynewLookaheadNeeds;
+
+ yynewStates = NULL;
+
+ if (yystackp->yytops.yycapacity
+ > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
+ yyMemoryExhausted (yystackp);
+ yystackp->yytops.yycapacity *= 2;
+
+ yynewStates =
+ (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
+ (yystackp->yytops.yycapacity
+ * sizeof yynewStates[0]));
+ if (yynewStates == NULL)
yyMemoryExhausted (yystackp);
yystackp->yytops.yystates = yynewStates;
+
+ yynewLookaheadNeeds =
+ (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
+ (yystackp->yytops.yycapacity
+ * sizeof yynewLookaheadNeeds[0]));
+ if (yynewLookaheadNeeds == NULL)
+ yyMemoryExhausted (yystackp);
+ yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
}
yystackp->yytops.yystates[yystackp->yytops.yysize]
= yystackp->yytops.yystates[yyk];
+ yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize]
+ = yystackp->yytops.yylookaheadNeeds[yyk];
yystackp->yytops.yysize += 1;
return yystackp->yytops.yysize-1;
}
return 0;
}
-static YYRESULTTAG yyresolveValue (yySemanticOption* yyoptionList,
+static YYRESULTTAG yyresolveValue (yyGLRState* yys,
yyGLRStack* yystackp, YYSTYPE* yyvalp,
YYLTYPE* yylocp]b4_user_formals[);
yyresolveStates (yyGLRState* yys, int yyn,
yyGLRStack* yystackp]b4_user_formals[)
{
- YYRESULTTAG yyflag;
if (0 < yyn)
{
YYASSERT (yys->yypred);
- yyflag = yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[);
- if (yyflag != yyok)
- return yyflag;
+ YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[));
if (! yys->yyresolved)
{
- yyflag = yyresolveValue (yys->yysemantics.yyfirstVal, yystackp,
- &yys->yysemantics.yysval, &yys->yyloc
- ]b4_user_args[);
+ YYSTYPE yysval;
+ YYRESULTTAG yyflag = yyresolveValue (yys, yystackp, &yysval,
+ &yys->yyloc]b4_user_args[);
if (yyflag != yyok)
- return yyflag;
+ {
+ yys->yysemantics.yyfirstVal = NULL;
+ return yyflag;
+ }
+ yys->yysemantics.yysval = yysval;
yys->yyresolved = yytrue;
}
}
{
yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
int yynrhs;
+ int yychar_current;
+ YYSTYPE yylval_current;
+ YYLTYPE yylloc_current;
+ YYRESULTTAG yyresult;
yynrhs = yyrhsLength (yyopt->yyrule);
YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[));
if (yynrhs == 0)
/* Set default location. */
yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
- return yyuserAction (yyopt->yyrule, yynrhs,
- yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
- yyvalp, yylocp, yystackp]b4_user_args[);
+ yychar_current = yychar;
+ yylval_current = yylval;
+ yylloc_current = yylloc;
+ yychar = yyopt->yyrawchar;
+ yylval = yyopt->yyval;
+ yylloc = yyopt->yyloc;
+ yyresult = 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;
}
#if YYDEBUG
static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
yyGLRStack* yystackp]b4_pure_formals[)
__attribute__ ((__noreturn__));
-static void
+/*ARGSUSED*/ static void
yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
yyGLRStack* yystackp]b4_pure_formals[)
{
}
-/** Resolve the ambiguity represented by OPTIONLIST, perform the indicated
+/** Resolve the ambiguity represented in state S, perform the indicated
* actions, and return the result. */
static YYRESULTTAG
-yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystackp,
- YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
+yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp, YYSTYPE* yyvalp,
+ YYLTYPE* yylocp]b4_user_formals[)
{
+ yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
yySemanticOption* yybest;
yySemanticOption** yypp;
yybool yymerge;
{
YYSTYPE yyval1;
YYLTYPE yydummy;
- YYCHK (yyresolveAction (yyp, yystackp, &yyval1,
- &yydummy]b4_user_args[));
+ 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);
}
}
int yyaction;
const short int* yyconflicts;
yyRuleNum yyrule;
- yySymbol* const yytokenp = yystackp->yytokenp;
while (yystackp->yytops.yystates[yyk] != NULL)
{
}
else
{
- if (*yytokenp == YYEMPTY)
+ yySymbol yytoken;
+ yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
+ if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
- *yytokenp = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc);
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
- yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
+ else
+ yytoken = YYTRANSLATE (yychar);
+ 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)
{
- 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 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)
/*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)
+ if (yychar != YYEMPTY)
{]b4_location_if([[
/* We throw away the lookahead, but the error range
of the shifted error token must take it into account. */
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_location_if([, &yylloc])[]b4_user_args[);
}
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
- *yytokenp = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", *yytokenp, &yylval, &yylloc);
+ 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;
/* Shift the error token having adjusted its location. */
YYLTYPE yyerrloc;]b4_location_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],
]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"));
- yytoken = YYEMPTY;
+ yychar = YYEMPTY;
yylval = yyval_default;
]b4_location_if([
#if YYLTYPE_IS_TRIVIAL
case 2: goto yyexhaustedlab;
default: goto yybuglab;
}
- yystack.yytokenp = &yytoken;
yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
yyposn = 0;
}
else
{
- if (yytoken == YYEMPTY)
+ yySymbol yytoken;
+ if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
+ else
+ yytoken = YYTRANSLATE (yychar);
yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
if (*yyconflicts != 0)
break;
if (yyisShiftAction (yyaction))
{
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- if (yytoken != YYEOF)
- yytoken = YYEMPTY;
+ if (yychar != YYEOF)
+ yychar = YYEMPTY;
yyposn += 1;
yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
if (0 < yystack.yyerrState)
size_t yys;
size_t yyn = yystack.yytops.yysize;
+ for (yys = 0; yys < yyn; yys += 1)
+ yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
+
/* yyprocessOneStack returns one of three things:
- An error flag. If the caller is yyprocessOneStack, it
/* 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 = YYEMPTY;
+ yytoken_to_shift = YYTRANSLATE (yychar);
+ yychar = YYEMPTY;
yyposn += 1;
for (yys = 0; yys < yyn; yys += 1)
{
goto yyreturn;
yyreturn:
- if (yytoken != YYEOF && yytoken != YYEMPTY)
+ if (yychar != YYEOF && yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead",
- yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+ YYTRANSLATE (yychar),
+ &yylval]b4_location_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
m4_if(b4_defines_flag, 0, [],
[@output @output_header_name@
b4_copyright([Skeleton parser for GLR parsing with Bison],
- [2002, 2003, 2004, 2005])[
+ [2002, 2003, 2004, 2005, 2006])[
/* C GLR parser skeleton written by Paul Hilfinger. */
]
projects / bison.git / blobdiff