From: Akim Demaille Date: Sun, 1 Apr 2012 10:56:55 +0000 (+0200) Subject: Merge remote-tracking branch 'origin/maint' X-Git-Tag: v2.7.90~468 X-Git-Url: https://git.saurik.com/bison.git/commitdiff_plain/3e75a2c92b12766add442d00a86d5ec1c67ce560 Merge remote-tracking branch 'origin/maint' * 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 --- 3e75a2c92b12766add442d00a86d5ec1c67ce560 diff --cc NEWS index 293e2dfd,f552c323..bb96c36e --- a/NEWS +++ b/NEWS @@@ -1,79 -1,24 +1,92 @@@ Bison News ---------- +* Changes in version ?.? (????-??-??): + +** Additional yylex/yyparse arguments + + The new directive %param declare additional argument to both yylex + and yyparse. The %lex-param, %parse-param, and %param directives + support one or more arguments. Instead of + + %lex-param {arg1_type *arg1} + %lex-param {arg2_type *arg2} + %parse-param {arg1_type *arg1} + %parse-param {arg2_type *arg2} + + one may now declare + + %param {arg1_type *arg1} {arg2_type *arg2} + +** Java skeleton improvements + + The constants for token names were moved to the Lexer interface. + Also, it is possible to add code to the parser's constructors using + "%code init" and "%define init_throws". + +** C++ skeleton improvements + + The C++ parser features a syntax_error exception, which can be + thrown from the scanner or from user rules to raise syntax errors. + This facilitates reporting errors caught in sub-functions (e.g., + rejecting too large integral literals from a conversion function + used by the scanner, or rejecting invalid combinations from a + factory invoked by the user actions). + +** Variable api.tokens.prefix + + The variable api.tokens.prefix changes the way tokens are identified in + the generated files. This is especially useful to avoid collisions + with identifiers in the target language. For instance + + %token FILE for ERROR + %define api.tokens.prefix "TOK_" + %% + start: FILE for ERROR; + + will generate the definition of the symbols TOK_FILE, TOK_for, and + TOK_ERROR in the generated sources. In particular, the scanner must + use these prefixed token names, although the grammar itself still + uses the short names (as in the sample rule given above). + +** Variable api.namespace + + The "namespace" variable is renamed "api.namespace". Backward + compatibility is ensured, but upgrading is recommended. + +** Variable parse.error + + The variable error controls the verbosity of error messages. The + use of the %error-verbose directive is deprecated in favor of + %define parse.error "verbose". + +** Semantic predicates + + The new, experimental, semantic-predicate feature allows actions of + the form %?{ BOOLEAN-EXPRESSION }, which cause syntax errors (as for + YYERROR) if the expression evaluates to 0, and are evaluated immediately + in GLR parsers, rather than being deferred. The result is that they + allow the programmer to prune possible parses based on the values of + runtime expressions. + * 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. diff --cc configure.ac index 622da5da,688e18ef..abe2a530 --- a/configure.ac +++ b/configure.ac @@@ -154,34 -157,24 +159,30 @@@ AC_CONFIG_FILES([etc/bench.pl], [chmod # Initialize the test suite. AC_CONFIG_TESTDIR(tests) -AC_CONFIG_FILES([tests/Makefile tests/atlocal]) +AC_CONFIG_FILES([tests/atlocal]) AC_CONFIG_FILES([tests/bison], [chmod +x tests/bison]) AC_CHECK_PROGS([VALGRIND], [valgrind]) - AC_PROG_CXX - BISON_TEST_FOR_WORKING_CXX_COMPILER AM_MISSING_PROG([AUTOM4TE], [autom4te]) # Needed by tests/atlocal.in. 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]) +gt_JAVACOMP([1.3], [1.4]) gt_JAVAEXEC +# We use gnulib, but from lib/local.mk instead of lib/Makefile.am. +# So prefix paths with lib/. See also etc/prefix-gnulib-mk. +gl_LIBOBJS=`echo "$gl_LIBOBJS" | sed -e 's, , lib/,g'` +# Listing the names of the variables to prefix is error-prone. +# Rather, adjust all the AC_SUBST variables whose name ends in '_H', +# and whose content ends in '.h'. +for ac_var in $ac_subst_vars +do + eval "ac_val=\$$ac_var" + case $ac_var=$ac_val in + (*_H=*.h) eval "$ac_var=lib/\$$ac_var";; + esac +done AC_CONFIG_FILES([Makefile - build-aux/Makefile - po/Makefile.in - data/Makefile - etc/Makefile - examples/Makefile - examples/calc++/Makefile - lib/Makefile src/Makefile - doc/Makefile - doc/yacc.1]) + po/Makefile.in + doc/yacc.1]) AC_OUTPUT diff --cc data/c.m4 index 41f56956,195c441d..14db807b --- a/data/c.m4 +++ b/data/c.m4 @@@ -175,23 -151,27 +176,37 @@@ m4_define([b4_table_value_equals] ## 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) +# ------------------------------------------------------------- +# Define "yy" which contents is CONTENT. +m4_define([b4_integral_parser_table_define], +[m4_ifvaln([$3], [b4_c_comment([$3], [ ])])dnl +static const b4_int_type_for([$2]) yy$1[[]] = +{ + $2 +};dnl +]) ## ------------------------- ## diff --cc data/glr.c index b9258688,d0b26926..37f40aee --- a/data/glr.c +++ b/data/glr.c @@@ -529,16 -596,15 +544,15 @@@ typedef enum { yyok, yyaccept, yyabort ]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[ -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ + do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ - yy_symbol_print (stderr, Type, \ - Value]b4_locations_if([, Location])[]b4_user_args[); \ + yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (YYID (0)) + YYFPRINTF (stderr, "\n"); \ + } \ + } while (YYID (0)) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ @@@ -844,15 -909,13 +858,13 @@@ yyfill (yyGLRStackItem *yyvsp, int *yyl * yyerr for YYERROR, yyabort for YYABORT. */ /*ARGSUSED*/ static YYRESULTTAG yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, - YYSTYPE* yyvalp, - YYLTYPE* YYOPTIONAL_LOC (yylocp), - yyGLRStack* yystackp - ]b4_user_formals[) - yyGLRStack* yystackp, - YYSTYPE* yyvalp]b4_locuser_formals[) ++ yyGLRStack* yystackp, ++ YYSTYPE* yyvalp]b4_locuser_formals[) { yybool yynormal __attribute__ ((__unused__)) = - (yystackp->yysplitPoint == NULL); + (yystackp->yysplitPoint == YY_NULL); int yylow; -]b4_parse_param_use[]dnl +]b4_parse_param_use([yyvalp], [yylocp])dnl [# undef yyerrok # define yyerrok (yystackp->yyerrState = 0) # undef YYACCEPT @@@ -926,20 -989,20 +938,20 @@@ yydestroyGLRState (char const *yymsg, y { if (yys->yyresolved) yydestruct (yymsg, yystos[yys->yylrState], - &yys->yysemantics.yysval]b4_locations_if([, &yys->yyloc])[]b4_user_args[); - &yys->yysemantics.yysval]b4_locuser_args([&yys->yyloc])[); ++ &yys->yysemantics.yysval]b4_locuser_args([&yys->yyloc])[); else { #if YYDEBUG if (yydebug) - { - if (yys->yysemantics.yyfirstVal) - YYFPRINTF (stderr, "%s unresolved ", yymsg); - else - YYFPRINTF (stderr, "%s incomplete ", yymsg); - yy_symbol_print (stderr, yystos[yys->yylrState], - YY_NULL]b4_locuser_args([&yys->yyloc])[); - YYFPRINTF (stderr, "\n"); - } + { + if (yys->yysemantics.yyfirstVal) + YYFPRINTF (stderr, "%s unresolved ", yymsg); + else + YYFPRINTF (stderr, "%s incomplete ", yymsg); + 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"); + } #endif if (yys->yysemantics.yyfirstVal) @@@ -1157,35 -1220,35 +1169,35 @@@ yyexpandGLRStack (yyGLRStack* yystackp { *yyp1 = *yyp0; if (*(yybool *) yyp0) - { - yyGLRState* yys0 = &yyp0->yystate; - yyGLRState* yys1 = &yyp1->yystate; - if (yys0->yypred != YY_NULL) - yys1->yypred = - YYRELOC (yyp0, yyp1, yys0->yypred, yystate); - if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != YY_NULL) - yys1->yysemantics.yyfirstVal = - YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); - } + { + yyGLRState* yys0 = &yyp0->yystate; + yyGLRState* yys1 = &yyp1->yystate; - if (yys0->yypred != NULL) ++ if (yys0->yypred != YY_NULL) + yys1->yypred = + YYRELOC (yyp0, yyp1, yys0->yypred, yystate); - if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL) ++ if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != YY_NULL) + yys1->yysemantics.yyfirstVal = + YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption); + } else - { - yySemanticOption* yyv0 = &yyp0->yyoption; - yySemanticOption* yyv1 = &yyp1->yyoption; - if (yyv0->yystate != YY_NULL) - yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate); - if (yyv0->yynext != YY_NULL) - yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption); - } + { + yySemanticOption* yyv0 = &yyp0->yyoption; + yySemanticOption* yyv1 = &yyp1->yyoption; - if (yyv0->yystate != NULL) ++ if (yyv0->yystate != YY_NULL) + 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); + } } - if (yystackp->yysplitPoint != NULL) + if (yystackp->yysplitPoint != YY_NULL) yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems, - yystackp->yysplitPoint, yystate); + yystackp->yysplitPoint, yystate); 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] = - YYRELOC (yystackp->yyitems, yynewItems, - yystackp->yytops.yystates[yyn], yystate); + YYRELOC (yystackp->yyitems, yynewItems, + yystackp->yytops.yystates[yyn], yystate); YYFREE (yystackp->yyitems); yystackp->yyitems = yynewItems; yystackp->yynextFree = yynewItems + yysize; @@@ -1214,13 -1277,13 +1226,13 @@@ yyupdateSplit (yyGLRStack* yystackp, yy static inline void 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->yytops.yystates[yyk] = NULL; + yystackp->yytops.yystates[yyk] = YY_NULL; } -/** Undelete the last stack that was marked as deleted. Can only be - done once after a deletion, and only when all other stacks have +/** Undelete the last stack in *YYSTACKP that was marked as deleted. Can + only be done once after a deletion, and only when all other stacks have been deleted. */ static void yyundeleteLastStack (yyGLRStack* yystackp) @@@ -1240,42 -1303,41 +1252,42 @@@ yyremoveDeletes (yyGLRStack* yystackp yyi = yyj = 0; while (yyj < yystackp->yytops.yysize) { - if (yystackp->yytops.yystates[yyi] == NULL) + if (yystackp->yytops.yystates[yyi] == YY_NULL) - { - if (yyi == yyj) - { - YYDPRINTF ((stderr, "Removing dead stacks.\n")); - } - yystackp->yytops.yysize -= 1; - } + { + if (yyi == yyj) + { + YYDPRINTF ((stderr, "Removing dead stacks.\n")); + } + yystackp->yytops.yysize -= 1; + } else - { - yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi]; - /* In the current implementation, it's unnecessary to copy - yystackp->yytops.yylookaheadNeeds[yyi] since, after - yyremoveDeletes returns, the parser immediately either enters - deterministic operation or shifts a token. However, it doesn't - hurt, and the code might evolve to need it. */ - yystackp->yytops.yylookaheadNeeds[yyj] = - yystackp->yytops.yylookaheadNeeds[yyi]; - if (yyj != yyi) - { - YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n", - (unsigned long int) yyi, (unsigned long int) yyj)); - } - yyj += 1; - } + { + yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi]; + /* In the current implementation, it's unnecessary to copy + yystackp->yytops.yylookaheadNeeds[yyi] since, after + yyremoveDeletes returns, the parser immediately either enters + deterministic operation or shifts a token. However, it doesn't + hurt, and the code might evolve to need it. */ + yystackp->yytops.yylookaheadNeeds[yyj] = + yystackp->yytops.yylookaheadNeeds[yyi]; + if (yyj != yyi) + { + YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n", + (unsigned long int) yyi, (unsigned long int) yyj)); + } + yyj += 1; + } yyi += 1; } } -/** Shift to a new state on stack #K of STACK, corresponding to LR state - * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */ +/** Shift to a new state on stack #YYK of *YYSTACKP, corresponding to LR + * state YYLRSTATE, at input position YYPOSN, with (resolved) semantic + * value *YYVALP and source location *YYLOCP. */ static inline void yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState, - size_t yyposn, - YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[) + size_t yyposn, - YYSTYPE* yyvalp, YYLTYPE* yylocp) ++ YYSTYPE* yyvalp]b4_locations_if([, YYLTYPE* yylocp])[) { yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate; @@@ -1359,21 -1380,20 +1371,21 @@@ yy_reduce_print (int yynormal, yyGLRSta * for userAction. */ static inline YYRESULTTAG yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, - YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) - YYSTYPE* yyvalp]b4_locuser_formals[) ++ YYSTYPE* yyvalp]b4_locuser_formals[) { int yynrhs = yyrhsLength (yyrule); - if (yystackp->yysplitPoint == NULL) + if (yystackp->yysplitPoint == YY_NULL) { /* Standard special case: single stack. */ - yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; + yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; YYASSERT (yyk == 0); yystackp->yynextFree -= yynrhs; yystackp->yyspaceLeft += yynrhs; yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate; - return yyuserAction (yyrule, yynrhs, rhs, yystackp, - yyvalp]b4_locuser_args[); + YY_REDUCE_PRINT ((1, yyrhs, yyk, yyrule]b4_user_args[)); - return yyuserAction (yyrule, yynrhs, yyrhs, - yyvalp, yylocp, yystackp]b4_user_args[); ++ return yyuserAction (yyrule, yynrhs, yyrhs, yystackp, ++ yyvalp]b4_locuser_args[); } else { @@@ -1381,27 -1405,68 +1393,27 @@@ yyGLRState* yys; yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred - = yystackp->yytops.yystates[yyk];]b4_locations_if([[ + = yystackp->yytops.yystates[yyk];]b4_locations_if([[ if (yynrhs == 0) - /* Set default location. */ - yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[ + /* Set default location. */ + yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[ for (yyi = 0; yyi < yynrhs; yyi += 1) - { - yys = yys->yypred; - YYASSERT (yys); - } + { + yys = yys->yypred; + YYASSERT (yys); + } yyupdateSplit (yystackp, yys); yystackp->yytops.yystates[yyk] = yys; + YY_REDUCE_PRINT ((0, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, yyk, yyrule]b4_user_args[)); return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, - yyvalp, yylocp, yystackp]b4_user_args[); - yystackp, yyvalp]b4_locuser_args[); - } -} - -#if !YYDEBUG -# define YY_REDUCE_PRINT(Args) -#else -# define YY_REDUCE_PRINT(Args) \ -do { \ - if (yydebug) \ - yy_reduce_print Args; \ -} while (YYID (0)) - -/*----------------------------------------------------------. -| Report that the RULE is going to be reduced on stack #K. | -`----------------------------------------------------------*/ - -/*ARGSUSED*/ static inline void -yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule, - YYSTYPE* yyvalp]b4_locuser_formals[) -{ - int yynrhs = yyrhsLength (yyrule); - yybool yynormal __attribute__ ((__unused__)) = - (yystackp->yysplitPoint == YY_NULL); - yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; - int yylow = 1; - int yyi; - YYUSE (yyvalp);]b4_locations_if([ - YYUSE (yylocp);])[ -]b4_parse_param_use[]dnl -[ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n", - (unsigned long int) yyk, yyrule - 1, - (unsigned long int) yyrline[yyrule]); - /* The symbols being reduced. */ - for (yyi = 0; yyi < yynrhs; yyi++) - { - YYFPRINTF (stderr, " $%d = ", yyi + 1); - yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], - &]b4_rhs_value(yynrhs, yyi + 1)[ - ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl - b4_user_args[); - YYFPRINTF (stderr, "\n"); ++ yystackp, yyvalp]b4_locuser_args[); } } -#endif -/** Pop items off stack #K of STACK according to grammar rule RULE, +/** Pop items off stack #YYK of *YYSTACKP according to grammar rule YYRULE, * and push back on the resulting nonterminal symbol. Perform the - * semantic action associated with RULE and store its value with the - * newly pushed state, if FORCEEVAL or if STACK is currently + * semantic action associated with YYRULE and store its value with the + * newly pushed state, if YYFORCEEVAL or if *YYSTACKP is currently * unambiguous. Otherwise, store the deferred semantic action with * the new state. If the new state would have an identical input * position, LR state, and predecessor to an existing state on the stack, @@@ -1415,26 -1480,18 +1427,25 @@@ yyglrReduce (yyGLRStack* yystackp, size { size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn; - if (yyforceEval || yystackp->yysplitPoint == NULL) + if (yyforceEval || yystackp->yysplitPoint == YY_NULL) { + YYRESULTTAG yyflag; - YYSTYPE yysval; - YYLTYPE yyloc; + YYSTYPE yysval;]b4_locations_if([ + YYLTYPE yyloc;])[ - yyflag = yydoAction (yystackp, yyk, yyrule, &yysval, - &yyloc]b4_user_args[); - YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[)); - YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[)); ++ yyflag = yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[); + if (yyflag == yyerr && yystackp->yysplitPoint != NULL) + { + YYDPRINTF ((stderr, "Parse on stack %lu rejected by rule #%d.\n", + (unsigned long int) yyk, yyrule - 1)); + } + if (yyflag != yyok) + return yyflag; YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc); yyglrShift (yystackp, yyk, - yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, - yylhsNonterm (yyrule)), - yyposn, &yysval]b4_locations_if([, &yyloc])[); + yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, + yylhsNonterm (yyrule)), - yyposn, &yysval, &yyloc); ++ yyposn, &yysval]b4_locations_if([, &yyloc])[); } else { @@@ -1452,28 -1509,27 +1463,28 @@@ yyupdateSplit (yystackp, yys); yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); YYDPRINTF ((stderr, - "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n", - (unsigned long int) yyk, yyrule - 1, yynewLRState)); + "Reduced stack %lu by rule #%d; action deferred. " + "Now in state %d.\n", + (unsigned long int) yyk, yyrule - 1, yynewLRState)); 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; - yyp = yystackp->yytops.yystates[yyi]; - while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) - { - if (yyp->yylrState == yynewLRState && yyp->yypred == yys) - { - yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); - yymarkStackDeleted (yystackp, yyk); - YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n", - (unsigned long int) yyk, - (unsigned long int) yyi)); - return yyok; - } - yyp = yyp->yypred; - } - } ++ if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULL) + { + yyGLRState* yyp, *yysplit = yystackp->yysplitPoint; + yyp = yystackp->yytops.yystates[yyi]; + while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn) + { + if (yyp->yylrState == yynewLRState && yyp->yypred == yys) + { + yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); + yymarkStackDeleted (yystackp, yyk); + YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n", + (unsigned long int) yyk, + (unsigned long int) yyi)); + return yyok; + } + yyp = yyp->yypred; + } + } yystackp->yytops.yystates[yyk] = yys; yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule); } @@@ -1493,27 -1549,27 +1504,27 @@@ yysplitStack (yyGLRStack* yystackp, siz yyGLRState** yynewStates; yybool* yynewLookaheadNeeds; - yynewStates = NULL; + yynewStates = YY_NULL; if (yystackp->yytops.yycapacity - > (YYSIZEMAX / (2 * sizeof yynewStates[0]))) - yyMemoryExhausted (yystackp); + > (YYSIZEMAX / (2 * sizeof yynewStates[0]))) + yyMemoryExhausted (yystackp); yystackp->yytops.yycapacity *= 2; yynewStates = - (yyGLRState**) YYREALLOC (yystackp->yytops.yystates, - (yystackp->yytops.yycapacity - * sizeof yynewStates[0])); + (yyGLRState**) YYREALLOC (yystackp->yytops.yystates, + (yystackp->yytops.yycapacity + * sizeof yynewStates[0])); - if (yynewStates == NULL) + if (yynewStates == YY_NULL) - yyMemoryExhausted (yystackp); + yyMemoryExhausted (yystackp); yystackp->yytops.yystates = yynewStates; yynewLookaheadNeeds = - (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, - (yystackp->yytops.yycapacity - * sizeof yynewLookaheadNeeds[0])); + (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, + (yystackp->yytops.yycapacity + * sizeof yynewLookaheadNeeds[0])); - if (yynewLookaheadNeeds == NULL) + if (yynewLookaheadNeeds == YY_NULL) - yyMemoryExhausted (yystackp); + yyMemoryExhausted (yystackp); yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; } yystackp->yytops.yystates[yystackp->yytops.yysize] @@@ -1559,43 -1615,43 +1570,43 @@@ yymergeOptionSets (yySemanticOption* yy yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1) { if (yys0 == yys1) - break; + break; else if (yys0->yyresolved) - { - yys1->yyresolved = yytrue; - yys1->yysemantics.yysval = yys0->yysemantics.yysval; - } + { + yys1->yyresolved = yytrue; + yys1->yysemantics.yysval = yys0->yysemantics.yysval; + } else if (yys1->yyresolved) - { - yys0->yyresolved = yytrue; - yys0->yysemantics.yysval = yys1->yysemantics.yysval; - } + { + yys0->yyresolved = yytrue; + yys0->yysemantics.yysval = yys1->yysemantics.yysval; + } else - { - yySemanticOption** yyz0p; - yySemanticOption* yyz1; - yyz0p = &yys0->yysemantics.yyfirstVal; - yyz1 = yys1->yysemantics.yyfirstVal; - while (YYID (yytrue)) - { - if (yyz1 == *yyz0p || yyz1 == YY_NULL) - break; - else if (*yyz0p == YY_NULL) - { - *yyz0p = yyz1; - break; - } - else if (*yyz0p < yyz1) - { - yySemanticOption* yyz = *yyz0p; - *yyz0p = yyz1; - yyz1 = yyz1->yynext; - (*yyz0p)->yynext = yyz; - } - yyz0p = &(*yyz0p)->yynext; - } - yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal; - } + { + yySemanticOption** yyz0p; + yySemanticOption* yyz1; + yyz0p = &yys0->yysemantics.yyfirstVal; + yyz1 = yys1->yysemantics.yyfirstVal; + while (YYID (yytrue)) + { - if (yyz1 == *yyz0p || yyz1 == NULL) ++ if (yyz1 == *yyz0p || yyz1 == YY_NULL) + break; - else if (*yyz0p == NULL) ++ else if (*yyz0p == YY_NULL) + { + *yyz0p = yyz1; + break; + } + else if (*yyz0p < yyz1) + { + yySemanticOption* yyz = *yyz0p; + *yyz0p = yyz1; + yyz1 = yyz1->yynext; + (*yyz0p)->yynext = yyz; + } + yyz0p = &(*yyz0p)->yynext; + } + yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal; + } } } @@@ -1654,7 -1709,7 +1665,7 @@@ yyresolveStates (yyGLRState* yys, int y * semantic values if invoked). */ static YYRESULTTAG yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp, - YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[) - YYSTYPE* yyvalp]b4_locuser_formals[) ++ YYSTYPE* yyvalp]b4_locuser_formals[) { yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1]; int yynrhs; @@@ -1678,17 -1733,17 +1689,17 @@@ /* Set default location. */ yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[ yychar_current = yychar; - yylval_current = yylval; - yylloc_current = yylloc; + yylval_current = yylval;]b4_locations_if([ + yylloc_current = yylloc;])[ yychar = yyopt->yyrawchar; - yylval = yyopt->yyval; - yylloc = yyopt->yyloc; + yylval = yyopt->yyval;]b4_locations_if([ + yylloc = yyopt->yyloc;])[ yyflag = yyuserAction (yyopt->yyrule, yynrhs, - yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, - yystackp, yyvalp]b4_locuser_args[); + yyrhsVals + YYMAXRHS + YYMAXLEFT - 1, - yyvalp, yylocp, yystackp]b4_user_args[); ++ yystackp, yyvalp]b4_locuser_args[); yychar = yychar_current; - yylval = yylval_current; - yylloc = yylloc_current; + yylval = yylval_current;]b4_locations_if([ + yylloc = yylloc_current;])[ return yyflag; } @@@ -1771,50 -1826,50 +1782,50 @@@ yyresolveLocations (yyGLRState* yys1, i { yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[); if (!yys1->yyresolved) - { - yySemanticOption *yyoption; - yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; - int yynrhs; - int yychar_current; - YYSTYPE yylval_current; - YYLTYPE yylloc_current; - yyoption = yys1->yysemantics.yyfirstVal; - YYASSERT (yyoption != YY_NULL); - yynrhs = yyrhsLength (yyoption->yyrule); - if (yynrhs > 0) - { - yyGLRState *yys; - int yyn; - yyresolveLocations (yyoption->yystate, yynrhs, - yystackp]b4_user_args[); - for (yys = yyoption->yystate, yyn = yynrhs; - yyn > 0; - yys = yys->yypred, yyn -= 1) - yyrhsloc[yyn].yystate.yyloc = yys->yyloc; - } - else - { - /* Both yyresolveAction and yyresolveLocations traverse the GSS - in reverse rightmost order. It is only necessary to invoke - yyresolveLocations on a subforest for which yyresolveAction - would have been invoked next had an ambiguity not been - detected. Thus the location of the previous state (but not - necessarily the previous state itself) is guaranteed to be - resolved already. */ - yyGLRState *yyprevious = yyoption->yystate; - yyrhsloc[0].yystate.yyloc = yyprevious->yyloc; - } - yychar_current = yychar; - yylval_current = yylval; - yylloc_current = yylloc; - yychar = yyoption->yyrawchar; - yylval = yyoption->yyval; - yylloc = yyoption->yyloc; - YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); - yychar = yychar_current; - yylval = yylval_current; - yylloc = yylloc_current; - } + { + yySemanticOption *yyoption; + yyGLRStackItem yyrhsloc[1 + YYMAXRHS]; + int yynrhs; + int yychar_current; + YYSTYPE yylval_current; + YYLTYPE yylloc_current; + yyoption = yys1->yysemantics.yyfirstVal; - YYASSERT (yyoption != NULL); ++ YYASSERT (yyoption != YY_NULL); + yynrhs = yyrhsLength (yyoption->yyrule); + if (yynrhs > 0) + { + yyGLRState *yys; + int yyn; + yyresolveLocations (yyoption->yystate, yynrhs, + yystackp]b4_user_args[); + for (yys = yyoption->yystate, yyn = yynrhs; + yyn > 0; + yys = yys->yypred, yyn -= 1) + yyrhsloc[yyn].yystate.yyloc = yys->yyloc; + } + else + { + /* Both yyresolveAction and yyresolveLocations traverse the GSS + in reverse rightmost order. It is only necessary to invoke + yyresolveLocations on a subforest for which yyresolveAction + would have been invoked next had an ambiguity not been + detected. Thus the location of the previous state (but not + necessarily the previous state itself) is guaranteed to be + resolved already. */ + yyGLRState *yyprevious = yyoption->yystate; + yyrhsloc[0].yystate.yyloc = yyprevious->yyloc; + } + yychar_current = yychar; + yylval_current = yylval; + yylloc_current = yylloc; + yychar = yyoption->yyrawchar; + yylval = yyoption->yyval; + yylloc = yyoption->yyloc; + YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs); + yychar = yychar_current; + yylval = yylval_current; + yylloc = yylloc_current; + } } }]])[ @@@ -1878,30 -1930,28 +1887,28 @@@ yyresolveValue (yyGLRState* yys, yyGLRS { yySemanticOption* yyp; int yyprec = yydprec[yybest->yyrule]; - yyflag = yyresolveAction (yybest, yystackp, &yysval, - yylocp]b4_user_args[); + yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args[); 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]) - { - YYSTYPE yysval_other;]b4_locations_if([ ++ for (yyp = yybest->yynext; yyp != YY_NULL; yyp = yyp->yynext) + { + if (yyprec == yydprec[yyp->yyrule]) + { - YYSTYPE yysval_other; - YYLTYPE yydummy; - yyflag = yyresolveAction (yyp, yystackp, &yysval_other, - &yydummy]b4_user_args[); ++ YYSTYPE yysval_other;]b4_locations_if([ + YYLTYPE yydummy;])[ + yyflag = yyresolveAction (yyp, yystackp, &yysval_other]b4_locuser_args([&yydummy])[); - if (yyflag != yyok) - { - yydestruct ("Cleanup: discarding incompletely merged value for", - yystos[yys->yylrState], - &yysval]b4_locuser_args[); - break; - } - yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); - } - } + if (yyflag != yyok) + { + yydestruct ("Cleanup: discarding incompletely merged value for", + yystos[yys->yylrState], - &yysval]b4_locations_if([, yylocp])[]b4_user_args[); ++ &yysval]b4_locuser_args[); + break; + } + yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); + } + } } else - yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[); + yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args([yylocp])[); if (yyflag == yyok) { @@@ -1963,9 -2013,13 +1970,9 @@@ yycompressStack (yyGLRStack* yystackp static YYRESULTTAG yyprocessOneStack (yyGLRStack* yystackp, size_t yyk, - size_t yyposn]b4_pure_formals[) + size_t yyposn]b4_pure_formals[) { - while (yystackp->yytops.yystates[yyk] != NULL) - int yyaction; - const short int* yyconflicts; - yyRuleNum yyrule; - + while (yystackp->yytops.yystates[yyk] != YY_NULL) { yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState; YYDPRINTF ((stderr, "Stack %lu Entering state %d\n", @@@ -2220,45 -2235,45 +2227,45 @@@ yyrecoverSyntaxError (yyGLRStack* yysta reductions. Skip tokens until we can proceed. */ while (YYID (yytrue)) { - yySymbol yytoken; - if (yychar == YYEOF) - yyFail (yystackp][]b4_lpure_args[, YY_NULL); - if (yychar != YYEMPTY) - {]b4_locations_if([[ - /* We throw away the lookahead, but the error range - of the shifted error token must take it into account. */ - yyGLRState *yys = yystackp->yytops.yystates[0]; - yyGLRStackItem yyerror_range[3]; - yyerror_range[1].yystate.yyloc = yys->yyloc; - yyerror_range[2].yystate.yyloc = yylloc; - YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ - yytoken = YYTRANSLATE (yychar); - yydestruct ("Error: discarding", - yytoken, &yylval]b4_locuser_args([&yylloc])[); - } - YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; - if (yychar <= YYEOF) - { - yychar = yytoken = YYEOF; - YYDPRINTF ((stderr, "Now at end of input.\n")); - } - else - { - yytoken = YYTRANSLATE (yychar); - YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); - } - yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; - if (yypact_value_is_default (yyj)) - return; - yyj += yytoken; - if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) - { - if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) - return; - } - else if (! yytable_value_is_error (yytable[yyj])) - return; + yySymbol yytoken; + if (yychar == YYEOF) - yyFail (yystackp][]b4_lpure_args[, NULL); ++ yyFail (yystackp][]b4_lpure_args[, YY_NULL); + if (yychar != YYEMPTY) + {]b4_locations_if([[ + /* We throw away the lookahead, but the error range + of the shifted error token must take it into account. */ + yyGLRState *yys = yystackp->yytops.yystates[0]; + yyGLRStackItem yyerror_range[3]; + yyerror_range[1].yystate.yyloc = yys->yyloc; + yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Error: discarding", - yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); ++ yytoken, &yylval]b4_locuser_args([&yylloc])[); + } + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + yyj = yypact[yystackp->yytops.yystates[0]->yylrState]; + if (yypact_value_is_default (yyj)) + return; + yyj += yytoken; + if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken) + { + if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0) + return; + } + else if (! yytable_value_is_error (yytable[yyj])) + return; } /* Reduce to one stack. */ @@@ -2279,50 -2294,52 +2286,51 @@@ yyGLRState *yys = yystackp->yytops.yystates[0]; yyj = yypact[yys->yylrState]; if (! yypact_value_is_default (yyj)) - { - yyj += YYTERROR; - if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR - && yyisShiftAction (yytable[yyj])) - { - /* Shift the error token. */]b4_locations_if([[ - /* First adjust its location.*/ + { + yyj += YYTERROR; + if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR + && yyisShiftAction (yytable[yyj])) + { - /* Shift the error token having adjusted its location. */ - YYLTYPE yyerrloc;]b4_locations_if([[ ++ /* Shift the error token. */]b4_locations_if([[ ++ /* First adjust its location.*/ + YYLTYPE yyerrloc; - yystackp->yyerror_range[2].yystate.yyloc = yylloc; - YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ - YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], - &yylval, &yyerrloc); - yyglrShift (yystackp, 0, yytable[yyj], - yys->yyposn, &yylval]b4_locations_if([, &yyerrloc])[); - yys = yystackp->yytops.yystates[0]; - break; - } - }]b4_locations_if([[ + yystackp->yyerror_range[2].yystate.yyloc = yylloc; + YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[ + YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]], + &yylval, &yyerrloc); + yyglrShift (yystackp, 0, yytable[yyj], - yys->yyposn, &yylval, &yyerrloc); ++ yys->yyposn, &yylval]b4_locations_if([, &yyerrloc])[); + yys = yystackp->yytops.yystates[0]; + break; + } - } - ]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ - if (yys->yypred != NULL) ++ }]b4_locations_if([[ + yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[ + 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->yynextFree -= 1; yystackp->yyspaceLeft += 1; } - if (yystackp->yytops.yystates[0] == NULL) - yyFail (yystackp][]b4_lpure_args[, NULL); + if (yystackp->yytops.yystates[0] == YY_NULL) + yyFail (yystackp][]b4_lpure_args[, YY_NULL); } -#define YYCHK1(YYE) \ - do { \ - switch (YYE) { \ - case yyok: \ - break; \ - case yyabort: \ - goto yyabortlab; \ - case yyaccept: \ - goto yyacceptlab; \ - case yyerr: \ - goto yyuser_error; \ - default: \ - goto yybuglab; \ - } \ +#define YYCHK1(YYE) \ + do { \ + switch (YYE) { \ + case yyok: \ + break; \ + case yyabort: \ + goto yyabortlab; \ + case yyaccept: \ + goto yyacceptlab; \ + case yyerr: \ + goto yyuser_error; \ + default: \ + goto yybuglab; \ + } \ } while (YYID (0)) - /*----------. | yyparse. | `----------*/ @@@ -2367,148 -2384,148 +2375,148 @@@ m4_popdef([b4_at_dollar])])dn while (YYID (yytrue)) { /* For efficiency, we have two loops, the first of which is - specialized to deterministic operation (single stack, no - potential ambiguity). */ + specialized to deterministic operation (single stack, no + potential ambiguity). */ /* Standard mode */ while (YYID (yytrue)) - { - yyRuleNum yyrule; - int yyaction; - const short int* yyconflicts; - - yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); - if (yystate == YYFINAL) - goto yyacceptlab; - if (yyisDefaultedState (yystate)) - { - yyrule = yydefaultAction (yystate); - if (yyrule == 0) - { -]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ - yyreportSyntaxError (&yystack]b4_user_args[); - goto yyuser_error; - } - YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[)); - } - else - { - yySymbol yytoken; - if (yychar == YYEMPTY) - { - YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; - } - - if (yychar <= YYEOF) - { - yychar = yytoken = YYEOF; - YYDPRINTF ((stderr, "Now at end of input.\n")); - } - else - { - yytoken = YYTRANSLATE (yychar); - YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); - } - - yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); - if (*yyconflicts != 0) - break; - if (yyisShiftAction (yyaction)) - { - YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - yychar = YYEMPTY; - yyposn += 1; - yyglrShift (&yystack, 0, yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[); - if (0 < yystack.yyerrState) - yystack.yyerrState -= 1; - } - else if (yyisErrorAction (yyaction)) - { -]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ - yyreportSyntaxError (&yystack]b4_user_args[); - goto yyuser_error; - } - else - YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); - } - } + { + yyRuleNum yyrule; + int yyaction; + const short int* yyconflicts; + + yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + if (yystate == YYFINAL) + goto yyacceptlab; + if (yyisDefaultedState (yystate)) + { + yyrule = yydefaultAction (yystate); + if (yyrule == 0) + { +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[)); + } + else + { + yySymbol yytoken; + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts); + if (*yyconflicts != 0) + break; + if (yyisShiftAction (yyaction)) + { + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yychar = YYEMPTY; + yyposn += 1; - yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc); ++ yyglrShift (&yystack, 0, yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[); + if (0 < yystack.yyerrState) + yystack.yyerrState -= 1; + } + else if (yyisErrorAction (yyaction)) + { +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + else + YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[)); + } + } while (YYID (yytrue)) - { - yySymbol yytoken_to_shift; - size_t yys; - - for (yys = 0; yys < yystack.yytops.yysize; yys += 1) - yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY; - - /* yyprocessOneStack returns one of three things: - - - An error flag. If the caller is yyprocessOneStack, it - immediately returns as well. When the caller is finally - yyparse, it jumps to an error label via YYCHK1. - - - yyok, but yyprocessOneStack has invoked yymarkStackDeleted - (&yystack, yys), which sets the top state of yys to NULL. Thus, - yyparse's following invocation of yyremoveDeletes will remove - the stack. - - - yyok, when ready to shift a token. - - Except in the first case, yyparse will invoke yyremoveDeletes and - then shift the next token onto all remaining stacks. This - synchronization of the shift (that is, after all preceding - reductions on all stacks) helps prevent double destructor calls - on yylval in the event of memory exhaustion. */ - - for (yys = 0; yys < yystack.yytops.yysize; yys += 1) - YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[)); - yyremoveDeletes (&yystack); - if (yystack.yytops.yysize == 0) - { - yyundeleteLastStack (&yystack); - if (yystack.yytops.yysize == 0) - yyFail (&yystack][]b4_lpure_args[, YY_("syntax error")); - YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); - YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); -]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ - yyreportSyntaxError (&yystack]b4_user_args[); - goto yyuser_error; - } - - /* If any yyglrShift call fails, it will fail after shifting. Thus, - a copy of yylval will already be on stack 0 in the event of a - failure in the following loop. Thus, yychar is set to YYEMPTY - before the loop to make sure the user destructor for yylval isn't - called twice. */ - yytoken_to_shift = YYTRANSLATE (yychar); - yychar = YYEMPTY; - yyposn += 1; - for (yys = 0; yys < yystack.yytops.yysize; yys += 1) - { - int yyaction; - const short int* yyconflicts; - yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState; - yygetLRActions (yystate, yytoken_to_shift, &yyaction, - &yyconflicts); - /* Note that yyconflicts were handled by yyprocessOneStack. */ - YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys)); - YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); - yyglrShift (&yystack, yys, yyaction, yyposn, - &yylval]b4_locations_if([, &yylloc])[); - YYDPRINTF ((stderr, "Stack %lu now in state #%d\n", - (unsigned long int) yys, - yystack.yytops.yystates[yys]->yylrState)); - } - - if (yystack.yytops.yysize == 1) - { - YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); - YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); - yycompressStack (&yystack); - break; - } - } + { + yySymbol yytoken_to_shift; + size_t yys; + + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY; + + /* yyprocessOneStack returns one of three things: + + - An error flag. If the caller is yyprocessOneStack, it + immediately returns as well. When the caller is finally + yyparse, it jumps to an error label via YYCHK1. + + - yyok, but yyprocessOneStack has invoked yymarkStackDeleted + (&yystack, yys), which sets the top state of yys to NULL. Thus, + yyparse's following invocation of yyremoveDeletes will remove + the stack. + + - yyok, when ready to shift a token. + + Except in the first case, yyparse will invoke yyremoveDeletes and + then shift the next token onto all remaining stacks. This + synchronization of the shift (that is, after all preceding + reductions on all stacks) helps prevent double destructor calls + on yylval in the event of memory exhaustion. */ + + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[)); + yyremoveDeletes (&yystack); + if (yystack.yytops.yysize == 0) + { + yyundeleteLastStack (&yystack); + if (yystack.yytops.yysize == 0) + yyFail (&yystack][]b4_lpure_args[, YY_("syntax error")); + YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); + YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); +]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ + yyreportSyntaxError (&yystack]b4_user_args[); + goto yyuser_error; + } + + /* If any yyglrShift call fails, it will fail after shifting. Thus, + a copy of yylval will already be on stack 0 in the event of a + failure in the following loop. Thus, yychar is set to YYEMPTY + before the loop to make sure the user destructor for yylval isn't + called twice. */ + yytoken_to_shift = YYTRANSLATE (yychar); + yychar = YYEMPTY; + yyposn += 1; + for (yys = 0; yys < yystack.yytops.yysize; yys += 1) + { + int yyaction; + const short int* yyconflicts; + yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState; + yygetLRActions (yystate, yytoken_to_shift, &yyaction, + &yyconflicts); + /* Note that yyconflicts were handled by yyprocessOneStack. */ + YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys)); + YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); + yyglrShift (&yystack, yys, yyaction, yyposn, - &yylval, &yylloc); ++ &yylval]b4_locations_if([, &yylloc])[); + YYDPRINTF ((stderr, "Stack %lu now in state #%d\n", + (unsigned long int) yys, + yystack.yytops.yystates[yys]->yylrState)); + } + + if (yystack.yytops.yysize == 1) + { + YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); + YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); + yycompressStack (&yystack); + break; + } + } continue; yyuser_error: yyrecoverSyntaxError (&yystack]b4_user_args[); @@@ -2535,8 -2552,7 +2543,7 @@@ yyreturn: if (yychar != YYEMPTY) yydestruct ("Cleanup: discarding lookahead", - YYTRANSLATE (yychar), - &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); - YYTRANSLATE (yychar), &yylval]b4_locuser_args([&yylloc])[); ++ YYTRANSLATE (yychar), &yylval]b4_locuser_args([&yylloc])[); /* If the stack is well-formed, pop the stack until it is empty, destroying its entries as we go. But free the stack regardless @@@ -2545,25 -2561,25 +2552,25 @@@ { yyGLRState** yystates = yystack.yytops.yystates; if (yystates) - { - size_t yysize = yystack.yytops.yysize; - size_t yyk; - for (yyk = 0; yyk < yysize; yyk += 1) - if (yystates[yyk]) - { - while (yystates[yyk]) - { - yyGLRState *yys = yystates[yyk]; -]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]] -)[ if (yys->yypred != YY_NULL) - yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[); - yystates[yyk] = yys->yypred; - yystack.yynextFree -= 1; - yystack.yyspaceLeft += 1; - } - break; - } - } + { + size_t yysize = yystack.yytops.yysize; + size_t yyk; + for (yyk = 0; yyk < yysize; yyk += 1) + if (yystates[yyk]) + { + while (yystates[yyk]) + { + yyGLRState *yys = yystates[yyk]; +]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[); + yystates[yyk] = yys->yypred; + yystack.yynextFree -= 1; + yystack.yyspaceLeft += 1; + } + break; + } + } yyfreeGLRStack (&yystack); } @@@ -2605,8 -2621,8 +2612,8 @@@ yypstack (yyGLRStack* yystackp, size_t yypstates (yystackp->yytops.yystates[yyk]); } -#define YYINDEX(YYX) \ +#define YYINDEX(YYX) \ - ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems) + ((YYX) == YY_NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems) static void diff --cc data/lalr1.cc index 4179deaf,d7201dd4..d67c9548 --- a/data/lalr1.cc +++ b/data/lalr1.cc @@@ -150,16 -48,14 +150,18 @@@ dnl FIXME: This is wrong, we want compu #include #include #include "stack.hh" -]b4_percent_define_ifdef([[location_type]], [], - [[#include "location.hh"]])[ +]b4_locations_if([b4_percent_define_ifdef([[location_type]], [], + [[#include "location.hh"]])])[ + +]b4_variant_if([b4_namespace_open +b4_variant_define +b4_namespace_close])[ + ]b4_null_define[ + /* Enabling traces. */ #ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ +# define YYDEBUG ]b4_parse_trace_if([1], [0])[ #endif /* Enabling verbose error messages. */ diff --cc data/lalr1.java index 57ff9932,103c03dd..a40d6c27 --- a/data/lalr1.java +++ b/data/lalr1.java @@@ -673,35 -629,35 +673,35 @@@ m4_popdef([b4_at_dollar])])dn for (;;) { - yyn = yypact_[yystate]; - if (!yy_pact_value_is_default_ (yyn)) - { - yyn += yyterror_; - if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) - { - yyn = yytable_[yyn]; - if (0 < yyn) - break; - } - } - - /* Pop the current state because it cannot handle the error token. */ - if (yystack.height == 0) - return false; - - ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[ - yystack.pop (); - yystate = yystack.stateAt (0); - if (yydebug > 0) - yystack.print (yyDebugStream); + yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += yyterror_; + if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ - if (yystack.height == 1) ++ if (yystack.height == 0) + return false; + + ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[ + yystack.pop (); + yystate = yystack.stateAt (0); + if (yydebug > 0) + yystack.print (yyDebugStream); } - ]b4_locations_if([ - /* Muck with the stack to setup for yylloc. */ - yystack.push (0, null, yylloc); - yystack.push (0, null, yyerrloc); + ]b4_locations_if([ + /* Muck with the stack to setup for yylloc. */ + yystack.push (0, null, yylloc); + yystack.push (0, null, yyerrloc); yyloc = yylloc (yystack, 2); - yystack.pop (2);])[ + yystack.pop (2);])[ /* Shift the error token. */ yy_symbol_print ("Shifting", yystos_[yyn], diff --cc data/yacc.c index 19b5331d,284e13de..a8dce4a7 --- a/data/yacc.c +++ b/data/yacc.c @@@ -268,9 -267,11 +268,11 @@@ m4_if(b4_prefix, [yy], [] /* Copy the first part of user declarations. */ ]b4_user_pre_prologue[ + ]b4_null_define[ + /* Enabling traces. */ #ifndef YYDEBUG -# define YYDEBUG ]b4_debug_flag[ +# define YYDEBUG ]b4_parse_trace_if([1], [0])[ #endif /* Enabling verbose error messages. */ diff --cc src/system.h index f0a76ceb,d3c544b4..0d69e93e --- a/src/system.h +++ b/src/system.h @@@ -92,15 -80,15 +92,15 @@@ typedef size_t uintptr_t and safer logic than it would for users. Due to the overhead of M4, suppressing Code is unlikely to offer any significant improvement in Bison's performance anyway. */ -# define PACIFY_CC(Code) Code +#define PACIFY_CC(Code) Code -# ifndef __attribute__ +#ifndef __attribute__ /* 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 */ -# endif +# define __attribute__(Spec) /* empty */ # endif +#endif /* The __-protected variants of `format' and `printf' attributes are accepted by gcc versions 2.6.4 (effectively 2.7) and later. */ diff --cc tests/calc.at index 28e6c50e,c5040083..477c92d3 --- a/tests/calc.at +++ b/tests/calc.at @@@ -239,11 -239,11 +239,11 @@@ int yylex (]AT_LEX_FORMALS[) a constructor for position that initializes the filename. The glr.cc skeleton does not (and in fact cannot: location/position are stored in a union, from which objects with constructors are - excluded in C++. */ + excluded in C++). */ %initial-action { - @$.initialize (0); + @$.initialize (); } -])])[ +])])])[ /* Bison Declarations */ %token CALC_EOF 0 "end of input"