[
/* This is the parser code for GLR (Generalized LR) parser. */
-#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
#endif
-#if ! defined (__GNUC__)
-# define inline
-#endif
-
/* YYFINAL -- State number of the termination state. */
#define YYFINAL ]b4_final_state_number[
/* YYLAST -- Last index in YYTABLE. */
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which
number is the opposite. If zero, do what YYDEFACT says.
- If YYTABLE_NINF, parse error. */
+ If YYTABLE_NINF, syntax error. */
#define YYTABLE_NINF ]b4_table_ninf[
static const ]b4_int_type_for([b4_table])[ yytable[] =
{
]b4_check[
};
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
+static const ]b4_int_type_for([b4_stos])[ yystos[] =
+{
+ ]b4_stos[
+};
+
\f
/* Prevent warning if -Wmissing-prototypes. */
]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[
if (yydebug) \
YYFPRINTF Args; \
} while (0)
+
+]b4_yysymprint_generate([b4_c_ansi_function_def])[
+
+# define YYDSYMPRINT(Args) \
+do { \
+ if (yydebug) \
+ yysymprint Args; \
+} while (0)
+
+# define YYDSYMPRINTF(Title, Token, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yysymprint (stderr, \
+ Token, Value]b4_location_if([, Location])[); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (0)
+
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
int yydebug;
+
#else /* !YYDEBUG */
+
/* Avoid empty `if' bodies. */
-# define YYDPRINTF(Args) {}
+# define YYDPRINTF(Args)
+# define YYDSYMPRINT(Args)
+# define YYDSYMPRINTF(Title, Token, Value, Location)
+
#endif /* !YYDEBUG */
/* YYINITDEPTH -- initial size of the parser's stacks. */
static void
yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yyformat, ...)
{
+ yystack->yyerrflag = 1;
if (yyformat != NULL)
{
char yymsg[256];
va_list yyap;
va_start (yyap, yyformat);
- yystack->yyerrflag = 1;
vsprintf (yymsg, yyformat, yyap);
yyerror (]b4_yyerror_args[yymsg);
}
*yyvalp = yyvsp[1-yyrhslen].yystate.yysemantics.yysval;
*yylocp = yyvsp[1-yyrhslen].yystate.yyloc;
}
-# undef yyval
-# define yyval (*yyvalp)
# undef yyerrok
# define yyerrok (yystack->yyerrState = 0)
# undef YYACCEPT
}
return yyok;
-# undef yyval
# undef yyerrok
# undef YYABORT
# undef YYACCEPT
[
/* Bison grammar-table manipulation. */
+]b4_yydestruct_generate([b4_c_ansi_function_def])[
+
/** Number of symbols composing the right hand side of rule #RULE. */
static inline int
yyrhsLength (yyRuleNum yyrule)
return yydefact[yystate];
}
-#define yyis_table_ninf(yyindex) \
+#define yyis_table_ninf(yytable_value) \
]m4_if(m4_eval(b4_table_ninf < b4_table_min), 1,
0,
- ((yyindex) == YYTABLE_NINF))[
+ ((yytable_value) == YYTABLE_NINF))[
/** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
* Result R means
*yyaction = -yydefact[yystate];
*yyconflicts = yyconfl;
}
- else if (! yyis_table_ninf (yyindex))
+ else if (! yyis_table_ninf (yytable[yyindex]))
{
*yyaction = yytable[yyindex];
*yyconflicts = yyconfl + yyconflp[yyindex];
/* GLRStates */
-/** True iff the semantic value of the edge leading to STATE is
- * resolved. */
-static inline bool
-yyhasResolvedValue (yyGLRState* yystate)
-{
- return yystate->yyresolved;
-}
-
static void
yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,
yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
size_t yyn;
yysize = yystack->yynextFree - yystack->yyitems;
if (YYMAXDEPTH <= yysize)
- yyFail (yystack][]b4_pure_args[,
- "parsing stack overflow (%d items)", yysize);
+ yyFail (yystack][]b4_pure_args[, "parser stack overflow");
yynewSize = 2*yysize;
if (YYMAXDEPTH < yynewSize)
yynewSize = YYMAXDEPTH;
#else
- yyFail (yystack][]b4_lpure_args[,
- "parsing stack overflow (%d items)", yysize);
+ yyFail (yystack][]b4_lpure_args[, "parser stack overflow");
#endif
}
if (yystack->yytops.yystates[yyi] == NULL)
{
if (yyi == yyj)
- YYDPRINTF ((stderr, "Removing dead stacks.\n"));
+ {
+ YYDPRINTF ((stderr, "Removing dead stacks.\n"));
+ }
yystack->yytops.yysize -= 1;
}
else
{
yystack->yytops.yystates[yyj] = yystack->yytops.yystates[yyi];
if (yyj != yyi)
- YYDPRINTF ((stderr, "Rename stack %d -> %d.\n", yyi, yyj));
+ {
+ YYDPRINTF ((stderr, "Rename stack %d -> %d.\n", yyi, yyj));
+ }
yyj += 1;
}
yyi += 1;
* have been previously resolved. Set *VALP to the resulting value,
* and *LOCP to the computed location (if any). Return value is as
* for userAction. */
-static inline int
+static inline YYRESULTTAG
yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
{
{
/* Standard special case: single stack. */
yyGLRStackItem* rhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk];
- assert (yyk == 0);
+ if (yyk != 0)
+ abort ();
yystack->yynextFree -= yynrhs;
yystack->yyspaceLeft += yynrhs;
yystack->yytops.yystates[0] = & yystack->yynextFree[-1].yystate;
for (yyi = yynrhs-1, yys = yystack->yytops.yystates[yyk]; 0 <= yyi;
yyi -= 1, yys = yys->yypred)
{
- assert (yys->yypred != NULL);
+ if (! yys->yypred)
+ abort ();
yyrhsVals[yyi].yystate.yyresolved = yytrue;
yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
yyrhsVals[yyi].yystate.yyloc = yys->yyloc;
yy_reduce_print (size_t yyk, yyRuleNum yyrule)
{
int yyi;
- YYDPRINTF ((stderr, "Reducing stack %d by rule %d (line %d),",
- yyk, yyrule - 1, yyrline[yyrule]));
+ YYFPRINTF (stderr, "Reducing stack %d by rule %d (line %d), ",
+ yyk, yyrule - 1, yyrline[yyrule]);
/* Print the symbols being reduced, and their result. */
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi]));
- YYFPRINTF (stderr, " -> %s\n", yytokenName (yyr1[yyrule]));
+ YYFPRINTF (stderr, "-> %s\n", yytokenName (yyr1[yyrule]));
}
#endif
yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState,
yylhsNonterm (yyrule)),
yyposn, yysval, &yyloc]b4_user_args[);
- YYDPRINTF ((stderr, "Stack %d entering state %d\n",
- yyk, yystack->yytops.yystates[yyk]->yylrState));
}
else
{
0 < yyn; yyn -= 1)
{
yys = yys->yypred;
- assert (yys != NULL);
+ if (! yys)
+ abort ();
}
yyupdateSplit (yystack, yys);
yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
yymarkStackDeleted (yystack, yyk);
YYDPRINTF ((stderr, "Merging stack %d into stack %d.\n",
yyk, yyi));
- return 0;
+ return yyok;
}
yyp = yyp->yypred;
}
yystack->yytops.yystates[yyk] = yys;
yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule]b4_pure_args[);
}
- return 0;
+ return yyok;
}
static int
{
if (yystack->yysplitPoint == NULL)
{
- assert (yyk == 0);
+ if (yyk != 0)
+ abort ();
yystack->yysplitPoint = yystack->yytops.yystates[yyk];
}
if (yystack->yytops.yysize >= yystack->yytops.yycapacity)
yySemanticOption* yyz;
for (yyz = yys0->yysemantics.yyfirstVal; yyz->yynext != NULL;
yyz = yyz->yynext)
- ;
+ continue;
yyz->yynext = yys1->yysemantics.yyfirstVal;
}
}
YYRESULTTAG yyflag;
if (0 < yyn)
{
- assert (yys->yypred != NULL);
+ if (! yys->yypred)
+ abort ();
yyflag = yyresolveStates (yys->yypred, yyn-1, yystack]b4_user_args[);
if (yyflag != yyok)
return yyflag;
for (yyi = yynrhs-1, yys = yyopt->yystate; 0 <= yyi;
yyi -= 1, yys = yys->yypred)
{
- assert (yys->yypred != NULL);
+ if (! yys->yypred)
+ abort ();
yyrhsVals[yyi].yystate.yyresolved = yytrue;
yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
yyrhsVals[yyi].yystate.yyloc = yys->yyloc;
for (yyn = 0, yys = yystack->yytops.yystates[0];
yys != yystack->yysplitPoint;
yys = yys->yypred, yyn += 1)
- ;
+ continue;
YYCHK (yyresolveStates (yystack->yytops.yystates[0], yyn, yystack
]b4_user_args[));
}
while (yystack->yytops.yystates[yyk] != NULL)
{
yyStateNum yystate = yystack->yytops.yystates[yyk]->yylrState;
+ YYDPRINTF ((stderr, "Stack %d Entering state %d\n", yyk, yystate));
- assert (yystate != YYFINAL);
+ if (yystate == YYFINAL)
+ abort ();
if (yyisDefaultedState (yystate))
{
yyrule = yydefaultAction (yystate);
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
*yytokenp = YYTRANSLATE (yychar);
- YYDPRINTF ((stderr, "Next token is %s\n",
- yytokenName (*yytokenp)));
+ YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
}
yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
}
static void
-yyreportParseError (yyGLRStack* yystack,
- YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
+yyreportSyntaxError (yyGLRStack* yystack,
+ YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
{
/* `Unused' warnings. */
(void) yylvalp;
yycount = 0;
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. */
- yysize = sizeof ("parse error, unexpected ")
+ yysize = sizeof ("syntax error, unexpected ")
+ strlen (yytokenName (*yytokenp));
yyprefix = ", expecting ";
for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5;
yysize += strlen (yytokenName (yyx)) + strlen (yyprefix),
yycount += 1, yyprefix = " or ";
yymsg = yyp = (char*) malloc (yysize);
- sprintf (yyp, "parse error, unexpected %s", yytokenName (*yytokenp));
+ sprintf (yyp, "syntax error, unexpected %s",
+ yytokenName (*yytokenp));
yyp += strlen (yyp);
if (yycount < 5)
{
}
else
#endif
- yyerror (]b4_lyyerror_args["parse error");
+ yyerror (]b4_lyyerror_args["syntax error");
yynerrs += 1;
}
}
YYLVALP, and YYLLOCP point to the syntactic category, semantic
value, and location of the lookahead. */
static void
-yyrecoverParseError (yyGLRStack* yystack,
- YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
+yyrecoverSyntaxError (yyGLRStack* yystack,
+ YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
{
yySymbol* const yytokenp = yystack->yytokenp;
size_t yyk;
while (yytrue)
{
if (*yytokenp == YYEOF)
- yyFail (yystack][]b4_lpure_args[, NULL);
+ {
+ /* Now pop stack until we find a state that shifts the
+ error token. */
+ while (yystack->yytops.yystates[0] != NULL)
+ {
+ yyGLRState *yys = yystack->yytops.yystates[0];
+ YYDSYMPRINTF ("Error: popping",
+ yystos[yys->yylrState],
+ &yys->yysemantics.yysval, &yys->yyloc);
+ yydestruct (yystos[yys->yylrState],
+ &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
+ yystack->yytops.yystates[0] = yys->yypred;
+ yystack->yynextFree -= 1;
+ yystack->yyspaceLeft += 1;
+ }
+ yyFail (yystack][]b4_lpure_args[, NULL);
+ }
if (*yytokenp != YYEMPTY)
- YYDPRINTF ((stderr, "Discarding token %s\n",
- yytokenName (*yytokenp)));
+ {
+ YYDSYMPRINTF ("Error: discarding", *yytokenp, yylvalp, yyllocp);
+ yydestruct (*yytokenp, yylvalp]b4_location_if([, yyllocp])[);
+ }
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
*yytokenp = YYTRANSLATE (yychar);
- YYDPRINTF ((stderr, "Next token is %s\n", yytokenName (*yytokenp)));
+ YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
yyj = yypact[yystack->yytops.yystates[0]->yylrState];
if (yyis_pact_ninf (yyj))
/* Something's not right; we shouldn't be here. */
/* Now pop stack until we find a state that shifts the error token. */
while (yystack->yytops.yystates[0] != NULL)
{
- yyj = yypact[yystack->yytops.yystates[0]->yylrState];
+ yyGLRState *yys = yystack->yytops.yystates[0];
+ yyj = yypact[yys->yylrState];
if (! yyis_pact_ninf (yyj))
{
yyj += YYTERROR;
if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
&& yyisShiftAction (yytable[yyj]))
{
+ YYDPRINTF ((stderr, "Shifting error token, "));
yyglrShift (yystack, 0, yytable[yyj],
- yystack->yytops.yystates[0]->yyposn,
- *yylvalp, yyllocp]b4_user_args[);
+ yys->yyposn, *yylvalp, yyllocp]b4_user_args[);
break;
}
}
- yystack->yytops.yystates[0] = yystack->yytops.yystates[0]->yypred;
+ YYDSYMPRINTF ("Error: popping",
+ yystos[yys->yylrState],
+ &yys->yysemantics.yysval, &yys->yyloc);
+ yydestruct (yystos[yys->yylrState],
+ &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
+ yystack->yytops.yystates[0] = yys->yypred;
yystack->yynextFree -= 1;
yystack->yyspaceLeft += 1;
}
/* For efficiency, we have two loops, the first of which is
specialized to deterministic operation (single stack, no
potential ambiguity). */
-
/* Standard mode */
while (yytrue)
{
const short* yyconflicts;
yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
if (yystate == YYFINAL)
goto yyDone;
if (yyisDefaultedState (yystate))
yyrule = yydefaultAction (yystate);
if (yyrule == 0)
{
- yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
+ yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
goto yyuser_error;
}
YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_lpure_args[));
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
yytoken = YYTRANSLATE (yychar);
- YYDPRINTF ((stderr, "Next token is %s\n",
- yytokenName (yytoken)));
+ YYDSYMPRINTF ("Next token is", yytoken, yylvalp, yyllocp);
}
yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
if (*yyconflicts != 0)
yylval, yyllocp]b4_user_args[);
if (0 < yystack.yyerrState)
yystack.yyerrState -= 1;
- YYDPRINTF ((stderr, "Entering state %d\n",
- yystack.yytops.yystates[0]->yylrState));
}
else if (yyisErrorAction (yyaction))
{
- yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
+ yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
goto yyuser_error;
}
else
{
yyundeleteLastStack (&yystack);
if (yystack.yytops.yysize == 0)
- yyFail (&yystack][]b4_lpure_args[, "parse error");
+ yyFail (&yystack][]b4_lpure_args[, "syntax error");
YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
- yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
+ yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
goto yyuser_error;
}
else if (yystack.yytops.yysize == 1)
}
continue;
yyuser_error:
- yyrecoverParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
+ yyrecoverSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
yyposn = yystack.yytops.yystates[0]->yyposn;
}
yyDone:
projects / bison.git / blobdiff