[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
yysyntax_error: fix for consistent error with lookahead.
From: |
Joel E. Denny |
Subject: |
yysyntax_error: fix for consistent error with lookahead. |
Date: |
Sun, 7 Nov 2010 17:47:41 -0500 (EST) |
User-agent: |
Alpine 1.00 (DEB 882 2007-12-20) |
I pushed the following patches to master and cherry-picked them to
branch-2.5.
>From b4bbc4a03c6f4799a4442c912b71a28c3a986e54 Mon Sep 17 00:00:00 2001
From: Joel E. Denny <address@hidden>
Date: Sun, 7 Nov 2010 09:44:07 -0500
Subject: [PATCH 1/3] yysyntax_error: prepare for readability of next patches.
These are purely whitespace changes that result in ugly code
but that make the next couple of patches much easier to read.
* data/glr.c (yyreportSyntaxError): Reindent.
* data/lalr1.cc (yy::parser::yysyntax_error_): Reindent.
* data/lalr1.java (YYParser::yysyntax_error): Reindent.
* data/yacc.c (yysyntax_error): Reindent.
---
ChangeLog | 10 +
data/glr.c | 182 +++++++-------
data/lalr1.cc | 88 +++---
data/lalr1.java | 49 ++--
data/yacc.c | 183 +++++++-------
src/parse-gram.c | 783 +++++++++++++++++++++++++++---------------------------
src/parse-gram.h | 12 +-
7 files changed, 661 insertions(+), 646 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 340a9db..76163f2 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,13 @@
+2010-11-07 Joel E. Denny <address@hidden>
+
+ yysyntax_error: prepare for readability of next patches.
+ These are purely whitespace changes that result in ugly code
+ but that make the next couple of patches much easier to read.
+ * data/glr.c (yyreportSyntaxError): Reindent.
+ * data/lalr1.cc (yy::parser::yysyntax_error_): Reindent.
+ * data/lalr1.java (YYParser::yysyntax_error): Reindent.
+ * data/yacc.c (yysyntax_error): Reindent.
+
2010-10-31 Joel E. Denny <address@hidden>
Fix memory leak.
diff --git a/data/glr.c b/data/glr.c
index 642b993..f6c51c3 100644
--- a/data/glr.c
+++ b/data/glr.c
@@ -2081,104 +2081,104 @@ yyreportSyntaxError (yyGLRStack*
yystackp]b4_user_formals[)
#if YYERROR_VERBOSE
int yyn;
yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
- if (YYPACT_NINF < yyn && yyn <= YYLAST)
- {
- yySymbol yytoken = YYTRANSLATE (yychar);
- size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
- size_t yysize = yysize0;
- size_t yysize1;
- yybool yysize_overflow = yyfalse;
- char* yymsg = NULL;
- enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
- /* Internationalized format string. */
- const char *yyformat = 0;
- /* Arguments of yyformat. */
- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. In other words, skip the first -YYN actions for this
- state because they are default actions. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
-
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn + 1;
- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-
- /* Number of reported tokens (one for the "unexpected", one per
- "expected"). */
- int yycount = 0;
+if (YYPACT_NINF < yyn && yyn <= YYLAST)
+ {
+ yySymbol yytoken = YYTRANSLATE (yychar);
+ size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
+ size_t yysize = yysize0;
+ size_t yysize1;
+ yybool yysize_overflow = yyfalse;
+ char* yymsg = NULL;
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ /* Internationalized format string. */
+ const char *yyformat = 0;
+ /* Arguments of yyformat. */
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. In other words, skip the first -YYN actions for this
+ state because they are default actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = YYLAST - yyn + 1;
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+
+ /* Number of reported tokens (one for the "unexpected", one per
+ "expected"). */
+ int yycount = 0;
int yyx;
- yyarg[yycount++] = yytokenName (yytoken);
-
- for (yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
- && !yytable_value_is_error (yytable[yyx + yyn]))
- {
- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
- {
- yycount = 1;
- yysize = yysize0;
- break;
- }
- yyarg[yycount++] = yytokenName (yyx);
- yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
- yysize_overflow |= yysize1 < yysize;
- yysize = yysize1;
- }
-
- switch (yycount)
- {
-#define YYCASE_(N, S) \
- case N: \
- yyformat = S; \
- break
- YYCASE_(1, YY_("syntax error, unexpected %s"));
- YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
- YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or
%s"));
- YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s
or %s"));
- YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s
or %s or %s"));
+ yyarg[yycount++] = yytokenName (yytoken);
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+ && !yytable_value_is_error (yytable[yyx + yyn]))
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ break;
+ }
+ yyarg[yycount++] = yytokenName (yyx);
+ yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
+ yysize_overflow |= yysize1 < yysize;
+ yysize = yysize1;
+ }
+
+ switch (yycount)
+ {
+#define YYCASE_(N, S) \
+ case N: \
+ yyformat = S; \
+ break
+ YYCASE_(1, YY_("syntax error, unexpected %s"));
+ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or
%s"));
#undef YYCASE_
- }
+ }
- yysize1 = yysize + strlen (yyformat);
- yysize_overflow |= yysize1 < yysize;
- yysize = yysize1;
+ yysize1 = yysize + strlen (yyformat);
+ yysize_overflow |= yysize1 < yysize;
+ yysize = yysize1;
- if (!yysize_overflow)
- yymsg = (char *) YYMALLOC (yysize);
+ if (!yysize_overflow)
+ yymsg = (char *) YYMALLOC (yysize);
- if (yymsg)
- {
- char *yyp = yymsg;
- int yyi = 0;
- while ((*yyp = *yyformat))
- {
- if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
- {
- yyp += yytnamerr (yyp, yyarg[yyi++]);
- yyformat += 2;
- }
- else
- {
- yyp++;
- yyformat++;
- }
- }
- yyerror (]b4_lyyerror_args[yymsg);
- YYFREE (yymsg);
- }
- else
- {
- yyerror (]b4_lyyerror_args[YY_("syntax error"));
- yyMemoryExhausted (yystackp);
- }
- }
- else
-#endif /* YYERROR_VERBOSE */
- yyerror (]b4_lyyerror_args[YY_("syntax error"));
- yynerrs += 1;
+ if (yymsg)
+ {
+ char *yyp = yymsg;
+ int yyi = 0;
+ while ((*yyp = *yyformat))
+ {
+ if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+ {
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyformat += 2;
+ }
+ else
+ {
+ yyp++;
+ yyformat++;
+ }
+ }
+ yyerror (]b4_lyyerror_args[yymsg);
+ YYFREE (yymsg);
+ }
+ else
+ {
+ yyerror (]b4_lyyerror_args[YY_("syntax error"));
+ yyMemoryExhausted (yystackp);
}
+ }
+else
+#endif /* YYERROR_VERBOSE */
+ yyerror (]b4_lyyerror_args[YY_("syntax error"));
+ yynerrs += 1;
+}
}
/* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
diff --git a/data/lalr1.cc b/data/lalr1.cc
index bd1faa5..d1d88d0 100644
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -982,62 +982,62 @@ b4_error_verbose_if([state_type yystate, int yytoken],
int yyn = yypact_[yystate];
if (yypact_ninf_ < yyn && yyn <= yylast_)
{
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. In other words, skip the first -YYN actions for this
- state because they are default actions. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. In other words, skip the first -YYN actions for
+ this state because they are default actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = yylast_ - yyn + 1;
- int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = yylast_ - yyn + 1;
+ int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
// Number of reported tokens (one for the "unexpected", one per
// "expected").
- size_t yycount = 0;
+ size_t yycount = 0;
// Its maximum.
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
// Arguments of yyformat.
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
yyarg[yycount++] = yytname_[yytoken];
- for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
- && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
- {
- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
- {
- yycount = 1;
- break;
- }
- else
- yyarg[yycount++] = yytname_[yyx];
- }
+ for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
+ && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ break;
+ }
+ else
+ yyarg[yycount++] = yytname_[yyx];
+ }
- char const* yyformat = 0;
- switch (yycount)
- {
-#define YYCASE_(N, S) \
- case N: \
- yyformat = S; \
- break
- YYCASE_(1, YY_("syntax error, unexpected %s"));
- YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
- YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
- YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or
%s"));
- YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or
%s or %s"));
+ char const* yyformat = 0;
+ switch (yycount)
+ {
+#define YYCASE_(N, S) \
+ case N: \
+ yyformat = S; \
+ break
+ YYCASE_(1, YY_("syntax error, unexpected %s"));
+ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or
%s"));
+ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s
or %s"));
#undef YYCASE_
- }
- // Argument number.
- size_t yyi = 0;
- for (char const* yyp = yyformat; *yyp; ++yyp)
- if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
- {
- yyres += yytnamerr_ (yyarg[yyi++]);
- ++yyp;
- }
- else
- yyres += *yyp;
}
- else
+ // Argument number.
+ size_t yyi = 0;
+ for (char const* yyp = yyformat; *yyp; ++yyp)
+ if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
+ {
+ yyres += yytnamerr_ (yyarg[yyi++]);
+ ++yyp;
+ }
+ else
+ yyres += *yyp;
+ }
+ else
]])dnl
[ yyres = YY_("syntax error");
return yyres;
diff --git a/data/lalr1.java b/data/lalr1.java
index c6bd403..27256e1 100644
--- a/data/lalr1.java
+++ b/data/lalr1.java
@@ -732,35 +732,36 @@ m4_popdef([b4_at_dollar])])dnl
{
StringBuffer res;
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. In other words, skip the first -YYN actions for this
- state because they are default actions. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
-
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = yylast_ - yyn + 1;
- int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
- int count = 0;
- for (int x = yyxbegin; x < yyxend; ++x)
- if (yycheck_[x + yyn] == x && x != yyterror_
- && !yy_table_value_is_error_ (yytable_[x + yyn]))
- ++count;
+ /* Start YYX at -YYN if negative to avoid negative
+ indexes in YYCHECK. In other words, skip the first
+ -YYN actions for this state because they are default
+ actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = yylast_ - yyn + 1;
+ int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
+ int count = 0;
+ for (int x = yyxbegin; x < yyxend; ++x)
+ if (yycheck_[x + yyn] == x && x != yyterror_
+ && !yy_table_value_is_error_ (yytable_[x + yyn]))
+ ++count;
// FIXME: This method of building the message is not compatible
// with internationalization.
res = new StringBuffer ("syntax error, unexpected ");
res.append (yytnamerr_ (yytname_[tok]));
- if (count < 5)
- {
- count = 0;
- for (int x = yyxbegin; x < yyxend; ++x)
- if (yycheck_[x + yyn] == x && x != yyterror_
- && !yy_table_value_is_error_ (yytable_[x + yyn]))
- {
- res.append (count++ == 0 ? ", expecting " : " or ");
- res.append (yytnamerr_ (yytname_[x]));
- }
- }
+ if (count < 5)
+ {
+ count = 0;
+ for (int x = yyxbegin; x < yyxend; ++x)
+ if (yycheck_[x + yyn] == x && x != yyterror_
+ && !yy_table_value_is_error_ (yytable_[x + yyn]))
+ {
+ res.append (count++ == 0 ? ", expecting " : " or ");
+ res.append (yytnamerr_ (yytname_[x]));
+ }
+ }
return res.toString ();
}
}
diff --git a/data/yacc.c b/data/yacc.c
index a329717..d171536 100644
--- a/data/yacc.c
+++ b/data/yacc.c
@@ -920,105 +920,104 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
return 1;
else
- {
- YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
- YYSIZE_T yysize = yysize0;
- YYSIZE_T yysize1;
- enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
- /* Internationalized format string. */
- const char *yyformat = 0;
- /* Arguments of yyformat. */
- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. In other words, skip the first -YYN actions for this
- state because they are default actions. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
-
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = YYLAST - yyn + 1;
- int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
- /* Number of reported tokens (one for the "unexpected", one per
- "expected"). */
- int yycount = 0;
- int yyx;
-
- yyarg[yycount++] = yytname[yytoken];
-
- for (yyx = yyxbegin; yyx < yyxend; ++yyx)
- if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
- && !yytable_value_is_error (yytable[yyx + yyn]))
- {
- if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
- {
- yycount = 1;
- yysize = yysize0;
- break;
- }
- yyarg[yycount++] = yytname[yyx];
- yysize1 = yysize + yytnamerr (0, yytname[yyx]);
- if (! (yysize <= yysize1
- && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
- {
- /* Overflow. */
- *yymsg_alloc = 0;
- return 2;
- }
- yysize = yysize1;
- }
+{
+ YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
+ YYSIZE_T yysize = yysize0;
+ YYSIZE_T yysize1;
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ /* Internationalized format string. */
+ const char *yyformat = 0;
+ /* Arguments of yyformat. */
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. In other words, skip the first -YYN actions for
+ this state because they are default actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = YYLAST - yyn + 1;
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+ /* Number of reported tokens (one for the "unexpected", one per
+ "expected"). */
+ int yycount = 0;
+ int yyx;
+
+ yyarg[yycount++] = yytname[yytoken];
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+ && !yytable_value_is_error (yytable[yyx + yyn]))
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ break;
+ }
+ yyarg[yycount++] = yytname[yyx];
+ yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+ if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ {
+ /* Overflow. */
+ *yymsg_alloc = 0;
+ return 2;
+ }
+ yysize = yysize1;
+ }
- switch (yycount)
- {
-#define YYCASE_(N, S) \
- case N: \
- yyformat = S; \
- break
- YYCASE_(1, YY_("syntax error, unexpected %s"));
- YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
- YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
- YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or
%s"));
- YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or
%s or %s"));
+ switch (yycount)
+ {
+#define YYCASE_(N, S) \
+ case N: \
+ yyformat = S; \
+ break
+ YYCASE_(1, YY_("syntax error, unexpected %s"));
+ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or
%s"));
#undef YYCASE_
- }
+ }
+
+ yysize1 = yysize + yystrlen (yyformat);
+ if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ {
+ /* Overflow. */
+ *yymsg_alloc = 0;
+ return 2;
+ }
+ yysize = yysize1;
+
+ if (*yymsg_alloc < yysize)
+ {
+ *yymsg_alloc = 2 * yysize;
+ if (! (yysize <= *yymsg_alloc
+ && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+ *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+ return 2;
+ }
- yysize1 = yysize + yystrlen (yyformat);
- if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ /* Avoid sprintf, as that infringes on the user's name space.
+ Don't have undefined behavior even if the translation
+ produced a string with the wrong number of "%s"s. */
+ {
+ char *yyp = *yymsg;
+ int yyi = 0;
+ while ((*yyp = *yyformat) != '\0')
+ if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
{
- /* Overflow. */
- *yymsg_alloc = 0;
- return 2;
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyformat += 2;
}
- yysize = yysize1;
-
- if (*yymsg_alloc < yysize)
+ else
{
- *yymsg_alloc = 2 * yysize;
- if (! (yysize <= *yymsg_alloc
- && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
- *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
- return 2;
+ yyp++;
+ yyformat++;
}
-
- /* Avoid sprintf, as that infringes on the user's name space.
- Don't have undefined behavior even if the translation
- produced a string with the wrong number of "%s"s. */
- {
- char *yyp = *yymsg;
- int yyi = 0;
- while ((*yyp = *yyformat) != '\0')
- if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
- {
- yyp += yytnamerr (yyp, yyarg[yyi++]);
- yyformat += 2;
- }
- else
- {
- yyp++;
- yyformat++;
- }
- }
- return 0;
- }
+ }
+ return 0;
+}
}
#endif /* YYERROR_VERBOSE */
--
1.7.0.4
>From 25a648d8a6a00bb810844e375d0d15125ed7eaf8 Mon Sep 17 00:00:00 2001
From: Joel E. Denny <address@hidden>
Date: Sun, 7 Nov 2010 09:45:18 -0500
Subject: [PATCH 2/3] yysyntax_error: more preparation for readability of next
patch.
There are no behavioral changes here.
* data/glr.c (yyreportSyntaxError): Reorganize.
* data/lalr1.cc (yy::parser::yysyntax_error_): Reorganize.
* tests/conflicts.at (parse.error=verbose and consistent errors):
Reorganize.
---
ChangeLog | 9 ++++
data/glr.c | 11 +++--
data/lalr1.cc | 10 ++--
tests/conflicts.at | 119 +++++++++++++++++++++++++++++-----------------------
4 files changed, 87 insertions(+), 62 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 76163f2..019c238 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,14 @@
2010-11-07 Joel E. Denny <address@hidden>
+ yysyntax_error: more preparation for readability of next patch.
+ There are no behavioral changes here.
+ * data/glr.c (yyreportSyntaxError): Reorganize.
+ * data/lalr1.cc (yy::parser::yysyntax_error_): Reorganize.
+ * tests/conflicts.at (parse.error=verbose and consistent errors):
+ Reorganize.
+
+2010-11-07 Joel E. Denny <address@hidden>
+
yysyntax_error: prepare for readability of next patches.
These are purely whitespace changes that result in ugly code
but that make the next couple of patches much easier to read.
diff --git a/data/glr.c b/data/glr.c
index f6c51c3..93ed512 100644
--- a/data/glr.c
+++ b/data/glr.c
@@ -2076,9 +2076,11 @@ yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
/*ARGSUSED*/ static void
yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
{
- if (yystackp->yyerrState == 0)
- {
-#if YYERROR_VERBOSE
+ if (yystackp->yyerrState != 0)
+ return;
+#if ! YYERROR_VERBOSE
+ yyerror (]b4_lyyerror_args[YY_("syntax error"));
+#else
int yyn;
yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
if (YYPACT_NINF < yyn && yyn <= YYLAST)
@@ -2175,11 +2177,10 @@ if (YYPACT_NINF < yyn && yyn <= YYLAST)
}
}
else
-#endif /* YYERROR_VERBOSE */
yyerror (]b4_lyyerror_args[YY_("syntax error"));
+#endif /* YYERROR_VERBOSE */
yynerrs += 1;
}
-}
/* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
yylval, and yylloc are the syntactic category, semantic value, and location
diff --git a/data/lalr1.cc b/data/lalr1.cc
index d1d88d0..a3b2232 100644
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -977,8 +977,8 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
]b4_parser_class_name[::yysyntax_error_ (]dnl
b4_error_verbose_if([state_type yystate, int yytoken],
[int, int])[)
- {
- std::string yyres;]b4_error_verbose_if([[
+ {]b4_error_verbose_if([[
+ std::string yyres;
int yyn = yypact_[yystate];
if (yypact_ninf_ < yyn && yyn <= yylast_)
{
@@ -1038,9 +1038,9 @@ b4_error_verbose_if([state_type yystate, int yytoken],
yyres += *yyp;
}
else
- ]])dnl
-[ yyres = YY_("syntax error");
- return yyres;
+ yyres = YY_("syntax error");
+ return yyres;]], [[
+ return YY_("syntax error");]])[
}
diff --git a/tests/conflicts.at b/tests/conflicts.at
index ffcbb77..72f5696 100644
--- a/tests/conflicts.at
+++ b/tests/conflicts.at
@@ -147,21 +147,6 @@ AT_SETUP([[parse.error=verbose and consistent errors]])
m4_pushdef([AT_CONSISTENT_ERRORS_CHECK], [
-AT_BISON_CHECK([$1[ -o input.c input.y]])
-AT_COMPILE([[input]])
-
-m4_pushdef([AT_EXPECTING], [m4_if($3, [ab], [[, expecting 'a' or 'b']],
- $3, [a], [[, expecting 'a']],
- $3, [b], [[, expecting 'b']])])
-
-AT_PARSER_CHECK([[./input]], [[1]], [],
-[[syntax error, unexpected ]$2[]AT_EXPECTING[
-]])
-
-m4_popdef([AT_EXPECTING])
-
-])
-
AT_DATA_GRAMMAR([input.y],
[[%code {
#include <assert.h>
@@ -171,13 +156,53 @@ AT_DATA_GRAMMAR([input.y],
#define USE(Var)
}
+]$1[
+
%define parse.error verbose
-// The point isn't to test IELR here, but state merging happens to
-// complicate the example.
-%define lr.type ielr
+%%
+
+]$2[
+
+%%
+
+int
+yylex (void)
+{
+ static char const *input = "]$3[";
+ yylval = 1;
+ return *input++;
+}
+
+void
+yyerror (char const *msg)
+{
+ fprintf (stderr, "%s\n", msg);
+}
+
+int
+main (void)
+{
+ return yyparse ();
+}
+]])
+AT_BISON_CHECK([[-o input.c input.y]])
+AT_COMPILE([[input]])
+
+m4_pushdef([AT_EXPECTING], [m4_if($5, [ab], [[, expecting 'a' or 'b']],
+ $5, [a], [[, expecting 'a']],
+ $5, [b], [[, expecting 'b']])])
-%nonassoc 'a'
+AT_PARSER_CHECK([[./input]], [[1]], [[]],
+[[syntax error, unexpected ]$4[]AT_EXPECTING[
+]])
+
+m4_popdef([AT_EXPECTING])
+
+])
+
+m4_pushdef([AT_USER_ACTION_GRAMMAR],
+[[%nonassoc 'a';
// If yylval=0 here, then we know that the 'a' destructor is being
// invoked incorrectly for the 'b' set in the semantic action below.
@@ -185,9 +210,7 @@ AT_DATA_GRAMMAR([input.y],
%destructor {
if (!$$)
fprintf (stderr, "Wrong destructor.\n");
-} 'a'
-
-%%
+} 'a';
// The lookahead assigned by the semantic action isn't needed before
// either error action is encountered. In a previous version of Bison,
@@ -198,13 +221,13 @@ AT_DATA_GRAMMAR([input.y],
// except that, due to another bug, the unexpected token is not reported
// at all because the error action is the default action in a consistent
// state. That bug still needs to be fixed.
-start: error-reduce consistent-error 'a' { USE ($3); } ;
+start: error-reduce consistent-error 'a' { USE ($][3); } ;
error-reduce:
'a' 'a' consistent-reduction consistent-error 'a'
- { USE (($1, $2, $5)); }
+ { USE (($][1, $][2, $][5)); }
| 'a' error
- { USE ($1); }
+ { USE ($][1); }
;
consistent-reduction: /*empty*/ {
@@ -214,48 +237,40 @@ consistent-reduction: /*empty*/ {
} ;
consistent-error:
- 'a' { USE ($1); }
+ 'a' { USE ($][1); }
| /*empty*/ %prec 'a'
;
// Provide another context in which all rules are useful so that this
// test case looks a little more realistic.
start: 'b' consistent-error 'b' ;
-
-%%
-
-int
-yylex (void)
-{
- static char const *input = "aa";
- yylval = 1;
- return *input++;
-}
-
-void
-yyerror (char const *msg)
-{
- fprintf (stderr, "%s\n", msg);
-}
-
-int
-main (void)
-{
- return yyparse ();
-}
]])
+m4_pushdef([AT_USER_ACTION_INPUT], [[aa]])
# See comments in grammar for why this test doesn't succeed.
AT_XFAIL_IF([[:]])
-AT_CONSISTENT_ERRORS_CHECK([], [['b']], [[none]])
-AT_CONSISTENT_ERRORS_CHECK([[-Dlr.default-reductions=consistent]],
+AT_CONSISTENT_ERRORS_CHECK([[]],
+ [AT_USER_ACTION_GRAMMAR],
+ [AT_USER_ACTION_INPUT],
+ [['b']], [[none]])
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reductions consistent]],
+ [AT_USER_ACTION_GRAMMAR],
+ [AT_USER_ACTION_INPUT],
[['b']], [[none]])
# Canonical LR doesn't foresee the error for 'a'!
-AT_CONSISTENT_ERRORS_CHECK([[-Dlr.default-reductions=accepting]],
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reductions accepting]],
+ [AT_USER_ACTION_GRAMMAR],
+ [AT_USER_ACTION_INPUT],
[[$end]], [[a]])
-AT_CONSISTENT_ERRORS_CHECK([[-Flr.type=canonical-lr]], [[$end]], [[a]])
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr]],
+ [AT_USER_ACTION_GRAMMAR],
+ [AT_USER_ACTION_INPUT],
+ [[$end]], [[a]])
+
+m4_popdef([AT_USER_ACTION_GRAMMAR])
+m4_popdef([AT_USER_ACTION_INPUT])
m4_popdef([AT_CONSISTENT_ERRORS_CHECK])
--
1.7.0.4
>From d2060f0634f4adfb5db74cce540a9d27806091fe Mon Sep 17 00:00:00 2001
From: Joel E. Denny <address@hidden>
Date: Sun, 7 Nov 2010 16:01:56 -0500
Subject: [PATCH 3/3] yysyntax_error: fix for consistent error with lookahead.
* NEWS (2.5): Document.
* data/yacc.c (yysyntax_error): In a verbose syntax error
message while in a consistent state with a default action (which
must be an error action given that yysyntax_error is being
invoked), continue to drop the expected token list, but don't
drop the unexpected token unless there actually is no lookahead.
Moreover, handle that internally instead of returning 1 to tell
the caller to do it. With that meaning of 1 gone, renumber
return codes more usefully.
(yyparse, yypush_parse): Update yysyntax_error usage. Most
importantly, set yytoken to YYEMPTY when there's no lookahead.
* data/glr.c (yyreportSyntaxError): As in yacc.c, don't drop the
unexpected token unless there actually is no lookahead.
* data/lalr1.cc (yy::parser::parse): If there's no lookahead,
pass yyempty_ not yyla.type to yysyntax_error_.
(yy::parser::yysyntax_error_): Again, don't drop the unexpected
token unless there actually is no lookahead.
* data/lalr1.java (YYParser::parse): If there's no lookahead,
set yytoken to yyempty_ before invoking yysyntax_error.
(YYParser::yysyntax_error): Again, don't drop the unexpected
token unless there actually is no lookahead.
* tests/conflicts.at (parse.error=verbose and consistent
errors): Extend test group to further reveal how the previous
use of the simple "syntax error" message was too general. Test
yacc.c, glr.c, lalr1.cc, and lalr1.java. No longer an expected
failure.
* tests/java.at (AT_JAVA_COMPILE, AT_JAVA_PARSER_CHECK): Move
to...
* tests/local.at: ... here.
(_AT_BISON_OPTION_PUSHDEFS): Push AT_SKEL_JAVA_IF definition.
(AT_BISON_OPTION_POPDEFS): Pop it.
(AT_FULL_COMPILE): Extend to handle Java.
---
ChangeLog | 36 +++
NEWS | 43 +++-
data/glr.c | 52 +++--
data/lalr1.cc | 60 ++++--
data/lalr1.java | 53 ++++-
data/yacc.c | 84 +++++---
src/parse-gram.c | 630 +++++++++++++++++++++++++++-------------------------
src/parse-gram.h | 10 +-
tests/conflicts.at | 200 +++++++++++++++---
tests/java.at | 19 --
tests/local.at | 47 +++-
11 files changed, 785 insertions(+), 449 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 019c238..41ba7e5 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,41 @@
2010-11-07 Joel E. Denny <address@hidden>
+ yysyntax_error: fix for consistent error with lookahead.
+ * NEWS (2.5): Document.
+ * data/yacc.c (yysyntax_error): In a verbose syntax error
+ message while in a consistent state with a default action (which
+ must be an error action given that yysyntax_error is being
+ invoked), continue to drop the expected token list, but don't
+ drop the unexpected token unless there actually is no lookahead.
+ Moreover, handle that internally instead of returning 1 to tell
+ the caller to do it. With that meaning of 1 gone, renumber
+ return codes more usefully.
+ (yyparse, yypush_parse): Update yysyntax_error usage. Most
+ importantly, set yytoken to YYEMPTY when there's no lookahead.
+ * data/glr.c (yyreportSyntaxError): As in yacc.c, don't drop the
+ unexpected token unless there actually is no lookahead.
+ * data/lalr1.cc (yy::parser::parse): If there's no lookahead,
+ pass yyempty_ not yyla.type to yysyntax_error_.
+ (yy::parser::yysyntax_error_): Again, don't drop the unexpected
+ token unless there actually is no lookahead.
+ * data/lalr1.java (YYParser::parse): If there's no lookahead,
+ set yytoken to yyempty_ before invoking yysyntax_error.
+ (YYParser::yysyntax_error): Again, don't drop the unexpected
+ token unless there actually is no lookahead.
+ * tests/conflicts.at (parse.error=verbose and consistent
+ errors): Extend test group to further reveal how the previous
+ use of the simple "syntax error" message was too general. Test
+ yacc.c, glr.c, lalr1.cc, and lalr1.java. No longer an expected
+ failure.
+ * tests/java.at (AT_JAVA_COMPILE, AT_JAVA_PARSER_CHECK): Move
+ to...
+ * tests/local.at: ... here.
+ (_AT_BISON_OPTION_PUSHDEFS): Push AT_SKEL_JAVA_IF definition.
+ (AT_BISON_OPTION_POPDEFS): Pop it.
+ (AT_FULL_COMPILE): Extend to handle Java.
+
+2010-11-07 Joel E. Denny <address@hidden>
+
yysyntax_error: more preparation for readability of next patch.
There are no behavioral changes here.
* data/glr.c (yyreportSyntaxError): Reorganize.
diff --git a/NEWS b/NEWS
index 177fbbb..c818839 100644
--- a/NEWS
+++ b/NEWS
@@ -223,14 +223,41 @@ Bison News
Bison now warns when a character literal is not of length one. In
some future release, Bison will report an error instead.
-** Verbose error messages fixed for nonassociative tokens.
-
- When %error-verbose is specified, syntax error messages produced by
- the generated parser include the unexpected token as well as a list of
- expected tokens. Previously, this list erroneously included tokens
- that would actually induce a syntax error because conflicts for them
- were resolved with %nonassoc. Such tokens are now properly omitted
- from the list.
+** Verbose syntax error message fixes:
+
+ When %error-verbose or `#define YYERROR_VERBOSE' is specified, syntax
+ error messages produced by the generated parser include the unexpected
+ token as well as a list of expected tokens. The effect of %nonassoc
+ on these verbose messages has been corrected in two ways, but
+ additional fixes are still being implemented:
+
+*** When %nonassoc is used, there can exist parser states that accept no
+ tokens, and so the parser does not always require a lookahead token
+ in order to detect a syntax error. Because no unexpected token or
+ expected tokens can then be reported, the verbose syntax error
+ message described above is suppressed, and the parser instead
+ reports the simpler message, "syntax error". Previously, this
+ suppression was sometimes erroneously triggered by %nonassoc when a
+ lookahead was actually required. Now verbose messages are
+ suppressed only when all previous lookaheads have already been
+ shifted or discarded.
+
+*** Previously, the list of expected tokens erroneously included tokens
+ that would actually induce a syntax error because conflicts for them
+ were resolved with %nonassoc in the current parser state. Such
+ tokens are now properly omitted from the list.
+
+*** Expected token lists are still often wrong due to state merging
+ (from LALR or IELR) and default reductions, which can both add and
+ subtract valid tokens. Canonical LR almost completely fixes this
+ problem by eliminating state merging and default reductions.
+ However, there is one minor problem left even when using canonical
+ LR and even after the fixes above. That is, if the resolution of a
+ conflict with %nonassoc appears in a later parser state than the one
+ at which some syntax error is discovered, the conflicted token is
+ still erroneously included in the expected token list. We are
+ currently working on a fix to eliminate this problem and to
+ eliminate the need for canonical LR.
** Destructor calls fixed for lookaheads altered in semantic actions.
diff --git a/data/glr.c b/data/glr.c
index 93ed512..d8b9604 100644
--- a/data/glr.c
+++ b/data/glr.c
@@ -2081,11 +2081,7 @@ yyreportSyntaxError (yyGLRStack*
yystackp]b4_user_formals[)
#if ! YYERROR_VERBOSE
yyerror (]b4_lyyerror_args[YY_("syntax error"));
#else
- int yyn;
- yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
-if (YYPACT_NINF < yyn && yyn <= YYLAST)
- {
- yySymbol yytoken = YYTRANSLATE (yychar);
+ yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
size_t yysize = yysize0;
size_t yysize1;
@@ -2096,23 +2092,47 @@ if (YYPACT_NINF < yyn && yyn <= YYLAST)
const char *yyformat = 0;
/* Arguments of yyformat. */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ /* Number of reported tokens (one for the "unexpected", one per
+ "expected"). */
+ int yycount = 0;
+ /* There are many possibilities here to consider:
+ - If this state is a consistent state with a default action, then
+ the only way this function was invoked is if the default action
+ is an error action. In that case, don't check for expected
+ tokens because there are none.
+ - The only way there can be no lookahead present (in yychar) is if
+ this state is a consistent state with a default action. Thus,
+ detecting the absence of a lookahead is sufficient to determine
+ that there is no unexpected or expected token to report. In that
+ case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this state is a
+ consistent state with a default action. There might have been a
+ previous inconsistent state, consistent state with a non-default
+ action, or user semantic action that manipulated yychar.
+ - Of course, the expected token list depends on states to have
+ correct lookahead information, and it depends on the parser not
+ to perform extra reductions after fetching a lookahead from the
+ scanner and before detecting a syntax error. Thus, state merging
+ (from LALR or IELR) and default reductions corrupt the expected
+ token list. However, the list is correct for canonical LR with
+ one exception: it will still contain any token that will not be
+ accepted due to an error action in a later state.
+ */
+ if (yytoken != YYEMPTY)
+ {
+ int yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
+ yyarg[yycount++] = yytokenName (yytoken);
+ if (!yypact_value_is_default (yyn))
+ {
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for this
state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
-
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-
- /* Number of reported tokens (one for the "unexpected", one per
- "expected"). */
- int yycount = 0;
int yyx;
-
- yyarg[yycount++] = yytokenName (yytoken);
-
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
&& !yytable_value_is_error (yytable[yyx + yyn]))
@@ -2128,6 +2148,8 @@ if (YYPACT_NINF < yyn && yyn <= YYLAST)
yysize_overflow |= yysize1 < yysize;
yysize = yysize1;
}
+ }
+ }
switch (yycount)
{
@@ -2135,6 +2157,7 @@ if (YYPACT_NINF < yyn && yyn <= YYLAST)
case N: \
yyformat = S; \
break
+ YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
@@ -2175,9 +2198,6 @@ if (YYPACT_NINF < yyn && yyn <= YYLAST)
yyerror (]b4_lyyerror_args[YY_("syntax error"));
yyMemoryExhausted (yystackp);
}
- }
-else
- yyerror (]b4_lyyerror_args[YY_("syntax error"));
#endif /* YYERROR_VERBOSE */
yynerrs += 1;
}
diff --git a/data/lalr1.cc b/data/lalr1.cc
index a3b2232..a18721e 100644
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -862,7 +862,8 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param)));])[
{
++yynerrs_;
error (]b4_args(b4_locations_if([yyla.location]),
- [[yysyntax_error_ (yystack_[0].state, yyla.type)]])[);
+ [[yysyntax_error_ (yystack_[0].state,
+ yyempty ? yyempty_ :
yyla.type)]])[);
}
]b4_locations_if([[
@@ -979,26 +980,52 @@ b4_error_verbose_if([state_type yystate, int yytoken],
[int, int])[)
{]b4_error_verbose_if([[
std::string yyres;
- int yyn = yypact_[yystate];
- if (yypact_ninf_ < yyn && yyn <= yylast_)
+ // Number of reported tokens (one for the "unexpected", one per
+ // "expected").
+ size_t yycount = 0;
+ // Its maximum.
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ // Arguments of yyformat.
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+
+ /* There are many possibilities here to consider:
+ - If this state is a consistent state with a default action, then
+ the only way this function was invoked is if the default action
+ is an error action. In that case, don't check for expected
+ tokens because there are none.
+ - The only way there can be no lookahead present (in yytoken) is
+ if this state is a consistent state with a default action.
+ Thus, detecting the absence of a lookahead is sufficient to
+ determine that there is no unexpected or expected token to
+ report. In that case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this state is
+ a consistent state with a default action. There might have
+ been a previous inconsistent state, consistent state with a
+ non-default action, or user semantic action that manipulated
+ yyla. (However, yyla is currently not documented for users.)
+ - Of course, the expected token list depends on states to have
+ correct lookahead information, and it depends on the parser not
+ to perform extra reductions after fetching a lookahead from the
+ scanner and before detecting a syntax error. Thus, state
+ merging (from LALR or IELR) and default reductions corrupt the
+ expected token list. However, the list is correct for
+ canonical LR with one exception: it will still contain any
+ token that will not be accepted due to an error action in a
+ later state.
+ */
+ if (yytoken != yyempty_)
{
+ yyarg[yycount++] = yytname_[yytoken];
+ int yyn = yypact_[yystate];
+ if (!yy_pact_value_is_default_ (yyn))
+ {
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for
this state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
-
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = yylast_ - yyn + 1;
int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
-
- // Number of reported tokens (one for the "unexpected", one per
- // "expected").
- size_t yycount = 0;
- // Its maximum.
- enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
- // Arguments of yyformat.
- char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
- yyarg[yycount++] = yytname_[yytoken];
for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck_[yyx + yyn] == yyx && yyx != yyterror_
&& !yy_table_value_is_error_ (yytable_[yyx + yyn]))
@@ -1011,6 +1038,8 @@ b4_error_verbose_if([state_type yystate, int yytoken],
else
yyarg[yycount++] = yytname_[yyx];
}
+ }
+ }
char const* yyformat = 0;
switch (yycount)
@@ -1019,6 +1048,7 @@ b4_error_verbose_if([state_type yystate, int yytoken],
case N: \
yyformat = S; \
break
+ YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
@@ -1026,6 +1056,7 @@ b4_error_verbose_if([state_type yystate, int yytoken],
YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s
or %s"));
#undef YYCASE_
}
+
// Argument number.
size_t yyi = 0;
for (char const* yyp = yyformat; *yyp; ++yyp)
@@ -1036,9 +1067,6 @@ b4_error_verbose_if([state_type yystate, int yytoken],
}
else
yyres += *yyp;
- }
- else
- yyres = YY_("syntax error");
return yyres;]], [[
return YY_("syntax error");]])[
}
diff --git a/data/lalr1.java b/data/lalr1.java
index 27256e1..a2772ff 100644
--- a/data/lalr1.java
+++ b/data/lalr1.java
@@ -627,6 +627,8 @@ m4_popdef([b4_at_dollar])])dnl
if (yyerrstatus_ == 0)
{
++yynerrs_;
+ if (yychar == yyempty_)
+ yytoken = yyempty_;
yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate,
yytoken));
}
@@ -727,17 +729,52 @@ m4_popdef([b4_at_dollar])])dnl
{]b4_error_verbose_if([[
if (yyErrorVerbose)
{
- int yyn = yypact_[yystate];
- if (yypact_ninf_ < yyn && yyn <= yylast_)
+ /* There are many possibilities here to consider:
+ - Assume YYFAIL is not used. It's too flawed to consider.
+ See
+
<http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
+ for details. YYERROR is fine as it does not invoke this
+ function.
+ - If this state is a consistent state with a default action,
+ then the only way this function was invoked is if the
+ default action is an error action. In that case, don't
+ check for expected tokens because there are none.
+ - The only way there can be no lookahead present (in tok) is
+ if this state is a consistent state with a default action.
+ Thus, detecting the absence of a lookahead is sufficient to
+ determine that there is no unexpected or expected token to
+ report. In that case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this
+ state is a consistent state with a default action. There
+ might have been a previous inconsistent state, consistent
+ state with a non-default action, or user semantic action
+ that manipulated yychar. (However, yychar is currently out
+ of scope during semantic actions.)
+ - Of course, the expected token list depends on states to
+ have correct lookahead information, and it depends on the
+ parser not to perform extra reductions after fetching a
+ lookahead from the scanner and before detecting a syntax
+ error. Thus, state merging (from LALR or IELR) and default
+ reductions corrupt the expected token list. However, the
+ list is correct for canonical LR with one exception: it
+ will still contain any token that will not be accepted due
+ to an error action in a later state.
+ */
+ if (tok != yyempty_)
{
- StringBuffer res;
-
+ // FIXME: This method of building the message is not compatible
+ // with internationalization.
+ StringBuffer res =
+ new StringBuffer ("syntax error, unexpected ");
+ res.append (yytnamerr_ (yytname_[tok]));
+ int yyn = yypact_[yystate];
+ if (!yy_pact_value_is_default_ (yyn))
+ {
/* Start YYX at -YYN if negative to avoid negative
indexes in YYCHECK. In other words, skip the first
-YYN actions for this state because they are default
actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
-
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = yylast_ - yyn + 1;
int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
@@ -746,11 +783,6 @@ m4_popdef([b4_at_dollar])])dnl
if (yycheck_[x + yyn] == x && x != yyterror_
&& !yy_table_value_is_error_ (yytable_[x + yyn]))
++count;
-
- // FIXME: This method of building the message is not compatible
- // with internationalization.
- res = new StringBuffer ("syntax error, unexpected ");
- res.append (yytnamerr_ (yytname_[tok]));
if (count < 5)
{
count = 0;
@@ -762,6 +794,7 @@ m4_popdef([b4_at_dollar])])dnl
res.append (yytnamerr_ (yytname_[x]));
}
}
+ }
return res.toString ();
}
}
diff --git a/data/yacc.c b/data/yacc.c
index d171536..5cf15ee 100644
--- a/data/yacc.c
+++ b/data/yacc.c
@@ -906,21 +906,14 @@ yytnamerr (char *yyres, const char *yystr)
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN while in state YYSTATE.
- Return 0 if *YYMSG was successfully written. Return 1 if an ordinary
- "syntax error" message will suffice instead. Return 2 if *YYMSG is
- not large enough to hold the message. In the last case, also set
- *YYMSG_ALLOC to either (a) the required number of bytes or (b) zero
- if the required number of bytes is too large to store. */
+ Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
+ not large enough to hold the message. In that case, also set
+ *YYMSG_ALLOC to the required number of bytes. Return 2 if the
+ required number of bytes is too large to store. */
static int
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
int yystate, int yytoken)
{
- int yyn = yypact[yystate];
-
- if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
- return 1;
- else
-{
YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
YYSIZE_T yysize = yysize0;
YYSIZE_T yysize1;
@@ -929,22 +922,51 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
const char *yyformat = 0;
/* Arguments of yyformat. */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ /* Number of reported tokens (one for the "unexpected", one per
+ "expected"). */
+ int yycount = 0;
+ /* There are many possibilities here to consider:
+ - Assume YYFAIL is not used. It's too flawed to consider. See
+ <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
+ for details. YYERROR is fine as it does not invoke this
+ function.
+ - If this state is a consistent state with a default action, then
+ the only way this function was invoked is if the default action
+ is an error action. In that case, don't check for expected
+ tokens because there are none.
+ - The only way there can be no lookahead present (in yychar) is if
+ this state is a consistent state with a default action. Thus,
+ detecting the absence of a lookahead is sufficient to determine
+ that there is no unexpected or expected token to report. In that
+ case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this state is a
+ consistent state with a default action. There might have been a
+ previous inconsistent state, consistent state with a non-default
+ action, or user semantic action that manipulated yychar.
+ - Of course, the expected token list depends on states to have
+ correct lookahead information, and it depends on the parser not
+ to perform extra reductions after fetching a lookahead from the
+ scanner and before detecting a syntax error. Thus, state merging
+ (from LALR or IELR) and default reductions corrupt the expected
+ token list. However, the list is correct for canonical LR with
+ one exception: it will still contain any token that will not be
+ accepted due to an error action in a later state.
+ */
+ if (yytoken != YYEMPTY)
+ {
+ int yyn = yypact[yystate];
+ yyarg[yycount++] = yytname[yytoken];
+ if (!yypact_value_is_default (yyn))
+ {
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for
this state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
-
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
- /* Number of reported tokens (one for the "unexpected", one per
- "expected"). */
- int yycount = 0;
int yyx;
-
- yyarg[yycount++] = yytname[yytoken];
-
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
&& !yytable_value_is_error (yytable[yyx + yyn]))
@@ -957,14 +979,13 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
}
yyarg[yycount++] = yytname[yyx];
yysize1 = yysize + yytnamerr (0, yytname[yyx]);
- if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
- {
- /* Overflow. */
- *yymsg_alloc = 0;
- return 2;
- }
+ if (! (yysize <= yysize1
+ && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ return 2;
yysize = yysize1;
}
+ }
+ }
switch (yycount)
{
@@ -972,6 +993,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
case N: \
yyformat = S; \
break
+ YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
@@ -982,11 +1004,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
yysize1 = yysize + yystrlen (yyformat);
if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
- {
- /* Overflow. */
- *yymsg_alloc = 0;
- return 2;
- }
+ return 2;
yysize = yysize1;
if (*yymsg_alloc < yysize)
@@ -995,7 +1013,7 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
if (! (yysize <= *yymsg_alloc
&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
- return 2;
+ return 1;
}
/* Avoid sprintf, as that infringes on the user's name space.
@@ -1018,7 +1036,6 @@ yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
}
return 0;
}
-}
#endif /* YYERROR_VERBOSE */
@@ -1467,7 +1484,7 @@ yyreduce:
yyerrlab:
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
- yytoken = YYTRANSLATE (yychar);
+ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
/* If not already recovering from an error, report this error. */
if (!yyerrstatus)
@@ -1483,7 +1500,7 @@ yyerrlab:
int yysyntax_error_status = YYSYNTAX_ERROR;
if (yysyntax_error_status == 0)
yymsgp = yymsg;
- else if (yysyntax_error_status == 2 && 0 < yymsg_alloc)
+ else if (yysyntax_error_status == 1)
{
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
@@ -1492,6 +1509,7 @@ yyerrlab:
{
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
+ yysyntax_error_status = 2;
}
else
{
diff --git a/tests/conflicts.at b/tests/conflicts.at
index 72f5696..655a666 100644
--- a/tests/conflicts.at
+++ b/tests/conflicts.at
@@ -147,15 +147,30 @@ AT_SETUP([[parse.error=verbose and consistent errors]])
m4_pushdef([AT_CONSISTENT_ERRORS_CHECK], [
-AT_DATA_GRAMMAR([input.y],
-[[%code {
+AT_BISON_OPTION_PUSHDEFS([$1])
+
+m4_pushdef([AT_YYLEX_PROTOTYPE],
+[AT_SKEL_CC_IF([[int yylex (yy::parser::semantic_type *lvalp)]],
+ [[int yylex (YYSTYPE *lvalp)]])])
+
+AT_SKEL_JAVA_IF([AT_DATA], [AT_DATA_GRAMMAR])([input.y],
+[AT_SKEL_JAVA_IF([[
+
+%code imports {
+ import java.io.IOException;
+}]], [[
+
+%code {]AT_SKEL_CC_IF([[
+ #include <string>]], [[
#include <assert.h>
#include <stdio.h>
- int yylex (void);
- void yyerror (char const *);
+ void yyerror (char const *msg);]])[
+ ]AT_YYLEX_PROTOTYPE[;
#define USE(Var)
}
+]AT_SKEL_CC_IF([[%defines]], [[%define api.pure]])])[
+
]$1[
%define parse.error verbose
@@ -164,63 +179,193 @@ AT_DATA_GRAMMAR([input.y],
]$2[
-%%
+]AT_SKEL_JAVA_IF([[%code lexer {]], [[%%]])[
-int
-yylex (void)
+/*--------.
+| yylex. |
+`--------*/]AT_SKEL_JAVA_IF([[
+
+public String input = "]$3[";
+public int index = 0;
+public int yylex ()
+{
+ if (index < input.length ())
+ return input.charAt (index++);
+ else
+ return 0;
+}
+public Object getLVal ()
+{
+ return new Integer(1);
+}]], [[
+
+]AT_YYLEX_PROTOTYPE[
{
static char const *input = "]$3[";
- yylval = 1;
+ *lvalp = 1;
return *input++;
+}]])[
+
+/*----------.
+| yyerror. |
+`----------*/]AT_SKEL_JAVA_IF([[
+
+public void yyerror (String msg)
+{
+ System.err.println (msg);
}
+};
+
+%%]], [AT_SKEL_CC_IF([[
+
+void
+yy::parser::error (std::string const &msg)
+{
+ std::cerr << msg << std::endl;
+}]], [[
+
void
yyerror (char const *msg)
{
fprintf (stderr, "%s\n", msg);
-}
+}]])])[
+
+/*-------.
+| main. |
+`-------*/]AT_SKEL_JAVA_IF([[
+
+class input
+{
+ public static void main (String args[]) throws IOException
+ {
+ YYParser p = new YYParser ();
+ p.parse ();
+ }
+}]], [AT_SKEL_CC_IF([[
+
+int
+main (void)
+{
+ yy::parser parser;
+ return parser.parse ();
+}]], [[
int
main (void)
{
return yyparse ();
-}
+}]])])[
]])
-AT_BISON_CHECK([[-o input.c input.y]])
-AT_COMPILE([[input]])
+
+AT_FULL_COMPILE([[input]])
m4_pushdef([AT_EXPECTING], [m4_if($5, [ab], [[, expecting 'a' or 'b']],
$5, [a], [[, expecting 'a']],
$5, [b], [[, expecting 'b']])])
-AT_PARSER_CHECK([[./input]], [[1]], [[]],
+AT_SKEL_JAVA_IF([AT_JAVA_PARSER_CHECK([[input]], [[0]]],
+ [AT_PARSER_CHECK([[./input]], [[1]]]),
+[[]],
[[syntax error, unexpected ]$4[]AT_EXPECTING[
]])
m4_popdef([AT_EXPECTING])
+m4_popdef([AT_YYLEX_PROTOTYPE])
+AT_BISON_OPTION_POPDEFS
])
+m4_pushdef([AT_PREVIOUS_STATE_GRAMMAR],
+[[%nonassoc 'a';
+
+start: consistent-error-on-a-a 'a' ;
+
+consistent-error-on-a-a:
+ 'a' default-reduction
+ | 'a' default-reduction 'a'
+ | 'a' shift
+ ;
+
+default-reduction: /*empty*/ ;
+shift: 'b' ;
+
+// Provide another context in which all rules are useful so that this
+// test case looks a little more realistic.
+start: 'b' consistent-error-on-a-a 'c' ;
+]])
+
+m4_pushdef([AT_PREVIOUS_STATE_INPUT], [[a]])
+
+# Unfortunately, no expected tokens are reported even though 'b' can be
+# accepted. Nevertheless, the main point of this test is to make sure
+# that at least the unexpected token is reported. In a previous version
+# of Bison, it wasn't reported because the error is detected in a
+# consistent state with an error action, and that case always triggered
+# the simple "syntax error" message.
+#
+# The point isn't to test IELR here, but state merging happens to
+# complicate this example.
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr]],
+ [AT_PREVIOUS_STATE_GRAMMAR],
+ [AT_PREVIOUS_STATE_INPUT],
+ [[$end]], [[none]])
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
+ %glr-parser]],
+ [AT_PREVIOUS_STATE_GRAMMAR],
+ [AT_PREVIOUS_STATE_INPUT],
+ [[$end]], [[none]])
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
+ %language "c++"]],
+ [AT_PREVIOUS_STATE_GRAMMAR],
+ [AT_PREVIOUS_STATE_INPUT],
+ [[$end]], [[none]])
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
+ %language "java"]],
+ [AT_PREVIOUS_STATE_GRAMMAR],
+ [AT_PREVIOUS_STATE_INPUT],
+ [[end of input]], [[none]])
+
+# Even canonical LR doesn't foresee the error for 'a'!
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
+ %define lr.default-reductions consistent]],
+ [AT_PREVIOUS_STATE_GRAMMAR],
+ [AT_PREVIOUS_STATE_INPUT],
+ [[$end]], [[ab]])
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.type ielr
+ %define lr.default-reductions accepting]],
+ [AT_PREVIOUS_STATE_GRAMMAR],
+ [AT_PREVIOUS_STATE_INPUT],
+ [[$end]], [[ab]])
+AT_CONSISTENT_ERRORS_CHECK([[%define lr.type canonical-lr]],
+ [AT_PREVIOUS_STATE_GRAMMAR],
+ [AT_PREVIOUS_STATE_INPUT],
+ [[$end]], [[ab]])
+
+m4_popdef([AT_PREVIOUS_STATE_GRAMMAR])
+m4_popdef([AT_PREVIOUS_STATE_INPUT])
+
m4_pushdef([AT_USER_ACTION_GRAMMAR],
[[%nonassoc 'a';
-// If yylval=0 here, then we know that the 'a' destructor is being
-// invoked incorrectly for the 'b' set in the semantic action below.
-// All 'a' tokens are returned by yylex, which sets yylval=1.
+// If $$ = 0 here, then we know that the 'a' destructor is being invoked
+// incorrectly for the 'b' set in the semantic action below. All 'a'
+// tokens are returned by yylex, which sets $$ = 1.
%destructor {
if (!$$)
fprintf (stderr, "Wrong destructor.\n");
} 'a';
-// The lookahead assigned by the semantic action isn't needed before
-// either error action is encountered. In a previous version of Bison,
-// this was a problem as it meant yychar was not translated into yytoken
-// before either error action. The second error action thus invoked a
+// Rather than depend on an inconsistent state to induce reading a
+// lookahead as in the previous grammar, just assign the lookahead in a
+// semantic action. That lookahead isn't needed before either error
+// action is encountered. In a previous version of Bison, this was a
+// problem as it meant yychar was not translated into yytoken before
+// either error action. The second error action thus invoked a
// destructor that it selected according to the incorrect yytoken. The
// first error action would have reported an incorrect unexpected token
-// except that, due to another bug, the unexpected token is not reported
-// at all because the error action is the default action in a consistent
-// state. That bug still needs to be fixed.
+// except that, due to the bug described in the previous grammar, the
+// unexpected token was not reported at all.
start: error-reduce consistent-error 'a' { USE ($][3); } ;
error-reduce:
@@ -247,13 +392,16 @@ start: 'b' consistent-error 'b' ;
]])
m4_pushdef([AT_USER_ACTION_INPUT], [[aa]])
-# See comments in grammar for why this test doesn't succeed.
-AT_XFAIL_IF([[:]])
-
AT_CONSISTENT_ERRORS_CHECK([[]],
[AT_USER_ACTION_GRAMMAR],
[AT_USER_ACTION_INPUT],
[['b']], [[none]])
+AT_CONSISTENT_ERRORS_CHECK([[%glr-parser]],
+ [AT_USER_ACTION_GRAMMAR],
+ [AT_USER_ACTION_INPUT],
+ [['b']], [[none]])
+# No C++ or Java test because yychar cannot be manipulated by users.
+
AT_CONSISTENT_ERRORS_CHECK([[%define lr.default-reductions consistent]],
[AT_USER_ACTION_GRAMMAR],
[AT_USER_ACTION_INPUT],
diff --git a/tests/java.at b/tests/java.at
index 9ea703f..dfd4252 100644
--- a/tests/java.at
+++ b/tests/java.at
@@ -219,25 +219,6 @@ m4_define([AT_DATA_JAVA_CALC_Y],
])
-
-# AT_JAVA_COMPILE(SOURCE)
-# -----------------------
-# Compile SOURCES into Java class files. Skip the test if java or javac is
-# not installed.
-m4_define([AT_JAVA_COMPILE],
-[AT_KEYWORDS(java)
-AT_CHECK([test -n "$CONF_JAVA" || exit 77
-test -n "$CONF_JAVAC" || exit 77])
-AT_CHECK([$SHELL ../../../javacomp.sh $1],
- 0, [ignore], [ignore])])
-
-
-# AT_JAVA_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
-# -----------------------------------------------------------------
-m4_define([AT_JAVA_PARSER_CHECK],
-[AT_CHECK([$5 $SHELL ../../../javaexec.sh $1], [$2], [$3], [$4])])
-
-
# _AT_CHECK_JAVA_CALC_ERROR(BISON-OPTIONS, INPUT,
# [VERBOSE-AND-LOCATED-ERROR-MESSAGE])
# ---------------------------------------------------------
diff --git a/tests/local.at b/tests/local.at
index d3b245c..bdcbfc4 100644
--- a/tests/local.at
+++ b/tests/local.at
@@ -80,6 +80,8 @@ m4_pushdef([AT_DEFINES_IF],
[m4_bmatch([$3], [%defines], [$1], [$2])])
m4_pushdef([AT_SKEL_CC_IF],
[m4_bmatch([$3], [%language "[Cc]\+\+"\|%skeleton "[a-z0-9]+\.cc"], [$1],
[$2])])
+m4_pushdef([AT_SKEL_JAVA_IF],
+[m4_bmatch([$3], [%language "[Jj][Aa][Vv][Aa]"\|%skeleton "[a-z0-9]+\.java"],
[$1], [$2])])
m4_pushdef([AT_GLR_IF],
[m4_bmatch([$3], [%glr-parser\|%skeleton "glr\.], [$1], [$2])])
m4_pushdef([AT_LALR1_CC_IF],
@@ -189,6 +191,7 @@ m4_popdef([AT_LEXPARAM_IF])
m4_popdef([AT_YACC_IF])
m4_popdef([AT_GLR_IF])
m4_popdef([AT_SKEL_CC_IF])
+m4_popdef([AT_SKEL_JAVA_IF])
m4_popdef([AT_GLR_CC_IF])
m4_popdef([AT_LALR1_CC_IF])
m4_popdef([AT_DEFINES_IF])
@@ -404,19 +407,38 @@ AT_CHECK([$BISON_CXX_WORKS], 0, ignore, ignore)
AT_CHECK([$CXX $CXXFLAGS $CPPFLAGS m4_bmatch([$1], [[.]], [], [$LDFLAGS ])-o
$1 m4_default([$2], [$1.cc])[]m4_bmatch([$1], [[.]], [], [ $LIBS])],
0, [ignore], [ignore])])
+# AT_JAVA_COMPILE(SOURCES)
+# ------------------------
+# Compile SOURCES into Java class files. Skip the test if java or javac
+# is not installed.
+m4_define([AT_JAVA_COMPILE],
+[AT_KEYWORDS(java)
+AT_CHECK([[test -n "$CONF_JAVA" || exit 77
+ test -n "$CONF_JAVAC" || exit 77]])
+AT_CHECK([[$SHELL ../../../javacomp.sh ]$1],
+ [[0]], [ignore], [ignore])])
# AT_FULL_COMPILE(OUTPUT, [OTHER])
# --------------------------------
-# Compile OUTPUT.y to OUTPUT.c or OUTPUT.cc, and compile it to OUTPUT.
-# If OTHER is specified, compile OUTPUT-OTHER.c or OUTPUT-OTHER.cc to OUTPUT
-# along with it.
-# Relies on AT_SKEL_CC_IF.
-m4_define([AT_FULL_COMPILE],
-[AT_SKEL_CC_IF(
- [AT_BISON_CHECK([-o $1.cc $1.y])
- AT_COMPILE_CXX([$1]m4_ifval($2, [, [$1.cc $1-$2.cc]]))],
- [AT_BISON_CHECK([-o $1.c $1.y])
- AT_COMPILE([$1]m4_ifval($2, [, [$1.c $1-$2.c]]))])
+# Compile OUTPUT.y to OUTPUT.c, OUTPUT.cc, or OUTPUT.java, and then
+# compile it to OUTPUT or OUTPUT.class. If OTHER is specified, compile
+# OUTPUT-OTHER.c, OUTPUT-OTHER.cc, or OUTPUT-OTHER.java to OUTPUT or
+# OUTPUT.java along with it. Relies on AT_SKEL_CC_IF and
+# AT_SKEL_JAVA_IF.
+m4_define([AT_FULL_COMPILE], [
+ AT_SKEL_JAVA_IF([
+ AT_BISON_CHECK([[-o ]$1[.java ]$1[.y]])
+ AT_JAVA_COMPILE([$1[.java]]m4_ifval($2,
+ [[$1[.java ]$1[-]$2[.java]]]))
+ ], [
+ AT_SKEL_CC_IF([
+ AT_BISON_CHECK([[-o ]$1[.cc ]$1[.y]])
+ AT_COMPILE_CXX([$1]m4_ifval($2, [, [$1[.cc ]$1[-]$2[.cc]]]))
+ ], [
+ AT_BISON_CHECK([[-o ]$1[.c ]$1[.y]])
+ AT_COMPILE([$1]m4_ifval($2, [, [$1[.c ]$1[-]$2[.c]]]))
+ ])
+ ])
])
@@ -430,6 +452,11 @@ m4_define([AT_FULL_COMPILE],
m4_define([AT_PARSER_CHECK],
[AT_CHECK([$5 $PREPARSER $1], [$2], [$3], [$4])])
+# AT_JAVA_PARSER_CHECK(COMMAND, EXIT-STATUS, EXPOUT, EXPERR, [PRE])
+# -----------------------------------------------------------------
+m4_define([AT_JAVA_PARSER_CHECK],
+[AT_CHECK([$5[ $SHELL ../../../javaexec.sh ]$1], [$2], [$3], [$4])])
+
# AT_TEST_TABLES_AND_PARSE(TITLE, COND-VALUE, TEST-SPEC,
# DECLS, GRAMMAR, INPUT,
# BISON-STDERR, TABLES-OR-LAST-STATE,
--
1.7.0.4
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- yysyntax_error: fix for consistent error with lookahead.,
Joel E. Denny <=