Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-09 12:23:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/maint'

Browse Source 
* origin/maint:
  bump to 2012 in skeletons.
  build: remove ancient Autoconf tests.
  doc: c++: complete the location documentation.
  c++: locations: provide convenience constructors.
  c++: locations: remove useless "inline".
  glr: do not use locations when they are not requested
  c++: use nullptr for C++11.
  build: simplify and improve the compiler warnings for tests.
  gnulib: update.
  maint: formatting changes.
  NEWS: update.
  Java: Fix syntax error handling without error token.
  tests: beware of -pedantic on large #line numbers.
  tests: when using the C++ compiler, use its flags too.

Conflicts:
	data/glr.c
	data/glr.cc
	data/lalr1.cc
	data/location.cc
	data/yacc.c
	tests/Makefile.am
This commit is contained in:
Akim Demaille
2012-04-01 12:56:55 +02:00
parent 24d84dd26c 681dda24ba
commit 3e75a2c92b
19 changed files with 407 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
NEWS
View File

@@ -71,12 +71,43 @@ Bison News
* Changes in version 2.5.1 (????-??-??): * Changes in version 2.5.1 (????-??-??):
** Some portability problems in the test suite have been fixed. ** Several portability problems in the test suite have been fixed:
** Minor improvements have been made to the manual. This includes warnings with some compilers, unexpected behavior of
tools such as diff, warning messages from the test suite itself,
etc.
__attribute__ is not longer disabled when __STRICT_ANSI__ is defined
(i.e., when -std is passed to GCC).
** Warnings during the build procedure have been eliminated.
** Many minor improvements have been made to the manual:
The layout for grammar has changed to a more compact scheme. Named
references are motivated. The description of the automaton
description file is updated.
** YYBACKUP works as expected. ** YYBACKUP works as expected.
** liby is no longer asking for "rpl_fprintf" on some platforms.
** Several Java fixes:
The Java parser no longer throws ArrayIndexOutOfBoundsException if
the first token leads to a syntax error. Some minor clean ups.
** C++11 compatibility:
C and C++ parsers use nullptr instead of 0 when __cplusplus is
201103L or higher.
** C++ locations:
The position and location constructors (and their initialize
methods) accept new arguments for line and column. Several issues
in the documentation were fixed.
* Changes in version 2.5 (2011-05-14): * Changes in version 2.5 (2011-05-14):
** Grammar symbol names can now contain non-initial dashes: ** Grammar symbol names can now contain non-initial dashes:

47
configure.ac
View File

@@ -55,6 +55,7 @@ AC_CONFIG_HEADERS([lib/config.h:lib/config.hin])
# Checks for the compiler. # Checks for the compiler.
AC_PROG_CC_STDC AC_PROG_CC_STDC
AC_PROG_CXX
# Gnulib (early checks). # Gnulib (early checks).
gl_EARLY gl_EARLY
@@ -67,31 +68,36 @@ AC_ARG_ENABLE([gcc-warnings],
esac], esac],
[enable_gcc_warnings=no]) [enable_gcc_warnings=no])
if test "$enable_gcc_warnings" = yes; then if test "$enable_gcc_warnings" = yes; then
warn_common='-Wall -Wextra -Wno-sign-compare -Wcast-align
-Wcast-qual -Wformat -Wpointer-arith -Wwrite-strings'
warn_c='-Wbad-function-cast -Wmissing-declarations -Wmissing-prototypes
-Wshadow -Wstrict-prototypes'
warn_cxx='-Wnoexcept -Wzero-as-null-pointer-constant'
AC_LANG_PUSH([C])
for i in $warn_common $warn_c;
do
gl_WARN_ADD([$i], [WARN_CFLAGS])
done
gl_WARN_ADD([-Werror], [WERROR_CFLAGS]) gl_WARN_ADD([-Werror], [WERROR_CFLAGS])
AC_SUBST([WERROR_CFLAGS])
gl_WARN_ADD([-Wall])
gl_WARN_ADD([-Wextra -Wno-sign-compare])
gl_WARN_ADD([-Wcast-align])
gl_WARN_ADD([-Wcast-qual])
gl_WARN_ADD([-Wformat])
gl_WARN_ADD([-Wpointer-arith])
gl_WARN_ADD([-Wwrite-strings])
AC_SUBST([WARN_CXXFLAGS], [$WARN_CFLAGS])
# The following warnings are not suitable for C++.
gl_WARN_ADD([-Wbad-function-cast])
gl_WARN_ADD([-Wmissing-declarations])
gl_WARN_ADD([-Wmissing-prototypes])
gl_WARN_ADD([-Wshadow])
gl_WARN_ADD([-Wstrict-prototypes])
AC_SUBST([WARN_CFLAGS])
# Warnings for the test suite only. # Warnings for the test suite only.
gl_WARN_ADD([-Wundef], [WARN_CFLAGS_TEST]) gl_WARN_ADD([-Wundef], [WARN_CFLAGS_TEST])
gl_WARN_ADD([-pedantic], [WARN_CFLAGS_TEST]) gl_WARN_ADD([-pedantic], [WARN_CFLAGS_TEST])
AC_SUBST([WARN_CXXFLAGS_TEST], ["$WARN_CXXFLAGS $WARN_CFLAGS_TEST"]) AC_LANG_POP([C])
AC_SUBST([WARN_CFLAGS_TEST], ["$WARN_CFLAGS $WARN_CFLAGS_TEST"])
AC_LANG_PUSH([C++])
for i in $warn_common $warn_cxx;
do
gl_WARN_ADD([$i], [WARN_CXXFLAGS])
done
gl_WARN_ADD([-Werror], [WERROR_CXXFLAGS])
# Warnings for the test suite only.
gl_WARN_ADD([-Wundef], [WARN_CXXFLAGS_TEST])
gl_WARN_ADD([-pedantic], [WARN_CXXFLAGS_TEST])
AC_LANG_POP([C++])
fi fi
BISON_TEST_FOR_WORKING_C_COMPILER BISON_TEST_FOR_WORKING_C_COMPILER
BISON_TEST_FOR_WORKING_CXX_COMPILER
AC_ARG_ENABLE([yacc], AC_ARG_ENABLE([yacc],
[AC_HELP_STRING([--disable-yacc], [AC_HELP_STRING([--disable-yacc],
@@ -133,7 +139,6 @@ gl_INIT
# Checks for library functions. # Checks for library functions.
AC_CHECK_FUNCS_ONCE([setlocale]) AC_CHECK_FUNCS_ONCE([setlocale])
AM_WITH_DMALLOC AM_WITH_DMALLOC
BISON_PREREQ_SUBPIPE
BISON_PREREQ_TIMEVAR BISON_PREREQ_TIMEVAR
# Gettext. # Gettext.
@@ -157,13 +162,9 @@ AC_CONFIG_TESTDIR(tests)
AC_CONFIG_FILES([tests/atlocal]) AC_CONFIG_FILES([tests/atlocal])
AC_CONFIG_FILES([tests/bison], [chmod +x tests/bison]) AC_CONFIG_FILES([tests/bison], [chmod +x tests/bison])
AC_CHECK_PROGS([VALGRIND], [valgrind]) AC_CHECK_PROGS([VALGRIND], [valgrind])
AC_PROG_CXX
BISON_TEST_FOR_WORKING_CXX_COMPILER
AM_MISSING_PROG([AUTOM4TE], [autom4te]) AM_MISSING_PROG([AUTOM4TE], [autom4te])
# Needed by tests/atlocal.in. # Needed by tests/atlocal.in.
AC_SUBST([GCC]) AC_SUBST([GCC])
AC_SUBST([O0CFLAGS], [`echo $CFLAGS | sed 's/-O[[0-9]] *//'`])
AC_SUBST([O0CXXFLAGS], [`echo $CXXFLAGS | sed 's/-O[[0-9]] *//'`])
gt_JAVACOMP([1.3], [1.4]) gt_JAVACOMP([1.3], [1.4])
gt_JAVAEXEC gt_JAVAEXEC

2
data/c++.m4
View File

@@ -99,6 +99,8 @@ m4_map_sep([ b4_token_enum], [,
]) ])
## ----------------- ## ## ----------------- ##
## Semantic Values. ## ## Semantic Values. ##
## ----------------- ## ## ----------------- ##

25
data/c.m4
View File

@@ -171,16 +171,31 @@ m4_define([b4_table_value_equals],
[[YYID (0)]], [[YYID (0)]],
[[((]$2[) == (]$3[))]])]) [[((]$2[) == (]$3[))]])])
## ---------## ## ---------##
## Values. ## ## Values. ##
## ---------## ## ---------##
# b4_null
---------
# Return a null pointer constant. NULL infringes on the user name
# space in C, so use 0 rather than NULL.
m4_define([b4_null], [0])
# b4_null_define
# --------------
# Portability issues: define a YY_NULL appropriate for the current
# language (C, C++98, or C++11).
m4_define([b4_null_define],
[# ifndef YY_NULL
# if defined __cplusplus && 201103L <= __cplusplus
# define YY_NULL nullptr
# else
# define YY_NULL 0
# endif
# endif[]dnl
])
# b4_null
# -------
# Return a null pointer constant.
m4_define([b4_null], [YY_NULL])
# b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT) # b4_integral_parser_table_define(TABLE-NAME, CONTENT, COMMENT)
# ------------------------------------------------------------- # -------------------------------------------------------------

237
data/glr.c
View File

@@ -93,13 +93,27 @@ m4_define([b4_lpure_args],
[b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args]) [b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args])
# b4_pure_formals # b4_pure_formals
# --------------- # ---------------
# Arguments passed to yyerror: user formals plus yylocp. # Arguments passed to yyerror: user formals plus yylocp with leading comma.
m4_define([b4_pure_formals], m4_define([b4_pure_formals],
[b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals]) [b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals])
# b4_locuser_formals(LOC = yylocp)
# --------------------------------
m4_define([b4_locuser_formals],
[b4_locations_if([, YYLTYPE *m4_default([$1], [yylocp])])[]b4_user_formals])
# b4_locuser_args(LOC = yylocp)
# -----------------------------
m4_define([b4_locuser_args],
[b4_locations_if([, m4_default([$1], [yylocp])])[]b4_user_args])
## ----------------- ## ## ----------------- ##
## Semantic Values. ## ## Semantic Values. ##
## ----------------- ## ## ----------------- ##
@@ -179,6 +193,8 @@ m4_if(b4_prefix, [yy], [],
/* Copy the first part of user declarations. */ /* Copy the first part of user declarations. */
]b4_user_pre_prologue ]b4_user_pre_prologue
b4_null_define
dnl # b4_shared_declarations dnl # b4_shared_declarations
dnl # ---------------------- dnl # ----------------------
dnl # Declaration that might either go into the header (if --defines) dnl # Declaration that might either go into the header (if --defines)
@@ -318,8 +334,7 @@ b4_percent_code_get[]dnl
#ifndef __attribute__ #ifndef __attribute__
/* This feature is available in gcc versions 2.5 and later. */ /* This feature is available in gcc versions 2.5 and later. */
# if (! defined __GNUC__ || __GNUC__ < 2 \ # if (! defined __GNUC__ || __GNUC__ < 2 \
|| (__GNUC__ == 2 && __GNUC_MINOR__ < 5) \ || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
|| (defined __STRICT_ANSI__ && __STRICT_ANSI__))
# define __attribute__(Spec) /* empty */ # define __attribute__(Spec) /* empty */
# endif # endif
#endif #endif
@@ -534,8 +549,7 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
if (yydebug) \ if (yydebug) \
{ \ { \
YYFPRINTF (stderr, "%s ", Title); \ YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, Type, \ yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \
Value]b4_locations_if([, Location])[]b4_user_args[); \
YYFPRINTF (stderr, "\n"); \ YYFPRINTF (stderr, "\n"); \
} \ } \
} while (YYID (0)) } while (YYID (0))
@@ -769,7 +783,7 @@ static void yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg)
static void static void
yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg) yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg)
{ {
if (yymsg != NULL) if (yymsg != YY_NULL)
yyerror (]b4_yyerror_args[yymsg); yyerror (]b4_yyerror_args[yymsg);
YYLONGJMP (yystackp->yyexception_buffer, 1); YYLONGJMP (yystackp->yyexception_buffer, 1);
} }
@@ -844,13 +858,11 @@ yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
* yyerr for YYERROR, yyabort for YYABORT. */ * yyerr for YYERROR, yyabort for YYABORT. */
/*ARGSUSED*/ static YYRESULTTAG /*ARGSUSED*/ static YYRESULTTAG
yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
YYSTYPE* yyvalp, yyGLRStack* yystackp,
YYLTYPE* YYOPTIONAL_LOC (yylocp), YYSTYPE* yyvalp]b4_locuser_formals[)
yyGLRStack* yystackp
]b4_user_formals[)
{ {
yybool yynormal __attribute__ ((__unused__)) = yybool yynormal __attribute__ ((__unused__)) =
(yystackp->yysplitPoint == NULL); (yystackp->yysplitPoint == YY_NULL);
int yylow; int yylow;
]b4_parse_param_use([yyvalp], [yylocp])dnl ]b4_parse_param_use([yyvalp], [yylocp])dnl
[# undef yyerrok [# undef yyerrok
@@ -876,9 +888,9 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
if (yyrhslen == 0) if (yyrhslen == 0)
*yyvalp = yyval_default; *yyvalp = yyval_default;
else else
*yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval; *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;]b4_locations_if([[
YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp; yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
]])[ ]])[
switch (yyn) switch (yyn)
{ {
@@ -926,7 +938,7 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[)
{ {
if (yys->yyresolved) if (yys->yyresolved)
yydestruct (yymsg, yystos[yys->yylrState], yydestruct (yymsg, yystos[yys->yylrState],
&yys->yysemantics.yysval]b4_locations_if([, &yys->yyloc])[]b4_user_args[); &yys->yysemantics.yysval]b4_locuser_args([&yys->yyloc])[);
else else
{ {
#if YYDEBUG #if YYDEBUG
@@ -937,7 +949,7 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[)
else else
YYFPRINTF (stderr, "%s incomplete ", yymsg); YYFPRINTF (stderr, "%s incomplete ", yymsg);
yy_symbol_print (stderr, yystos[yys->yylrState], yy_symbol_print (stderr, yystos[yys->yylrState],
NULL]b4_locations_if([, &yys->yyloc])[]b4_user_args[); YY_NULL]b4_locuser_args([&yys->yyloc])[);
YYFPRINTF (stderr, "\n"); YYFPRINTF (stderr, "\n");
} }
#endif #endif
@@ -1068,8 +1080,8 @@ yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
if (yystackp->yytops.yylookaheadNeeds[yyk]) if (yystackp->yytops.yylookaheadNeeds[yyk])
{ {
yynewOption->yyrawchar = yychar; yynewOption->yyrawchar = yychar;
yynewOption->yyval = yylval; yynewOption->yyval = yylval;]b4_locations_if([
yynewOption->yyloc = yylloc; yynewOption->yyloc = yylloc;])[
} }
else else
yynewOption->yyrawchar = YYEMPTY; yynewOption->yyrawchar = YYEMPTY;
@@ -1090,7 +1102,7 @@ yyinitStateSet (yyGLRStateSet* yyset)
yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]); yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);
if (! yyset->yystates) if (! yyset->yystates)
return yyfalse; return yyfalse;
yyset->yystates[0] = NULL; yyset->yystates[0] = YY_NULL;
yyset->yylookaheadNeeds = yyset->yylookaheadNeeds =
(yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]); (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
if (! yyset->yylookaheadNeeds) if (! yyset->yylookaheadNeeds)
@@ -1120,8 +1132,8 @@ yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
if (!yystackp->yyitems) if (!yystackp->yyitems)
return yyfalse; return yyfalse;
yystackp->yynextFree = yystackp->yyitems; yystackp->yynextFree = yystackp->yyitems;
yystackp->yysplitPoint = NULL; yystackp->yysplitPoint = YY_NULL;
yystackp->yylastDeleted = NULL; yystackp->yylastDeleted = YY_NULL;
return yyinitStateSet (&yystackp->yytops); return yyinitStateSet (&yystackp->yytops);
} }
@@ -1160,10 +1172,10 @@ yyexpandGLRStack (yyGLRStack* yystackp)
{ {
yyGLRState* yys0 = &yyp0->yystate; yyGLRState* yys0 = &yyp0->yystate;
yyGLRState* yys1 = &yyp1->yystate; yyGLRState* yys1 = &yyp1->yystate;
if (yys0->yypred != NULL) if (yys0->yypred != YY_NULL)
yys1->yypred = yys1->yypred =
YYRELOC (yyp0, yyp1, yys0->yypred, yystate); YYRELOC (yyp0, yyp1, yys0->yypred, yystate);
if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL) if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != YY_NULL)
yys1->yysemantics.yyfirstVal = yys1->yysemantics.yyfirstVal =
YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption);
} }
@@ -1171,18 +1183,18 @@ yyexpandGLRStack (yyGLRStack* yystackp)
{ {
yySemanticOption* yyv0 = &yyp0->yyoption; yySemanticOption* yyv0 = &yyp0->yyoption;
yySemanticOption* yyv1 = &yyp1->yyoption; yySemanticOption* yyv1 = &yyp1->yyoption;
if (yyv0->yystate != NULL) if (yyv0->yystate != YY_NULL)
yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate);
if (yyv0->yynext != NULL) if (yyv0->yynext != YY_NULL)
yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption);
} }
} }
if (yystackp->yysplitPoint != NULL) if (yystackp->yysplitPoint != YY_NULL)
yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems,
yystackp->yysplitPoint, yystate); yystackp->yysplitPoint, yystate);
for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1) for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1)
if (yystackp->yytops.yystates[yyn] != NULL) if (yystackp->yytops.yystates[yyn] != YY_NULL)
yystackp->yytops.yystates[yyn] = yystackp->yytops.yystates[yyn] =
YYRELOC (yystackp->yyitems, yynewItems, YYRELOC (yystackp->yyitems, yynewItems,
yystackp->yytops.yystates[yyn], yystate); yystackp->yytops.yystates[yyn], yystate);
@@ -1206,7 +1218,7 @@ yyfreeGLRStack (yyGLRStack* yystackp)
static inline void static inline void
yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys) yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
{ {
if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys) if (yystackp->yysplitPoint != YY_NULL && yystackp->yysplitPoint > yys)
yystackp->yysplitPoint = yys; yystackp->yysplitPoint = yys;
} }
@@ -1214,9 +1226,9 @@ yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
static inline void static inline void
yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk) yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
{ {
if (yystackp->yytops.yystates[yyk] != NULL) if (yystackp->yytops.yystates[yyk] != YY_NULL)
yystackp->yylastDeleted = yystackp->yytops.yystates[yyk]; yystackp->yylastDeleted = yystackp->yytops.yystates[yyk];
yystackp->yytops.yystates[yyk] = NULL; yystackp->yytops.yystates[yyk] = YY_NULL;
} }
/** Undelete the last stack in *YYSTACKP that was marked as deleted. Can /** Undelete the last stack in *YYSTACKP that was marked as deleted. Can
@@ -1225,12 +1237,12 @@ yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
static void static void
yyundeleteLastStack (yyGLRStack* yystackp) yyundeleteLastStack (yyGLRStack* yystackp)
{ {
if (yystackp->yylastDeleted == NULL || yystackp->yytops.yysize != 0) if (yystackp->yylastDeleted == YY_NULL || yystackp->yytops.yysize != 0)
return; return;
yystackp->yytops.yystates[0] = yystackp->yylastDeleted; yystackp->yytops.yystates[0] = yystackp->yylastDeleted;
yystackp->yytops.yysize = 1; yystackp->yytops.yysize = 1;
YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
yystackp->yylastDeleted = NULL; yystackp->yylastDeleted = YY_NULL;
} }
static inline void static inline void
@@ -1240,7 +1252,7 @@ yyremoveDeletes (yyGLRStack* yystackp)
yyi = yyj = 0; yyi = yyj = 0;
while (yyj < yystackp->yytops.yysize) while (yyj < yystackp->yytops.yysize)
{ {
if (yystackp->yytops.yystates[yyi] == NULL) if (yystackp->yytops.yystates[yyi] == YY_NULL)
{ {
if (yyi == yyj) if (yyi == yyj)
{ {
@@ -1275,7 +1287,7 @@ yyremoveDeletes (yyGLRStack* yystackp)
static inline void static inline void
yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
size_t yyposn, size_t yyposn,
YYSTYPE* yyvalp, YYLTYPE* yylocp) YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[)
{ {
yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
@@ -1283,8 +1295,8 @@ yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
yynewState->yyposn = yyposn; yynewState->yyposn = yyposn;
yynewState->yyresolved = yytrue; yynewState->yyresolved = yytrue;
yynewState->yypred = yystackp->yytops.yystates[yyk]; yynewState->yypred = yystackp->yytops.yystates[yyk];
yynewState->yysemantics.yysval = *yyvalp; yynewState->yysemantics.yysval = *yyvalp;]b4_locations_if([
yynewState->yyloc = *yylocp; yynewState->yyloc = *yylocp;])[
yystackp->yytops.yystates[yyk] = yynewState; yystackp->yytops.yystates[yyk] = yynewState;
YY_RESERVE_GLRSTACK (yystackp); YY_RESERVE_GLRSTACK (yystackp);
@@ -1303,7 +1315,7 @@ yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
yynewState->yyposn = yyposn; yynewState->yyposn = yyposn;
yynewState->yyresolved = yyfalse; yynewState->yyresolved = yyfalse;
yynewState->yypred = yystackp->yytops.yystates[yyk]; yynewState->yypred = yystackp->yytops.yystates[yyk];
yynewState->yysemantics.yyfirstVal = NULL; yynewState->yysemantics.yyfirstVal = YY_NULL;
yystackp->yytops.yystates[yyk] = yynewState; yystackp->yytops.yystates[yyk] = yynewState;
/* Invokes YY_RESERVE_GLRSTACK. */ /* Invokes YY_RESERVE_GLRSTACK. */
@@ -1359,11 +1371,11 @@ yy_reduce_print (int yynormal, yyGLRStackItem* yyvsp, size_t yyk,
* for userAction. */ * for userAction. */
static inline YYRESULTTAG static inline YYRESULTTAG
yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) YYSTYPE* yyvalp]b4_locuser_formals[)
{ {
int yynrhs = yyrhsLength (yyrule); int yynrhs = yyrhsLength (yyrule);
if (yystackp->yysplitPoint == NULL) if (yystackp->yysplitPoint == YY_NULL)
{ {
/* Standard special case: single stack. */ /* Standard special case: single stack. */
yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
@@ -1372,8 +1384,8 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
yystackp->yyspaceLeft += yynrhs; yystackp->yyspaceLeft += yynrhs;
yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule]b4_user_args[)); YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule]b4_user_args[));
return yyuserAction (yyrule, yynrhs, yyrhs, return yyuserAction (yyrule, yynrhs, yyrhs, yystackp,
yyvalp, yylocp, yystackp]b4_user_args[); yyvalp]b4_locuser_args[);
} }
else else
{ {
@@ -1394,7 +1406,7 @@ yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
yystackp->yytops.yystates[yyk] = yys; yystackp->yytops.yystates[yyk] = yys;
YY_REDUCE_PRINT ((0, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule]b4_user_args[)); YY_REDUCE_PRINT ((0, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule]b4_user_args[));
return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
yyvalp, yylocp, yystackp]b4_user_args[); yystackp, yyvalp]b4_locuser_args[);
} }
} }
@@ -1415,14 +1427,13 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
{ {
size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn; size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
if (yyforceEval || yystackp->yysplitPoint == NULL) if (yyforceEval || yystackp->yysplitPoint == YY_NULL)
{ {
YYRESULTTAG yyflag; YYRESULTTAG yyflag;
YYSTYPE yysval; YYSTYPE yysval;]b4_locations_if([
YYLTYPE yyloc; YYLTYPE yyloc;])[
yyflag = yydoAction (yystackp, yyk, yyrule, &yysval, yyflag = yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[);
&yyloc]b4_user_args[);
if (yyflag == yyerr && yystackp->yysplitPoint != NULL) if (yyflag == yyerr && yystackp->yysplitPoint != NULL)
{ {
YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n", YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n",
@@ -1434,7 +1445,7 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
yyglrShift (yystackp, yyk, yyglrShift (yystackp, yyk,
yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
yylhsNonterm (yyrule)), yylhsNonterm (yyrule)),
yyposn, &yysval, &yyloc); yyposn, &yysval]b4_locations_if([, &yyloc])[);
} }
else else
{ {
@@ -1456,7 +1467,7 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
"Now in state %d.\n", "Now in state %d.\n",
(unsigned long int) yyk, yyrule - 1, yynewLRState)); (unsigned long int) yyk, yyrule - 1, yynewLRState));
for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL) if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULL)
{ {
yyGLRState* yyp, *yysplit = yystackp->yysplitPoint; yyGLRState* yyp, *yysplit = yystackp->yysplitPoint;
yyp = yystackp->yytops.yystates[yyi]; yyp = yystackp->yytops.yystates[yyi];
@@ -1483,7 +1494,7 @@ yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
static size_t static size_t
yysplitStack (yyGLRStack* yystackp, size_t yyk) yysplitStack (yyGLRStack* yystackp, size_t yyk)
{ {
if (yystackp->yysplitPoint == NULL) if (yystackp->yysplitPoint == YY_NULL)
{ {
YYASSERT (yyk == 0); YYASSERT (yyk == 0);
yystackp->yysplitPoint = yystackp->yytops.yystates[yyk]; yystackp->yysplitPoint = yystackp->yytops.yystates[yyk];
@@ -1493,7 +1504,7 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk)
yyGLRState** yynewStates; yyGLRState** yynewStates;
yybool* yynewLookaheadNeeds; yybool* yynewLookaheadNeeds;
yynewStates = NULL; yynewStates = YY_NULL;
if (yystackp->yytops.yycapacity if (yystackp->yytops.yycapacity
> (YYSIZEMAX / (2 * sizeof yynewStates[0]))) > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
@@ -1504,7 +1515,7 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk)
(yyGLRState**) YYREALLOC (yystackp->yytops.yystates, (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
(yystackp->yytops.yycapacity (yystackp->yytops.yycapacity
* sizeof yynewStates[0])); * sizeof yynewStates[0]));
if (yynewStates == NULL) if (yynewStates == YY_NULL)
yyMemoryExhausted (yystackp); yyMemoryExhausted (yystackp);
yystackp->yytops.yystates = yynewStates; yystackp->yytops.yystates = yynewStates;
@@ -1512,7 +1523,7 @@ yysplitStack (yyGLRStack* yystackp, size_t yyk)
(yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
(yystackp->yytops.yycapacity (yystackp->yytops.yycapacity
* sizeof yynewLookaheadNeeds[0])); * sizeof yynewLookaheadNeeds[0]));
if (yynewLookaheadNeeds == NULL) if (yynewLookaheadNeeds == YY_NULL)
yyMemoryExhausted (yystackp); yyMemoryExhausted (yystackp);
yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
} }
@@ -1578,9 +1589,9 @@ yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
yyz1 = yys1->yysemantics.yyfirstVal; yyz1 = yys1->yysemantics.yyfirstVal;
while (YYID (yytrue)) while (YYID (yytrue))
{ {
if (yyz1 == *yyz0p || yyz1 == NULL) if (yyz1 == *yyz0p || yyz1 == YY_NULL)
break; break;
else if (*yyz0p == NULL) else if (*yyz0p == YY_NULL)
{ {
*yyz0p = yyz1; *yyz0p = yyz1;
break; break;
@@ -1654,13 +1665,13 @@ yyresolveStates (yyGLRState* yys, int yyn,
* semantic values if invoked). */ * semantic values if invoked). */
static YYRESULTTAG static YYRESULTTAG
yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) YYSTYPE* yyvalp]b4_locuser_formals[)
{ {
yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
int yynrhs; int yynrhs;
int yychar_current; int yychar_current;
YYSTYPE yylval_current; YYSTYPE yylval_current;]b4_locations_if([
YYLTYPE yylloc_current; YYLTYPE yylloc_current;])[
YYRESULTTAG yyflag; YYRESULTTAG yyflag;
yynrhs = yyrhsLength (yyopt->yyrule); yynrhs = yyrhsLength (yyopt->yyrule);
@@ -1678,17 +1689,17 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
/* Set default location. */ /* Set default location. */
yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
yychar_current = yychar; yychar_current = yychar;
yylval_current = yylval; yylval_current = yylval;]b4_locations_if([
yylloc_current = yylloc; yylloc_current = yylloc;])[
yychar = yyopt->yyrawchar; yychar = yyopt->yyrawchar;
yylval = yyopt->yyval; yylval = yyopt->yyval;]b4_locations_if([
yylloc = yyopt->yyloc; yylloc = yyopt->yyloc;])[
yyflag = yyuserAction (yyopt->yyrule, yynrhs, yyflag = yyuserAction (yyopt->yyrule, yynrhs,
yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
yyvalp, yylocp, yystackp]b4_user_args[); yystackp, yyvalp]b4_locuser_args[);
yychar = yychar_current; yychar = yychar_current;
yylval = yylval_current; yylval = yylval_current;]b4_locations_if([
yylloc = yylloc_current; yylloc = yylloc_current;])[
return yyflag; return yyflag;
} }
@@ -1704,7 +1715,7 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred) for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
yystates[yyi] = yys; yystates[yyi] = yys;
if (yys == NULL) if (yys == YY_NULL)
{ {
yyleftmost_state.yyposn = 0; yyleftmost_state.yyposn = 0;
yystates[0] = &yyleftmost_state; yystates[0] = &yyleftmost_state;
@@ -1779,7 +1790,7 @@ yyresolveLocations (yyGLRState* yys1, int yyn1,
YYSTYPE yylval_current; YYSTYPE yylval_current;
YYLTYPE yylloc_current; YYLTYPE yylloc_current;
yyoption = yys1->yysemantics.yyfirstVal; yyoption = yys1->yysemantics.yyfirstVal;
YYASSERT (yyoption != NULL); YYASSERT (yyoption != YY_NULL);
yynrhs = yyrhsLength (yyoption->yyrule); yynrhs = yyrhsLength (yyoption->yyrule);
if (yynrhs > 0) if (yynrhs > 0)
{ {
@@ -1829,16 +1840,14 @@ static YYRESULTTAG
yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[) yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
{ {
yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal; yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
yySemanticOption* yybest; yySemanticOption* yybest = yyoptionList;
yySemanticOption** yypp; yySemanticOption** yypp;
yybool yymerge; yybool yymerge = yyfalse;
YYSTYPE yysval; YYSTYPE yysval;
YYRESULTTAG yyflag; YYRESULTTAG yyflag;]b4_locations_if([
YYLTYPE *yylocp = &yys->yyloc; YYLTYPE *yylocp = &yys->yyloc;])[
yybest = yyoptionList; for (yypp = &yyoptionList->yynext; *yypp != YY_NULL; )
yymerge = yyfalse;
for (yypp = &yyoptionList->yynext; *yypp != NULL; )
{ {
yySemanticOption* yyp = *yypp; yySemanticOption* yyp = *yypp;
@@ -1878,22 +1887,20 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
{ {
yySemanticOption* yyp; yySemanticOption* yyp;
int yyprec = yydprec[yybest->yyrule]; int yyprec = yydprec[yybest->yyrule];
yyflag = yyresolveAction (yybest, yystackp, &yysval, yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args[);
yylocp]b4_user_args[);
if (yyflag == yyok) if (yyflag == yyok)
for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext) for (yyp = yybest->yynext; yyp != YY_NULL; yyp = yyp->yynext)
{ {
if (yyprec == yydprec[yyp->yyrule]) if (yyprec == yydprec[yyp->yyrule])
{ {
YYSTYPE yysval_other; YYSTYPE yysval_other;]b4_locations_if([
YYLTYPE yydummy; YYLTYPE yydummy;])[
yyflag = yyresolveAction (yyp, yystackp, &yysval_other, yyflag = yyresolveAction (yyp, yystackp, &yysval_other]b4_locuser_args([&yydummy])[);
&yydummy]b4_user_args[);
if (yyflag != yyok) if (yyflag != yyok)
{ {
yydestruct ("Cleanup: discarding incompletely merged value for", yydestruct ("Cleanup: discarding incompletely merged value for",
yystos[yys->yylrState], yystos[yys->yylrState],
&yysval]b4_locations_if([, yylocp])[]b4_user_args[); &yysval]b4_locuser_args[);
break; break;
} }
yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
@@ -1901,7 +1908,7 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
} }
} }
else else
yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[); yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args([yylocp])[);
if (yyflag == yyok) if (yyflag == yyok)
{ {
@@ -1909,14 +1916,14 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
yys->yysemantics.yysval = yysval; yys->yysemantics.yysval = yysval;
} }
else else
yys->yysemantics.yyfirstVal = NULL; yys->yysemantics.yyfirstVal = YY_NULL;
return yyflag; return yyflag;
} }
static YYRESULTTAG static YYRESULTTAG
yyresolveStack (yyGLRStack* yystackp]b4_user_formals[) yyresolveStack (yyGLRStack* yystackp]b4_user_formals[)
{ {
if (yystackp->yysplitPoint != NULL) if (yystackp->yysplitPoint != YY_NULL)
{ {
yyGLRState* yys; yyGLRState* yys;
int yyn; int yyn;
@@ -1936,10 +1943,10 @@ yycompressStack (yyGLRStack* yystackp)
{ {
yyGLRState* yyp, *yyq, *yyr; yyGLRState* yyp, *yyq, *yyr;
if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL) if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == YY_NULL)
return; return;
for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL; for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = YY_NULL;
yyp != yystackp->yysplitPoint; yyp != yystackp->yysplitPoint;
yyr = yyp, yyp = yyq, yyq = yyp->yypred) yyr = yyp, yyp = yyq, yyq = yyp->yypred)
yyp->yypred = yyr; yyp->yypred = yyr;
@@ -1947,10 +1954,10 @@ yycompressStack (yyGLRStack* yystackp)
yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems; yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1; yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems; yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;
yystackp->yysplitPoint = NULL; yystackp->yysplitPoint = YY_NULL;
yystackp->yylastDeleted = NULL; yystackp->yylastDeleted = YY_NULL;
while (yyr != NULL) while (yyr != YY_NULL)
{ {
yystackp->yynextFree->yystate = *yyr; yystackp->yynextFree->yystate = *yyr;
yyr = yyr->yypred; yyr = yyr->yypred;
@@ -1965,7 +1972,7 @@ static YYRESULTTAG
yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
size_t yyposn]b4_pure_formals[) size_t yyposn]b4_pure_formals[)
{ {
while (yystackp->yytops.yystates[yyk] != NULL) while (yystackp->yytops.yystates[yyk] != YY_NULL)
{ {
yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState; yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
YYDPRINTF ((stderr, "Stack %lu Entering state %d\n", YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
@@ -2086,14 +2093,14 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
yyerror (]b4_lyyerror_args[YY_("syntax error")); yyerror (]b4_lyyerror_args[YY_("syntax error"));
#else #else
yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); yySymbol yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken)); size_t yysize0 = yytnamerr (YY_NULL, yytokenName (yytoken));
size_t yysize = yysize0; size_t yysize = yysize0;
size_t yysize1; size_t yysize1;
yybool yysize_overflow = yyfalse; yybool yysize_overflow = yyfalse;
char* yymsg = NULL; char* yymsg = YY_NULL;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */ /* Internationalized format string. */
const char *yyformat = 0; const char *yyformat = YY_NULL;
/* Arguments of yyformat. */ /* Arguments of yyformat. */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Number of reported tokens (one for the "unexpected", one per /* Number of reported tokens (one for the "unexpected", one per
@@ -2148,7 +2155,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
break; break;
} }
yyarg[yycount++] = yytokenName (yyx); yyarg[yycount++] = yytokenName (yyx);
yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx)); yysize1 = yysize + yytnamerr (YY_NULL, yytokenName (yyx));
yysize_overflow |= yysize1 < yysize; yysize_overflow |= yysize1 < yysize;
yysize = yysize1; yysize = yysize1;
} }
@@ -2222,7 +2229,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
{ {
yySymbol yytoken; yySymbol yytoken;
if (yychar == YYEOF) if (yychar == YYEOF)
yyFail (yystackp][]b4_lpure_args[, NULL); yyFail (yystackp][]b4_lpure_args[, YY_NULL);
if (yychar != YYEMPTY) if (yychar != YYEMPTY)
{]b4_locations_if([[ {]b4_locations_if([[
/* We throw away the lookahead, but the error range /* We throw away the lookahead, but the error range
@@ -2234,7 +2241,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
yytoken = YYTRANSLATE (yychar); yytoken = YYTRANSLATE (yychar);
yydestruct ("Error: discarding", yydestruct ("Error: discarding",
yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); yytoken, &yylval]b4_locuser_args([&yylloc])[);
} }
YYDPRINTF ((stderr, "Reading a token: ")); YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX; yychar = YYLEX;
@@ -2263,10 +2270,10 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
/* Reduce to one stack. */ /* Reduce to one stack. */
for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1) for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
if (yystackp->yytops.yystates[yyk] != NULL) if (yystackp->yytops.yystates[yyk] != YY_NULL)
break; break;
if (yyk >= yystackp->yytops.yysize) if (yyk >= yystackp->yytops.yysize)
yyFail (yystackp][]b4_lpure_args[, NULL); yyFail (yystackp][]b4_lpure_args[, YY_NULL);
for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1) for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
yymarkStackDeleted (yystackp, yyk); yymarkStackDeleted (yystackp, yyk);
yyremoveDeletes (yystackp); yyremoveDeletes (yystackp);
@@ -2274,7 +2281,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
/* Now pop stack until we find a state that shifts the error token. */ /* Now pop stack until we find a state that shifts the error token. */
yystackp->yyerrState = 3; yystackp->yyerrState = 3;
while (yystackp->yytops.yystates[0] != NULL) while (yystackp->yytops.yystates[0] != YY_NULL)
{ {
yyGLRState *yys = yystackp->yytops.yystates[0]; yyGLRState *yys = yystackp->yytops.yystates[0];
yyj = yypact[yys->yylrState]; yyj = yypact[yys->yylrState];
@@ -2284,27 +2291,28 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
&& yyisShiftAction (yytable[yyj])) && yyisShiftAction (yytable[yyj]))
{ {
/* Shift the error token having adjusted its location. */ /* Shift the error token. */]b4_locations_if([[
YYLTYPE yyerrloc;]b4_locations_if([[ /* First adjust its location.*/
YYLTYPE yyerrloc;
yystackp->yyerror_range[2].yystate.yyloc = yylloc; yystackp->yyerror_range[2].yystate.yyloc = yylloc;
YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
&yylval, &yyerrloc); &yylval, &yyerrloc);
yyglrShift (yystackp, 0, yytable[yyj], yyglrShift (yystackp, 0, yytable[yyj],
yys->yyposn, &yylval, &yyerrloc); yys->yyposn, &yylval]b4_locations_if([, &yyerrloc])[);
yys = yystackp->yytops.yystates[0]; yys = yystackp->yytops.yystates[0];
break; break;
} }
} }]b4_locations_if([[
]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
if (yys->yypred != NULL) if (yys->yypred != YY_NULL)
yydestroyGLRState ("Error: popping", yys]b4_user_args[); yydestroyGLRState ("Error: popping", yys]b4_user_args[);
yystackp->yytops.yystates[0] = yys->yypred; yystackp->yytops.yystates[0] = yys->yypred;
yystackp->yynextFree -= 1; yystackp->yynextFree -= 1;
yystackp->yyspaceLeft += 1; yystackp->yyspaceLeft += 1;
} }
if (yystackp->yytops.yystates[0] == NULL) if (yystackp->yytops.yystates[0] == YY_NULL)
yyFail (yystackp][]b4_lpure_args[, NULL); yyFail (yystackp][]b4_lpure_args[, YY_NULL);
} }
#define YYCHK1(YYE) \ #define YYCHK1(YYE) \
@@ -2361,7 +2369,7 @@ m4_popdef([b4_at_dollar])])dnl
case 2: goto yyexhaustedlab; case 2: goto yyexhaustedlab;
default: goto yybuglab; default: goto yybuglab;
} }
yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc); yyglrShift (&yystack, 0, 0, 0, &yylval]b4_locations_if([, &yylloc])[);
yyposn = 0; yyposn = 0;
while (YYID (yytrue)) while (YYID (yytrue))
@@ -2419,7 +2427,7 @@ m4_popdef([b4_at_dollar])])dnl
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
yychar = YYEMPTY; yychar = YYEMPTY;
yyposn += 1; yyposn += 1;
yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc); yyglrShift (&yystack, 0, yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[);
if (0 < yystack.yyerrState) if (0 < yystack.yyerrState)
yystack.yyerrState -= 1; yystack.yyerrState -= 1;
} }
@@ -2495,7 +2503,7 @@ m4_popdef([b4_at_dollar])])dnl
YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys)); YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
yyglrShift (&yystack, yys, yyaction, yyposn, yyglrShift (&yystack, yys, yyaction, yyposn,
&yylval, &yylloc); &yylval]b4_locations_if([, &yylloc])[);
YYDPRINTF ((stderr, "Stack %lu now in state #%d\n", YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
(unsigned long int) yys, (unsigned long int) yys,
yystack.yytops.yystates[yys]->yylrState)); yystack.yytops.yystates[yys]->yylrState));
@@ -2535,8 +2543,7 @@ m4_popdef([b4_at_dollar])])dnl
yyreturn: yyreturn:
if (yychar != YYEMPTY) if (yychar != YYEMPTY)
yydestruct ("Cleanup: discarding lookahead", yydestruct ("Cleanup: discarding lookahead",
YYTRANSLATE (yychar), YYTRANSLATE (yychar), &yylval]b4_locuser_args([&yylloc])[);
&yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
/* If the stack is well-formed, pop the stack until it is empty, /* If the stack is well-formed, pop the stack until it is empty,
destroying its entries as we go. But free the stack regardless destroying its entries as we go. But free the stack regardless
@@ -2555,7 +2562,7 @@ m4_popdef([b4_at_dollar])])dnl
{ {
yyGLRState *yys = yystates[yyk]; yyGLRState *yys = yystates[yyk];
]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
)[ if (yys->yypred != NULL) )[ if (yys->yypred != YY_NULL)
yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
yystates[yyk] = yys->yypred; yystates[yyk] = yys->yypred;
yystack.yynextFree -= 1; yystack.yynextFree -= 1;
@@ -2592,7 +2599,7 @@ yy_yypstack (yyGLRState* yys)
static void static void
yypstates (yyGLRState* yyst) yypstates (yyGLRState* yyst)
{ {
if (yyst == NULL) if (yyst == YY_NULL)
YYFPRINTF (stderr, "<null>"); YYFPRINTF (stderr, "<null>");
else else
yy_yypstack (yyst); yy_yypstack (yyst);
@@ -2606,7 +2613,7 @@ yypstack (yyGLRStack* yystackp, size_t yyk)
} }
#define YYINDEX(YYX) \ #define YYINDEX(YYX) \
((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems) ((YYX) == YY_NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
static void static void

4
data/lalr1.cc
View File

@@ -157,6 +157,8 @@ dnl FIXME: This is wrong, we want computed header guards.
b4_variant_define b4_variant_define
b4_namespace_close])[ b4_namespace_close])[
]b4_null_define[
/* Enabling traces. */ /* Enabling traces. */
#ifndef YYDEBUG #ifndef YYDEBUG
# define YYDEBUG ]b4_parse_trace_if([1], [0])[ # define YYDEBUG ]b4_parse_trace_if([1], [0])[
@@ -1056,7 +1058,7 @@ b4_error_verbose_if([state_type yystate, int yytoken],
} }
} }
char const* yyformat = 0; char const* yyformat = YY_NULL;
switch (yycount) switch (yycount)
{ {
#define YYCASE_(N, S) \ #define YYCASE_(N, S) \

2
data/lalr1.java
View File

@@ -686,7 +686,7 @@ m4_popdef([b4_at_dollar])])dnl
} }
/* Pop the current state because it cannot handle the error token. */ /* Pop the current state because it cannot handle the error token. */
if (yystack.height == 1) if (yystack.height == 0)
return false; return false;
]b4_locations_if([yyerrloc = yystack.locationAt (0);])[ ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[

29
data/location.cc
View File

@@ -36,6 +36,8 @@ b4_copyright([Positions for Bison parsers in C++])[
# include <string> # include <string>
# include <algorithm> # include <algorithm>
]b4_null_define[
]b4_namespace_open[ ]b4_namespace_open[
/// Abstract a position. /// Abstract a position.
class position class position
@@ -43,7 +45,7 @@ b4_copyright([Positions for Bison parsers in C++])[
public: public:
]m4_ifdef([b4_location_constructors], [[ ]m4_ifdef([b4_location_constructors], [[
/// Construct a position. /// Construct a position.
explicit position (]b4_percent_define_get([[filename_type]])[* f = 0, explicit position (]b4_percent_define_get([[filename_type]])[* f = YY_NULL,
unsigned int l = ]b4_location_initial_line[u, unsigned int l = ]b4_location_initial_line[u,
unsigned int c = ]b4_location_initial_column[u) unsigned int c = ]b4_location_initial_column[u)
: filename (f) : filename (f)
@@ -54,25 +56,26 @@ b4_copyright([Positions for Bison parsers in C++])[
]])[ ]])[
/// Initialization. /// Initialization.
inline void initialize (]b4_percent_define_get([[filename_type]])[* fn) void initialize (]b4_percent_define_get([[filename_type]])[* fn = YY_NULL,
unsigned int l = ]b4_location_initial_line[u,
unsigned int c = ]b4_location_initial_column[u)
{ {
filename = fn; filename = fn;
line = ]b4_location_initial_line[u; line = l;
column = ]b4_location_initial_column[u; column = c;
} }
/** \name Line and Column related manipulators /** \name Line and Column related manipulators
** \{ */ ** \{ */
/// (line related) Advance to the COUNT next lines. /// (line related) Advance to the COUNT next lines.
/// Set current column to initial value. void lines (int count = 1)
inline void lines (int count = 1)
{ {
column = ]b4_location_initial_column[u; column = ]b4_location_initial_column[u;
line += count; line += count;
} }
/// (column related) Advance to the COUNT next columns. /// (column related) Advance to the COUNT next columns.
inline void columns (int count = 1) void columns (int count = 1)
{ {
column = std::max (]b4_location_initial_column[u, column + count); column = std::max (]b4_location_initial_column[u, column + count);
} }
@@ -195,9 +198,11 @@ b4_copyright([Locations for Bison parsers in C++])[
])[ ])[
/// Initialization. /// Initialization.
inline void initialize (]b4_percent_define_get([[filename_type]])[* fn) void initialize (]b4_percent_define_get([[filename_type]])[* f = YY_NULL,
unsigned int l = ]b4_location_initial_line[u,
unsigned int c = ]b4_location_initial_column[u)
{ {
begin.initialize (fn); begin.initialize (f, l, c);
end = begin; end = begin;
} }
@@ -205,19 +210,19 @@ b4_copyright([Locations for Bison parsers in C++])[
** \{ */ ** \{ */
public: public:
/// Reset initial location to final location. /// Reset initial location to final location.
inline void step () void step ()
{ {
begin = end; begin = end;
} }
/// Extend the current location to the COUNT next columns. /// Extend the current location to the COUNT next columns.
inline void columns (unsigned int count = 1) void columns (unsigned int count = 1)
{ {
end += count; end += count;
} }
/// Extend the current location to the COUNT next lines. /// Extend the current location to the COUNT next lines.
inline void lines (unsigned int count = 1) void lines (unsigned int count = 1)
{ {
end.lines (count); end.lines (count);
} }

2
data/yacc.c
View File

@@ -268,6 +268,8 @@ m4_if(b4_prefix, [yy], [],
/* Copy the first part of user declarations. */ /* Copy the first part of user declarations. */
]b4_user_pre_prologue[ ]b4_user_pre_prologue[
]b4_null_define[
/* Enabling traces. */ /* Enabling traces. */
#ifndef YYDEBUG #ifndef YYDEBUG
# define YYDEBUG ]b4_parse_trace_if([1], [0])[ # define YYDEBUG ]b4_parse_trace_if([1], [0])[

102
doc/bison.texinfo
View File

@@ -320,6 +320,11 @@ C++ Parsers
* C++ Scanner Interface:: Exchanges between yylex and parse * C++ Scanner Interface:: Exchanges between yylex and parse
* A Complete C++ Example:: Demonstrating their use * A Complete C++ Example:: Demonstrating their use
C++ Location Values
* C++ position:: One point in the source file
* C++ location:: Two points in the source file
A Complete C++ Example A Complete C++ Example
* Calc++ --- C++ Calculator:: The specifications * Calc++ --- C++ Calculator:: The specifications
@@ -9324,55 +9329,98 @@ define a @code{position}, a single point in a file, and a @code{location}, a
range composed of a pair of @code{position}s (possibly spanning several range composed of a pair of @code{position}s (possibly spanning several
files). files).
@deftypemethod {position} {std::string*} file @tindex uint
In this section @code{uint} is an abbreviation for @code{unsigned int}: in
genuine code only the latter is used.
@menu
* C++ position:: One point in the source file
* C++ location:: Two points in the source file
@end menu
@node C++ position
@subsubsection C++ @code{position}
@deftypeop {Constructor} {position} {} position (std::string* @var{file} = 0, uint @var{line} = 1, uint @var{col} = 1)
Create a @code{position} denoting a given point. Note that @code{file} is
not reclaimed when the @code{position} is destroyed: memory managed must be
handled elsewhere.
@end deftypeop
@deftypemethod {position} {void} initialize (std::string* @var{file} = 0, uint @var{line} = 1, uint @var{col} = 1)
Reset the position to the given values.
@end deftypemethod
@deftypeivar {position} {std::string*} file
The name of the file. It will always be handled as a pointer, the The name of the file. It will always be handled as a pointer, the
parser will never duplicate nor deallocate it. As an experimental parser will never duplicate nor deallocate it. As an experimental
feature you may change it to @samp{@var{type}*} using @samp{%define feature you may change it to @samp{@var{type}*} using @samp{%define
filename_type "@var{type}"}. filename_type "@var{type}"}.
@end deftypemethod @end deftypeivar
@deftypemethod {position} {unsigned int} line @deftypeivar {position} {uint} line
The line, starting at 1. The line, starting at 1.
@end deftypemethod @end deftypeivar
@deftypemethod {position} {unsigned int} lines (int @var{height} = 1) @deftypemethod {position} {uint} lines (int @var{height} = 1)
Advance by @var{height} lines, resetting the column number. Advance by @var{height} lines, resetting the column number.
@end deftypemethod @end deftypemethod
@deftypemethod {position} {unsigned int} column @deftypeivar {position} {uint} column
The column, starting at 0. The column, starting at 1.
@end deftypemethod @end deftypeivar
@deftypemethod {position} {unsigned int} columns (int @var{width} = 1) @deftypemethod {position} {uint} columns (int @var{width} = 1)
Advance by @var{width} columns, without changing the line number. Advance by @var{width} columns, without changing the line number.
@end deftypemethod @end deftypemethod
@deftypemethod {position} {position&} operator+= (position& @var{pos}, int @var{width}) @deftypemethod {position} {position&} operator+= (int @var{width})
@deftypemethodx {position} {position} operator+ (const position& @var{pos}, int @var{width}) @deftypemethodx {position} {position} operator+ (int @var{width})
@deftypemethodx {position} {position&} operator-= (const position& @var{pos}, int @var{width}) @deftypemethodx {position} {position&} operator-= (int @var{width})
@deftypemethodx {position} {position} operator- (position& @var{pos}, int @var{width}) @deftypemethodx {position} {position} operator- (int @var{width})
Various forms of syntactic sugar for @code{columns}. Various forms of syntactic sugar for @code{columns}.
@end deftypemethod @end deftypemethod
@deftypemethod {position} {position} operator<< (std::ostream @var{o}, const position& @var{p}) @deftypemethod {position} {bool} operator== (const position& @var{that})
@deftypemethodx {position} {bool} operator!= (const position& @var{that})
Whether @code{*this} and @code{that} denote equal/different positions.
@end deftypemethod
@deftypefun {std::ostream&} operator<< (std::ostream& @var{o}, const position& @var{p})
Report @var{p} on @var{o} like this: Report @var{p} on @var{o} like this:
@samp{@var{file}:@var{line}.@var{column}}, or @samp{@var{file}:@var{line}.@var{column}}, or
@samp{@var{line}.@var{column}} if @var{file} is null. @samp{@var{line}.@var{column}} if @var{file} is null.
@end deftypefun
@node C++ location
@subsubsection C++ @code{location}
@deftypeop {Constructor} {location} {} location (const position& @var{begin}, const position& @var{end})
Create a @code{Location} from the endpoints of the range.
@end deftypeop
@deftypeop {Constructor} {location} {} location (const position& @var{pos} = position())
@deftypeopx {Constructor} {location} {} location (std::string* @var{file}, uint @var{line}, uint @var{col})
Create a @code{Location} denoting an empty range located at a given point.
@end deftypeop
@deftypemethod {location} {void} initialize (std::string* @var{file} = 0, uint @var{line} = 1, uint @var{col} = 1)
Reset the location to an empty range at the given values.
@end deftypemethod @end deftypemethod
@deftypemethod {location} {position} begin @deftypeivar {location} {position} begin
@deftypemethodx {location} {position} end @deftypeivarx {location} {position} end
The first, inclusive, position of the range, and the first beyond. The first, inclusive, position of the range, and the first beyond.
@end deftypemethod @end deftypeivar
@deftypemethod {location} {unsigned int} columns (int @var{width} = 1) @deftypemethod {location} {uint} columns (int @var{width} = 1)
@deftypemethodx {location} {unsigned int} lines (int @var{height} = 1) @deftypemethodx {location} {uint} lines (int @var{height} = 1)
Advance the @code{end} position. Advance the @code{end} position.
@end deftypemethod @end deftypemethod
@deftypemethod {location} {location} operator+ (const location& @var{begin}, const location& @var{end}) @deftypemethod {location} {location} operator+ (const location& @var{end})
@deftypemethodx {location} {location} operator+ (const location& @var{begin}, int @var{width}) @deftypemethodx {location} {location} operator+ (int @var{width})
@deftypemethodx {location} {location} operator+= (const location& @var{loc}, int @var{width}) @deftypemethodx {location} {location} operator+= (int @var{width})
Various forms of syntactic sugar. Various forms of syntactic sugar.
@end deftypemethod @end deftypemethod
@@ -9380,6 +9428,16 @@ Various forms of syntactic sugar.
Move @code{begin} onto @code{end}. Move @code{begin} onto @code{end}.
@end deftypemethod @end deftypemethod
@deftypemethod {location} {bool} operator== (const location& @var{that})
@deftypemethodx {location} {bool} operator!= (const location& @var{that})
Whether @code{*this} and @code{that} denote equal/different ranges of
positions.
@end deftypemethod
@deftypefun {std::ostream&} operator<< (std::ostream& @var{o}, const location& @var{p})
Report @var{p} on @var{o}, taking care of special cases such as: no
@code{filename} defined, or equal filename/line or column.
@end deftypefun
@node C++ Parser Interface @node C++ Parser Interface
@subsection C++ Parser Interface @subsection C++ Parser Interface

2
gnulib

Submodule gnulib updated: cbf7a84bcf...0e9d9267fa

2
lib/libiberty.h
View File

@@ -24,7 +24,7 @@
# define BISON_LIBIBERTY_H_ 1 # define BISON_LIBIBERTY_H_ 1
# ifndef __attribute__ # ifndef __attribute__
# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8) || __STRICT_ANSI__ # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)
# define __attribute__(x) # define __attribute__(x)
# endif # endif
# endif # endif

28
m4/subpipe.m4
View File

@@ -1,28 +0,0 @@
# -*- Autoconf -*-
# Checks required to run `subpipe'.
#
# Copyright (C) 2002-2003, 2005, 2009-2012 Free Software Foundation,
# Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# 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, see <http://www.gnu.org/licenses/>.
# Written by Paul Eggert <eggert@twinsun.com>.
AC_DEFUN([BISON_PREREQ_SUBPIPE],
[
AC_TYPE_PID_T
AC_HEADER_SYS_WAIT
AC_CHECK_FUNCS(dup2 waitpid)
AC_FUNC_FORK
])

2
src/system.h
View File

@@ -97,7 +97,7 @@ typedef size_t uintptr_t;
#ifndef __attribute__ #ifndef __attribute__
/* This feature is available in gcc versions 2.5 and later. */ /* This feature is available in gcc versions 2.5 and later. */
# if (! defined __GNUC__ || __GNUC__ < 2 \ # if (! defined __GNUC__ || __GNUC__ < 2 \
|| (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
# define __attribute__(Spec) /* empty */ # define __attribute__(Spec) /* empty */
# endif # endif
#endif #endif

2
tests/actions.at
View File

@@ -345,7 +345,7 @@ thing:
; ;
%% %%
/* Alias to ARGV[1]. */ /* Alias to ARGV[1]. */
const char *source = 0; const char *source = YY_NULL;
static int static int
yylex (]AT_LEX_FORMALS[) yylex (]AT_LEX_FORMALS[)

45
tests/atlocal.in
View File

@@ -16,30 +16,47 @@
# You should have received a copy of the GNU General Public License # You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>. # along with this program. If not, see <http://www.gnu.org/licenses/>.
# We need a C compiler.
: ${CC='@CC@'}
# We want no optimization.
CFLAGS='@O0CFLAGS@ @WARN_CFLAGS_TEST@ @WERROR_CFLAGS@'
# Sometimes a test group needs to ignore gcc warnings, so it locally
# sets CFLAGS to this.
NO_WERROR_CFLAGS='@O0CFLAGS@ @WARN_CFLAGS_TEST@'
# We need `config.h'. # We need `config.h'.
CPPFLAGS="-I$abs_top_builddir/lib @CPPFLAGS@" CPPFLAGS="-I$abs_top_builddir/lib @CPPFLAGS@"
## ------------------- ##
## C/C++ Compilation. ##
## ------------------- ##
: ${CC='@CC@'}
: ${CXX='@CXX@'}
# Is the compiler GCC? # Is the compiler GCC?
GCC='@GCC@' GCC='@GCC@'
# The C++ compiler. # We want no optimization.
: ${CXX='@CXX@'} O0CFLAGS=`echo '@CFLAGS@' | sed 's/-O[0-9] *//'`
O0CXXFLAGS=`echo '@CXXFLAGS@' | sed 's/-O[0-9] *//'`
# Sometimes a test group needs to ignore gcc warnings, so it locally
# sets CFLAGS to this.
NO_WERROR_CFLAGS="$O0CFLAGS @WARN_CFLAGS@ @WARN_CFLAGS_TEST@"
NO_WERROR_CXXFLAGS="$O0CXXFLAGS @WARN_CXXFLAGS@ @WARN_CXXFLAGS_TEST@"
# But most of the time, we want -Werror.
CFLAGS="$NO_WERROR_CFLAGS @WERROR_CFLAGS@"
CXXFLAGS="$NO_WERROR_CXXFLAGS @WERROR_CXXFLAGS@"
# If 'exit 77'; skip all C++ tests; otherwise ':'. # If 'exit 77'; skip all C++ tests; otherwise ':'.
BISON_CXX_WORKS='@BISON_CXX_WORKS@' BISON_CXX_WORKS='@BISON_CXX_WORKS@'
# We want no optimization with C++, too. # Handle --compile-c-with-cxx here, once CXX and CXXFLAGS are known.
CXXFLAGS='@O0CXXFLAGS@ @WARN_CXXFLAGS_TEST@ @WERROR_CFLAGS@' if "$at_arg_compile_c_with_cxx"; then
CC=$CXX
O0CFLAGS=$O0CXXFLAGS
NO_WERROR_CFLAGS=$NO_WERROR_CXXFLAGS
CFLAGS=$CXXFLAGS
fi
## ------- ##
## Other. ##
## ------- ##
# Are special link options needed? # Are special link options needed?
LDFLAGS='@LDFLAGS@' LDFLAGS='@LDFLAGS@'

2
tests/calc.at
View File

@@ -241,7 +241,7 @@ int yylex (]AT_LEX_FORMALS[);
are stored in a union, from which objects with constructors are are stored in a union, from which objects with constructors are
excluded in C++). */ excluded in C++). */
%initial-action { %initial-action {
@$.initialize (0); @$.initialize ();
} }
])])])[ ])])])[

66
tests/java.at
View File

@@ -781,3 +781,69 @@ AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Position']], [1], [ignore])
AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Location']], [1], [ignore]) AT_CHECK([[$EGREP -v ' */?\*' YYParser.java | grep 'Location']], [1], [ignore])
AT_CLEANUP AT_CLEANUP
# ----------------------------------------------- #
# Java syntax error handling without error token. #
# ----------------------------------------------- #
AT_SETUP([Java syntax error handling without error token])
AT_DATA([[YYParser.y]], [[%language "Java"
%lex-param { String s }
%code imports {
import java.io.IOException;
}
%code lexer {
String Input;
int Position;
public YYLexer (String s)
{
Input = s;
Position = 0;
}
public void yyerror (String s)
{
System.err.println (s);
}
public Object getLVal ()
{
return null;
}
public int yylex () throws IOException
{
if (Position >= Input.length ())
return EOF;
else
return Input.charAt (Position++);
}
}
%code {
public static void main (String args []) throws IOException
{
YYParser p = new YYParser (args [0]);
p.parse ();
}
}
%%
input:
'a' 'a'
;
]])
AT_BISON_CHECK([[YYParser.y]])
AT_JAVA_COMPILE([[YYParser.java]])
AT_JAVA_PARSER_CHECK([[YYParser aa]], [[0]], [[]], [[]])
AT_JAVA_PARSER_CHECK([[YYParser ab]], [[0]], [[]], [[syntax error
]])
AT_JAVA_PARSER_CHECK([[YYParser ba]], [[0]], [[]], [[syntax error
]])
AT_CLEANUP

2
tests/regression.at
View File

@@ -760,7 +760,7 @@ static const yytype_uint8 yyrline[] =
static const char *const yytname[] = static const char *const yytname[] =
{ {
"$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"", "$end", "error", "$undefined", "\"if\"", "\"const\"", "\"then\"",
"\"else\"", "$accept", "statement", "struct_stat", "if", "else", 0 "\"else\"", "$accept", "statement", "struct_stat", "if", "else", YY_NULL
}; };
static const yytype_uint16 yytoknum[] = static const yytype_uint16 yytoknum[] =
{ {