-m4_divert(-1) -*- C -*-
+ -*- C -*-
# GLR skeleton for Bison
-# Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation,
+# Inc.
-# This program is free software; you can redistribute it and/or modify
+# 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
-# the Free Software Foundation; either version 2 of the License, or
+# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
-
+#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
-
+#
# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-# 02110-1301 USA
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
m4_include(b4_pkgdatadir/[c.m4])
+b4_push_if([
+b4_complain([[non-deterministic push parsers are not yet supported]])])
+
## ---------------- ##
## Default values. ##
## ---------------- ##
# 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])
## ----------------- ##
# We do want M4 expansion after # for CPP macros.
m4_changecom()
-m4_divert(0)dnl
-@output @output_parser_name@
-b4_copyright([Skeleton parser for GLR parsing with Bison],
+m4_divert_push(0)dnl
+@output(b4_parser_file_name@)
+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], [],
+b4_percent_code_get([[top]])[]dnl
+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)[
+[b4_percent_code_get([[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
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@])[
+]b4_percent_code_get([[provides]])[]dnl
+])
+
+b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
+ [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
+b4_percent_code_get[]dnl
-]/* Line __line__ of glr.c. */
-b4_syncline([@oline@], [@ofile@])
-[
-#include <stdio.h>
+[#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <stdarg.h>
#ifndef YY_
# if YYENABLE_NLS
# 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) \
{ \
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))
#ifndef YYSTACKEXPANDABLE
# if (! defined __cplusplus \
- || (]b4_location_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+ || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
&& ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
# define YYSTACKEXPANDABLE 1
# else
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(
[
# undef YYERROR
# define YYERROR return yyerrok, yyerr
# undef YYRECOVERING
-# define YYRECOVERING (yystackp->yyerrState != 0)
+# define YYRECOVERING() (yystackp->yyerrState != 0)
# undef yyclearin
# define yyclearin (yychar = YYEMPTY)
# undef YYFILL
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;
+]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
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
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;]])[
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
- fprintf (stderr, " $%d = ", yyi + 1);
+ YYFPRINTF (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");
+ YYFPRINTF (stderr, "\n");
}
}
#endif
return yyflag;
}
- yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_location_if([[
+ 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;]])[
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)
{
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 set the semantic value of S. If result != yyok, the chain of
switch (yypreference (yybest, yyp))
{
case 0:
+ yyresolveLocations (yys, 1, yystackp]b4_user_args[);
return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
break;
case 1:
{
yydestruct ("Cleanup: discarding incompletely merged value for",
yystos[yys->yylrState],
- &yysval]b4_location_if([, yylocp])[]b4_user_args[);
+ &yysval]b4_locations_if([, yylocp])[]b4_user_args[);
break;
}
yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
{
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);
}
- else
- yytoken = YYTRANSLATE (yychar);
+
yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
while (*yyconflicts != 0)
#if YYERROR_VERBOSE
int yyn;
yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
- if (YYPACT_NINF < yyn && yyn < YYLAST)
+ if (YYPACT_NINF < yyn && yyn <= YYLAST)
{
yySymbol yytoken = YYTRANSLATE (yychar);
size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
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;
/* 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[)
{
if (yychar == YYEOF)
yyFail (yystackp][]b4_lpure_args[, NULL);
if (yychar != YYEMPTY)
- {]b4_location_if([[
+ {]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];
YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
yytoken = YYTRANSLATE (yychar);
yydestruct ("Error: discarding",
- yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+ yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
}
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
- yytoken = YYTRANSLATE (yychar);
- YY_SYMBOL_PRINT ("Next token is", yytoken, &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;
&& 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);]])[
YY_SYMBOL_PRINT ("Shifting", yystos[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;
yychar = 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;
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;
}
{
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);
}
- else
- yytoken = YYTRANSLATE (yychar);
+
yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
if (*yyconflicts != 0)
break;
if (yyisShiftAction (yyaction))
{
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
- if (yychar != YYEOF)
- yychar = 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
yytoken_to_shift = YYTRANSLATE (yychar);
yychar = 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 (yychar != YYEOF && yychar != YYEMPTY)
+ if (yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead",
YYTRANSLATE (yychar),
- &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
+ &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 */
-#ifdef YYDEBUG
+#if YYDEBUG
static void yypstack (yyGLRStack* yystackp, size_t yyk)
__attribute__ ((__unused__));
static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
if (yys->yypred)
{
yy_yypstack (yys->yypred);
- fprintf (stderr, " -> ");
+ YYFPRINTF (stderr, " -> ");
}
- fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn);
+ YYFPRINTF (stderr, "%d@@%lu", yys->yylrState,
+ (unsigned long int) yys->yyposn);
}
static void
yypstates (yyGLRState* yyst)
{
if (yyst == NULL)
- fprintf (stderr, "<null>");
+ YYFPRINTF (stderr, "<null>");
else
yy_yypstack (yyst);
- fprintf (stderr, "\n");
+ YYFPRINTF (stderr, "\n");
}
static void
size_t yyi;
for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
{
- fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystackp->yyitems));
+ YYFPRINTF (stderr, "%3lu. ",
+ (unsigned long int) (yyp - yystackp->yyitems));
if (*(yybool *) yyp)
{
- fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
- yyp->yystate.yyresolved, yyp->yystate.yylrState,
- (unsigned long int) yyp->yystate.yyposn,
- (long int) YYINDEX (yyp->yystate.yypred));
+ YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
+ yyp->yystate.yyresolved, yyp->yystate.yylrState,
+ (unsigned long int) yyp->yystate.yyposn,
+ (long int) YYINDEX (yyp->yystate.yypred));
if (! yyp->yystate.yyresolved)
- fprintf (stderr, ", firstVal: %ld",
- (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
+ YYFPRINTF (stderr, ", firstVal: %ld",
+ (long int) YYINDEX (yyp->yystate
+ .yysemantics.yyfirstVal));
}
else
{
- fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
- yyp->yyoption.yyrule,
- (long int) YYINDEX (yyp->yyoption.yystate),
- (long int) YYINDEX (yyp->yyoption.yynext));
+ YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld",
+ yyp->yyoption.yyrule - 1,
+ (long int) YYINDEX (yyp->yyoption.yystate),
+ (long int) YYINDEX (yyp->yyoption.yynext));
}
- fprintf (stderr, "\n");
+ YYFPRINTF (stderr, "\n");
}
- fprintf (stderr, "Tops:");
+ YYFPRINTF (stderr, "Tops:");
for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
- fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi,
- (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
- fprintf (stderr, "\n");
+ YYFPRINTF (stderr, "%lu: %ld; ", (unsigned long int) yyi,
+ (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
+ YYFPRINTF (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, 2004, 2005, 2006])[
-
-/* C GLR parser skeleton written by Paul Hilfinger. */
-]
+dnl
+dnl glr.cc produces its own header.
+dnl
+m4_if(b4_skeleton, ["glr.c"],
+[b4_defines_if(
+[@output(b4_spec_defines_file@)
+b4_copyright([Skeleton interface for Bison GLR parsers in C],
+ [2002, 2003, 2004, 2005, 2006])
b4_shared_declarations
-extern YYSTYPE b4_prefix[]lval;
+b4_pure_if([],
+[[extern YYSTYPE b4_prefix][lval;]])
-b4_location_if([b4_pure_if([],
+b4_locations_if([b4_pure_if([],
[extern YYLTYPE b4_prefix[]lloc;])
])
-])
+])])
+m4_divert_pop(0)
projects / bison.git / blobdiff