# b4_lyyerror_args
# ----------------
-# Same as above, but on the lookahead, hence yyllocp instead of yylocp.
+# Same as above, but on the look-ahead, hence yyllocp instead of yylocp.
m4_define([b4_lyyerror_args],
[b4_pure_if([b4_location_if([yyllocp, ])])dnl
m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
# b4_lpure_args
# -------------
-# Same as above, but on the lookahead, hence yyllocp instead of yylocp.
+# Same as above, but on the look-ahead, hence yyllocp instead of yylocp.
m4_define([b4_lpure_args],
[b4_pure_if([b4_location_if([, yyllocp])])[]b4_user_args])
# b4_lpure_formals
# ----------------
-# Same as above, but on the lookahead, hence yyllocp instead of yylocp.
+# Same as above, but on the look-ahead, hence yyllocp instead of yylocp.
m4_define([b4_lpure_formals],
[b4_pure_if([b4_location_if([YYLTYPE *yyllocp])])[]b4_user_formals])
m4_changecom()
m4_divert(0)dnl
@output @output_parser_name@
-b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003])
+b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003, 2004])
[
/* This is the parser code for GLR (Generalized LR) parser. */
#define yychar b4_prefix[]char
#define yydebug b4_prefix[]debug
#define yynerrs b4_prefix[]nerrs
-b4_location_if([#define yylloc b4_prefix[]lloc])])
+#define yylloc b4_prefix[]lloc])
b4_token_defines(b4_tokens)
#define YYTRANSLATE(YYX) \
((YYX <= 0) ? YYEOF : \
- (unsigned)(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[] =
/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
0, pointed into by YYCONFLP. */
]dnl Do not use b4_int_type_for here, since there are places where
-dnl pointers onto yyconfl are taken, which type is "short *".
+dnl pointers onto yyconfl are taken, which type is "short int *".
dnl We probably ought to introduce a type for confl.
-[static const short yyconfl[] =
+[static const short int yyconfl[] =
{
]b4_conflicting_rules[
};
/* Error token number */
#define YYTERROR 1
-/* YYLLOC_DEFAULT -- Compute the default location (before the actions
- are run). */
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. */
]b4_location_if([[
#define YYRHSLOC(yyRhs,YYK) ((yyRhs)[YYK].yystate.yyloc)
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN) \
- ((yyCurrent).first_line = YYRHSLOC(yyRhs, 1).first_line, \
+ ((yyCurrent).first_line = YYRHSLOC(yyRhs, 1).first_line, \
(yyCurrent).first_column = YYRHSLOC(yyRhs, 1).first_column, \
- (yyCurrent).last_line = YYRHSLOC(yyRhs, YYN).last_line, \
+ (yyCurrent).last_line = YYRHSLOC(yyRhs, YYN).last_line, \
(yyCurrent).last_column = YYRHSLOC(yyRhs, YYN).last_column)
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+ This macro was not mandated originally: define only if we know
+ we won't break user code: when these are the locations we know. */
+
+# define YY_LOCATION_PRINT(File, Loc) \
+ fprintf (File, "%d.%d-%d.%d", \
+ (Loc).first_line, (Loc).first_column, \
+ (Loc).last_line, (Loc).last_column)
#endif
]],[
#ifndef YYLLOC_DEFAULT
#endif
])[
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
/* YYLEX -- calling `yylex' with the right arguments. */
#define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
]b4_yysymprint_generate([b4_c_ansi_function_def])[
-# define YYDSYMPRINT(Args) \
-do { \
- if (yydebug) \
- yysymprint Args; \
-} while (0)
-
-# define YYDSYMPRINTF(Title, Token, Value, Location) \
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yysymprint (stderr, \
- Token, Value]b4_location_if([, Location])[); \
+ Type, Value]b4_location_if([, Location])[); \
YYFPRINTF (stderr, "\n"); \
} \
} while (0)
#else /* !YYDEBUG */
- /* Avoid empty `if' bodies. */
# define YYDPRINTF(Args)
-# define YYDSYMPRINT(Args)
-# define YYDSYMPRINTF(Title, Token, Value, Location)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
#endif /* !YYDEBUG */
typedef int yyRuleNum;
/** Grammar symbol */
-typedef short yySymbol;
+typedef short int yySymbol;
/** Item references, as in LALR(1) machine */
-typedef short yyItemNum;
+typedef short int yyItemNum;
typedef struct yyGLRState yyGLRState;
typedef struct yySemanticOption yySemanticOption;
if (yyrhslen == 0)
{
*yyvalp = yyval_default;
- *yylocp = yyloc_default;
+ *yylocp = yyvsp[0].yystate.yyloc;
}
else
{
*/
static inline void
yygetLRActions (yyStateNum yystate, int yytoken,
- int* yyaction, const short** yyconflicts)
+ int* yyaction, const short int** yyconflicts)
{
int yyindex = yypact[yystate] + yytoken;
if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)
]b4_user_formals[)
{
int yyaction;
- const short* yyconflicts;
+ const short int* yyconflicts;
yyRuleNum yyrule;
yySymbol* const yytokenp = yystack->yytokenp;
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
*yytokenp = YYTRANSLATE (yychar);
- YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
+ YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);
}
yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
if (yyisShiftAction (yyaction))
{
- YYDPRINTF ((stderr, "Shifting token %s on stack %d, ",
- yytokenName (*yytokenp), yyk));
+ YYDPRINTF ((stderr, "On stack %d, ", yyk));
+ YY_SYMBOL_PRINT ("shifting", *yytokenp, yylvalp, yyllocp);
yyglrShift (yystack, yyk, yyaction, yyposn+1,
*yylvalp, yyllocp]b4_user_args[);
- YYDPRINTF ((stderr, "which is now in state #%d\n",
+ YYDPRINTF ((stderr, ", now in state #%d\n",
yystack->yytops.yystates[yyk]->yylrState));
break;
}
/* Recover from a syntax error on YYSTACK, assuming that YYTOKENP,
YYLVALP, and YYLLOCP point to the syntactic category, semantic
- value, and location of the lookahead. */
+ value, and location of the look-ahead. */
static void
yyrecoverSyntaxError (yyGLRStack* yystack,
YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
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],
+ yydestruct ("Error: popping",
+ yystos[yys->yylrState],
&yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
yystack->yytops.yystates[0] = yys->yypred;
yystack->yynextFree -= 1;
yyFail (yystack][]b4_lpure_args[, NULL);
}
if (*yytokenp != YYEMPTY)
- {
- YYDSYMPRINTF ("Error: discarding", *yytokenp, yylvalp, yyllocp);
- yydestruct (*yytokenp, yylvalp]b4_location_if([, yyllocp])[);
- }
+ yydestruct ("Error: discarding",
+ *yytokenp, yylvalp]b4_location_if([, yyllocp])[);
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
*yytokenp = YYTRANSLATE (yychar);
- YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
+ YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);
yyj = yypact[yystack->yytops.yystates[0]->yylrState];
if (yyis_pact_ninf (yyj))
return;
if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
&& yyisShiftAction (yytable[yyj]))
{
- YYDPRINTF ((stderr, "Shifting error token, "));
+ YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
+ yylvalp, yyllocp);
yyglrShift (yystack, 0, yytable[yyj],
yys->yyposn, *yylvalp, yyllocp]b4_user_args[);
break;
}
}
- YYDSYMPRINTF ("Error: popping",
- yystos[yys->yylrState],
- &yys->yysemantics.yysval, &yys->yyloc);
- yydestruct (yystos[yys->yylrState],
+ yydestruct ("Error: popping",
+ yystos[yys->yylrState],
&yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
yystack->yytops.yystates[0] = yys->yypred;
yystack->yynextFree -= 1;
if (setjmp (yystack.yyexception_buffer) != 0)
goto yyDone;
- yyglrShift (&yystack, 0, 0, 0, yyval_default, &yyloc_default]b4_user_args[);
+ yylval = yyval_default;
+]b4_location_if([
+#if YYLTYPE_IS_TRIVIAL
+ yylloc.first_line = yylloc.last_line = 1;
+ yylloc.first_column = yylloc.last_column = 0;
+#endif
+])
+m4_ifdef([b4_initial_action], [
+m4_pushdef([b4_at_dollar], [yylval])dnl
+m4_pushdef([b4_dollar_dollar], [yylloc])dnl
+ /* User initialization code. */
+ b4_initial_action
+m4_popdef([b4_dollar_dollar])dnl
+m4_popdef([b4_at_dollar])dnl
+/* Line __line__ of glr.c. */
+b4_syncline([@oline@], [@ofile@])])dnl
+[
+ yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc]b4_user_args[);
yytoken = YYEMPTY;
yyposn = 0;
{
yyRuleNum yyrule;
int yyaction;
- const short* yyconflicts;
+ const short int* yyconflicts;
yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
yytoken = YYTRANSLATE (yychar);
- YYDSYMPRINTF ("Next token is", yytoken, yylvalp, yyllocp);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, yylvalp, yyllocp);
}
yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
if (*yyconflicts != 0)
break;
if (yyisShiftAction (yyaction))
{
- YYDPRINTF ((stderr, "Shifting token %s, ",
- yytokenName (yytoken)));
+ YY_SYMBOL_PRINT ("Shifting", yytoken, yylvalp, yyllocp);
if (yytoken != YYEOF)
yytoken = YYEMPTY;
yyposn += 1;
yyposn = yystack.yytops.yystates[0]->yyposn;
}
yyDone:
- ;
+ /* On YYABORT, free the lookahead. */
+ if (yystack.yyerrflag == 1 && yytoken != YYEMPTY)
+ yydestruct ("Error: discarding lookahead",
+ yytoken, yylvalp]b4_location_if([, yyllocp])[);
yyfreeGLRStack (&yystack);
return yystack.yyerrflag;
}
/* DEBUGGING ONLY */
+#ifdef YYDEBUG
static void yypstack (yyGLRStack* yystack, int yyk) ATTRIBUTE_UNUSED;
static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED;
yy_yypstack (yys->yypred);
fprintf (stderr, " -> ");
}
- fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long) yys->yyposn);
+ fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn);
}
static void
size_t yyi;
for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1)
{
- fprintf (stderr, "%3lu. ", (unsigned long) (yyp - yystack->yyitems));
+ fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystack->yyitems));
if (*(yybool *) yyp)
{
fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
yyp->yystate.yyresolved, yyp->yystate.yylrState,
- (unsigned long) yyp->yystate.yyposn,
- (long) YYINDEX (yyp->yystate.yypred));
+ (unsigned long int) yyp->yystate.yyposn,
+ (long int) YYINDEX (yyp->yystate.yypred));
if (! yyp->yystate.yyresolved)
fprintf (stderr, ", firstVal: %ld",
- (long) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
+ (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
}
else
{
fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
yyp->yyoption.yyrule,
- (long) YYINDEX (yyp->yyoption.yystate),
- (long) YYINDEX (yyp->yyoption.yynext));
+ (long int) YYINDEX (yyp->yyoption.yystate),
+ (long int) YYINDEX (yyp->yyoption.yynext));
}
fprintf (stderr, "\n");
}
fprintf (stderr, "Tops:");
for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1)
- fprintf (stderr, "%lu: %ld; ", (unsigned long) yyi,
- (long) YYINDEX (yystack->yytops.yystates[yyi]));
+ fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi,
+ (long int) YYINDEX (yystack->yytops.yystates[yyi]));
fprintf (stderr, "\n");
}
+#endif
]
b4_epilogue
m4_if(b4_defines_flag, 0, [],
[@output @output_header_name@
-b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003])
+b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003, 2004])
b4_token_defines(b4_tokens)
projects / bison.git / blobdiff