m4_divert(-1) -*- C -*-
-m4_include([c.m4])
# GLR skeleton for Bison
-# Copyright (C) 2002 Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
m4_define_default([b4_stack_depth_max], [10000])
m4_define_default([b4_stack_depth_init], [200])
-# Location type.
-m4_define_default([b4_location_type], [yyltype])
-
## ------------------------ ##
m4_changecom()
m4_divert(0)dnl
@output @output_parser_name@
-b4_copyright([Skeleton parser for GLR parsing with Bison], [2002])
+b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003])
[
/* This is the parser code for GLR (Generalized LR) parser. */
-#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
# define YYERROR_VERBOSE ]b4_error_verbose[
#endif
-#ifndef YYSTYPE
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
]m4_ifdef([b4_stype],
[b4_syncline([b4_stype_line], [b4_filename])
-typedef union b4_stype yystype;
-/* Line __line__ of __file__. */
+typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
+/* Line __line__ of glr.c. */
b4_syncline([@oline@], [@ofile@])],
-[typedef int yystype;])[
-# define YYSTYPE yystype
+[typedef int YYSTYPE;])[
+# define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1
#endif
-#ifndef YYLTYPE
-typedef struct yyltype
+#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+typedef struct YYLTYPE
{
int first_line;
int first_column;
int last_line;
int last_column;
-} yyltype;
-# define YYLTYPE ]b4_location_type[
+} YYLTYPE;
+# define YYLTYPE_IS_DECLARED 1
# define YYLTYPE_IS_TRIVIAL 1
#endif
/* Default (constant) values used for initialization for null
- right-hand sides. Unlike the standard bison.simple template,
+ right-hand sides. Unlike the standard yacc.c template,
here we set the default values of $$ and $@@ to zeroed-out
values. Since the default value of these quantities is undefined,
this behavior is technically correct. */
/* Copy the second part of user declarations. */
]b4_post_prologue[
-]/* Line __line__ of __file__. */
+]/* Line __line__ of glr.c. */
b4_syncline([@oline@], [@ofile@])
[
-#if ! defined (__cplusplus)
- typedef char bool;
-# define yytrue 1
-# define yyfalse 0
+#ifdef __cplusplus
+ typedef bool yybool;
+#else
+ typedef unsigned char yybool;
#endif
+#define yytrue 1
+#define yyfalse 0
/*-----------------.
| GCC extensions. |
/* 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[] =
{
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 YYDSYMPRINT(Args) {}
+# define YYDPRINTF(Args)
+# define YYDSYMPRINT(Args)
+# define YYDSYMPRINTF(Title, Token, Value, Location)
#endif /* !YYDEBUG */
properly redirected to new data. */
#define YYHEADROOM 2
-#if ! defined (YYSTACKEXPANDABLE) \
- && (! defined (__cplusplus) || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
+#if (! defined (YYSTACKEXPANDABLE) \
+ && (! defined (__cplusplus) \
+ || (]b4_location_if([YYLTYPE_IS_TRIVIAL && ])[YYSTYPE_IS_TRIVIAL)))
#define YYSTACKEXPANDABLE 1
#else
#define YYSTACKEXPANDABLE 0
typedef struct yyGLRStateSet yyGLRStateSet;
struct yyGLRState {
- bool yyisState;
- bool yyresolved;
+ yybool yyisState;
+ yybool yyresolved;
yyStateNum yylrState;
yyGLRState* yypred;
size_t yyposn;
};
struct yySemanticOption {
- bool yyisState;
+ yybool yyisState;
yyRuleNum yyrule;
yyGLRState* yystate;
yySemanticOption* yynext;
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);
}
# undef YYBACKUP
# undef yyclearin
# undef YYRECOVERING
-/* Line __line__ of __file__. */
+/* Line __line__ of glr.c. */
b4_syncline([@oline@], [@ofile@])
}
\f
/** True iff LR state STATE has only a default reduction (regardless
* of token). */
-static inline bool
+static inline yybool
yyisDefaultedState (yyStateNum yystate)
{
return yyis_pact_ninf (yypact[yystate]);
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];
return yydefgoto[yylhs - YYNTOKENS];
}
-static inline bool
+static inline yybool
yyisShiftAction (int yyaction)
{
return 0 < yyaction;
}
-static inline bool
+static inline yybool
yyisErrorAction (int yyaction)
{
return yyaction == 0;
/* 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;
yyn -= 1, yyp0 += 1, yyp1 += 1)
{
*yyp1 = *yyp0;
- if (*(bool*) yyp0)
+ if (*(yybool *) yyp0)
{
yyGLRState* yys0 = &yyp0->yystate;
yyGLRState* yys1 = &yyp1->yystate;
#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;
{
/* 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]));
+ unsigned int yylineno = yyrline[yyrule];
+ YYFPRINTF (stderr, "Reducing stack %d by rule %d (line %u), ",
+ yyk, yyrule - 1, yylineno);
/* 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
*/
static inline YYRESULTTAG
yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
- bool yyforceEval]b4_pure_formals[)
+ yybool yyforceEval]b4_pure_formals[)
{
size_t yyposn = yystack->yytops.yystates[yyk]->yyposn;
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));
{
if (yystack->yysplitPoint == NULL)
{
- assert (yyk == 0);
+ if (yyk != 0)
+ abort ();
yystack->yysplitPoint = yystack->yytops.yystates[yyk];
}
if (yystack->yytops.yysize >= yystack->yytops.yycapacity)
/** True iff Y0 and Y1 represent identical options at the top level.
* That is, they represent the same rule applied to RHS symbols
* that produce the same terminal symbols. */
-static bool
+static yybool
yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
{
if (yyy0->yyrule == yyy1->yyrule)
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 (yystack->yytops.yystates[0] != NULL)
{
yyGLRState *yys = yystack->yytops.yystates[0];
- YYDPRINTF ((stderr, "Error: popping "));
- YYDSYMPRINT ((stderr,
+ YYDSYMPRINTF ("Error: popping",
yystos[yys->yylrState],
- &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[));
- YYDPRINTF ((stderr, "\n"));
+ &yys->yysemantics.yysval, &yys->yyloc);
yydestruct (yystos[yys->yylrState],
&yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
yystack->yytops.yystates[0] = yys->yypred;
}
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. */
break;
}
}
- YYDPRINTF ((stderr, "Error: popping "));
- YYDSYMPRINT ((stderr,
+ YYDSYMPRINTF ("Error: popping",
yystos[yys->yylrState],
- &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[));
- YYDPRINTF ((stderr, "\n"));
+ &yys->yysemantics.yysval, &yys->yyloc);
yydestruct (yystos[yys->yylrState],
&yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
yystack->yytops.yystates[0] = yys->yypred;
/* 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:
for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1)
{
fprintf (stderr, "%3lu. ", (unsigned long) (yyp - yystack->yyitems));
- if (*(bool*) yyp)
+ if (*(yybool *) yyp)
{
fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
yyp->yystate.yyresolved, yyp->yystate.yylrState,
b4_epilogue
m4_if(b4_defines_flag, 0, [],
[@output @output_header_name@
-b4_copyright([Skeleton parser for GLR parsing with Bison], [2002])
+b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003])
b4_token_defines(b4_tokens)
-#ifndef YYSTYPE
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
m4_ifdef([b4_stype],
[b4_syncline([b4_stype_line], [b4_filename])
-typedef union b4_stype yystype;
-/* Line __line__ of __file__. */
+typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
+/* Line __line__ of glr.c. */
b4_syncline([@oline@], [@ofile@])],
-[typedef int yystype;])
-# define YYSTYPE yystype
+[typedef int YYSTYPE;])
+# define YYSTYPE_IS_DECLARED 1
# define YYSTYPE_IS_TRIVIAL 1
#endif
[extern YYSTYPE b4_prefix[]lval;])
b4_location_if(
-[#ifndef YYLTYPE
-typedef struct yyltype
+[#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+typedef struct YYLTYPE
{
int first_line;
int first_column;
int last_line;
int last_column;
-} yyltype;
-# define YYLTYPE yyltype
+} YYLTYPE;
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
#endif
m4_if(b4_pure, [0],
projects / bison.git / blobdiff