Re: [Bison-Announce] Bison 3.4.91 released [beta]
Akim Demaille <[email protected]>
| Newsgroups | gmane.comp.parsers.bison.bugs |
|---|---|
| Message-ID | <[email protected]> |
Hi Frank! > Le 1 déc. 2019 à 07:31, Akim Demaille <[email protected]> a écrit : > >> Le 30 nov. 2019 à 06:52, Frank Heckenbach <[email protected]> a écrit : >> >> % g++-7 -Wextra -Wuseless-cast -c test.cc > > Doh... Yet another compiler flag... > > This one is really troublesome, I don't think I'll eliminate all the warnings before 3.5. Well, I wanted to get rid of it. It was much harder than I anticipated, for several reasons. First, this: # define YY_FPRINTF(Args) \ do { \ YY_IGNORE_USELESS_CAST_BEGIN \ fprintf Args; \ YY_IGNORE_USELESS_CAST_END \ } while (0) works as expected with GCC-9, but not with GCC-5 to GCC-8. Indeed: > #include <cstdio> > > # define YY_IGNORE_USELESS_CAST_BEGIN \ > _Pragma ("GCC diagnostic push") \ > _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") > # define YY_IGNORE_USELESS_CAST_END \ > _Pragma ("GCC diagnostic pop") > > > # define YY_FPRINTF(Args) \ > do { \ > YY_IGNORE_USELESS_CAST_BEGIN \ > fprintf Args; \ > YY_IGNORE_USELESS_CAST_END \ > } while (0) > > int main () > { > long yyi, yyj; > YY_FPRINTF ((stderr, "Rename stack %ld.\n", static_cast<long>(yyi))); > } gives > $ gcc-mp-7 -Wuseless-cast bar.cc > bar.cc: In function 'int main()': > bar.cc:20:68: warning: useless cast to type 'long int' [-Wuseless-cast] > YY_FPRINTF ((stderr, "Rename stack %ld.\n", static_cast<long>(yyi))); > ^ > bar.cc:13:13: note: in definition of macro 'YY_FPRINTF' > fprintf Args; \ > ^~~~ So I had to go into this more complex set of macros > # define YY_FPRINTF \ > YY_IGNORE_USELESS_CAST_BEGIN YY_FPRINTF_ > > # define YY_FPRINTF_(Args) \ > do { \ > YYFPRINTF Args; \ > YY_IGNORE_USELESS_CAST_END \ > } while (0) Second, because I just could not find a means to have this work with between 4.8 and 5 included. With these compilers putting each call to YYFPRINTF between a pair of YY_IGNORE_USELESS_CAST_BEGIN and YY_IGNORE_USELESS_CAST_END works, but it's too painful and clutters the source. And finally, with GCC 4.7, the compiler chokes on _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\""). So eventually I came to this solution, which does not enable the warning for GCC before 6. control this warning with pragmas with GCC before 5. commit f8d82ff03900c109efb57634299d7d180ce60987 Author: Akim Demaille <[email protected]> Date: Sat Nov 30 09:23:35 2019 +0100 warnings: enable -Wuseless-cast, and eliminate warnings Prompted by Frank Heckenbach. https://lists.gnu.org/archive/html/bug-bison/2019-11/msg00016.html. * configure.ac (warn_cxx): Add -Wuseless-cast. * data/skeletons/c.m4 (b4_attribute_define): Define YY_IGNORE_USELESS_CAST_BEGIN and YY_IGNORE_USELESS_CAST_END. * data/skeletons/glr.c (YY_FPRINTF): New, replaces YYFPRINTF, wrapped with YY_IGNORE_USELESS_CAST_BEGIN and YY_IGNORE_USELESS_CAST_END. (YY_DPRINTF): Likewise. * tests/actions.at: Remove useless cast. * tests/headers.at: Adjust. diff --git a/TODO b/TODO index 6d874425..5258b72d 100644 --- a/TODO +++ b/TODO @@ -1,4 +1,16 @@ * Bison 3.5 +** Deprecate YYPRINT +The doc shows it too much. + +** glr.c: parse.assert +There are many assertions in glr.c that are there to check the skeleton +itself, not the user code. So it should be under the control of +parse.assert. + +** java, d: error.verbose +The code checks dynamically for error.verbose. It should be controlled by +M4. + ** doc I feel its ugly to use the GNU style to declare functions in the doc. It generates tons of white space in the page, and may contribute to bad page diff --git a/configure.ac b/configure.ac index 45f87370..7a80eac1 100644 --- a/configure.ac +++ b/configure.ac @@ -151,8 +151,6 @@ if test "$enable_gcc_warnings" = yes; then # Warnings for the test suite, and maybe for bison if GCC is modern # enough. - gl_WARN_ADD([-Wmissing-declarations], [WARN_CFLAGS_TEST]) - gl_WARN_ADD([-Wmissing-prototypes], [WARN_CFLAGS_TEST]) test $lv_cv_gcc_pragma_push_works = yes && AS_VAR_APPEND([WARN_CFLAGS], [" $WARN_CFLAGS_TEST"]) @@ -179,6 +177,14 @@ if test "$enable_gcc_warnings" = yes; then [[if (sizeof (long) < sizeof (int)) return 1;]])]) gl_WARN_ADD([-Wzero-as-null-pointer-constant], [WARN_CXXFLAGS], [AC_LANG_PROGRAM([], [nullptr])]) + # Before GCC6, the pragmas don't work well enough to neutralize + # this warning. + gl_WARN_ADD([-Wuseless-cast], [WARN_CXXFLAGS], + [AC_LANG_PROGRAM([], [ + #if defined __GNUC__ && ! defined __ICC && ! defined __clang__ && __GNUC__ < 6 + syntax error + #endif + ])]) gl_WARN_ADD([-Werror], [WERROR_CXXFLAGS]) # Warnings for the test suite only. for i in $warn_tests; diff --git a/data/skeletons/c.m4 b/data/skeletons/c.m4 index 756d74ee..4b2c0946 100644 --- a/data/skeletons/c.m4 +++ b/data/skeletons/c.m4 @@ -327,11 +327,11 @@ m4_define([b4_attribute_define], #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") -# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ _Pragma ("GCC diagnostic pop") #else # define YY_INITIAL_VALUE(Value) Value @@ -343,6 +343,18 @@ m4_define([b4_attribute_define], #ifndef YY_INITIAL_VALUE # define YY_INITIAL_VALUE(Value) /* Nothing. */ #endif + +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif ]]) diff --git a/data/skeletons/glr.c b/data/skeletons/glr.c index ceb8116d..1f809bb6 100644 --- a/data/skeletons/glr.c +++ b/data/skeletons/glr.c @@ -470,23 +470,36 @@ typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG; # define YYFPRINTF fprintf # endif -]b4_yy_location_print_define[ +# define YY_FPRINTF \ + YY_IGNORE_USELESS_CAST_BEGIN YY_FPRINTF_ -# define YYDPRINTF(Args) \ +# define YY_FPRINTF_(Args) \ + do { \ + YYFPRINTF Args; \ + YY_IGNORE_USELESS_CAST_END \ + } while (0) + +# define YY_DPRINTF \ + YY_IGNORE_USELESS_CAST_BEGIN YY_DPRINTF_ + +# define YY_DPRINTF_(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ + YY_IGNORE_USELESS_CAST_END \ } while (0) +]b4_yy_location_print_define[ + ]b4_yy_symbol_print_define[ # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ do { \ if (yydebug) \ { \ - YYFPRINTF (stderr, "%s ", Title); \ + YY_FPRINTF ((stderr, "%s ", Title)); \ yy_symbol_print (stderr, Type, Value]b4_locuser_args([Location])[); \ - YYFPRINTF (stderr, "\n"); \ + YY_FPRINTF ((stderr, "\n")); \ } \ } while (0) @@ -502,7 +515,7 @@ static void yypdumpstack (struct yyGLRStack* yystackp) #else /* !]b4_api_PREFIX[DEBUG */ -# define YYDPRINTF(Args) do {} while (yyfalse) +# define YY_DPRINTF(Args) do {} while (yyfalse) # define YY_SYMBOL_PRINT(Title, Type, Value, Location) #endif /* !]b4_api_PREFIX[DEBUG */ @@ -786,7 +799,7 @@ yygetToken (int *yycharp][]b4_pure_if([, yyGLRStack* yystackp])[]b4_user_formals ]b4_parse_param_use()dnl [ if (*yycharp == YYEMPTY) { - YYDPRINTF ((stderr, "Reading a token: "));]b4_glr_cc_if([[ + YY_DPRINTF ((stderr, "Reading a token: "));]b4_glr_cc_if([[ #if YY_EXCEPTIONS try { @@ -796,7 +809,7 @@ yygetToken (int *yycharp][]b4_pure_if([, yyGLRStack* yystackp])[]b4_user_formals } catch (const ]b4_namespace_ref[::]b4_parser_class[::syntax_error& yyexc) { - YYDPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([ + YY_DPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([ yylloc = yyexc.location;])[ yyerror (]b4_lyyerror_args[yyexc.what ()); // Map errors caught in the scanner to the undefined token @@ -810,7 +823,7 @@ yygetToken (int *yycharp][]b4_pure_if([, yyGLRStack* yystackp])[]b4_user_formals if (*yycharp <= YYEOF) { *yycharp = yytoken = YYEOF; - YYDPRINTF ((stderr, "Now at end of input.\n")); + YY_DPRINTF ((stderr, "Now at end of input.\n")); } else { @@ -892,7 +905,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, } catch (const syntax_error& yyexc) { - YYDPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([ + YY_DPRINTF ((stderr, "Caught exception: %s\n", yyexc.what()));]b4_locations_if([ *yylocp = yyexc.location;])[ yyerror (]b4_yyerror_args[yyexc.what ()); YYERROR; @@ -946,9 +959,9 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[) if (yydebug) { if (yys->yysemantics.yyfirstVal) - YYFPRINTF (stderr, "%s unresolved", yymsg); + YY_FPRINTF ((stderr, "%s unresolved", yymsg)); else - YYFPRINTF (stderr, "%s incomplete", yymsg); + YY_FPRINTF ((stderr, "%s incomplete", yymsg)); YY_SYMBOL_PRINT ("", yystos[yys->yylrState], YY_NULLPTR, &yys->yyloc); } #endif @@ -1258,7 +1271,7 @@ yyundeleteLastStack (yyGLRStack* yystackp) return; yystackp->yytops.yystates[0] = yystackp->yylastDeleted; yystackp->yytops.yysize = 1; - YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); + YY_DPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n")); yystackp->yylastDeleted = YY_NULLPTR; } @@ -1272,7 +1285,7 @@ yyremoveDeletes (yyGLRStack* yystackp) if (yystackp->yytops.yystates[yyi] == YY_NULLPTR) { if (yyi == yyj) - YYDPRINTF ((stderr, "Removing dead stacks.\n")); + YY_DPRINTF ((stderr, "Removing dead stacks.\n")); yystackp->yytops.yysize -= 1; } else @@ -1286,7 +1299,7 @@ yyremoveDeletes (yyGLRStack* yystackp) yystackp->yytops.yylookaheadNeeds[yyj] = yystackp->yytops.yylookaheadNeeds[yyi]; if (yyj != yyi) - YYDPRINTF ((stderr, "Rename stack %ld -> %ld.\n", + YY_DPRINTF ((stderr, "Rename stack %ld -> %ld.\n", YY_CAST (long, yyi), YY_CAST (long, yyj))); yyj += 1; } @@ -1356,22 +1369,22 @@ yy_reduce_print (yybool yynormal, yyGLRStackItem* yyvsp, ptrdiff_t yyk, int yynrhs = yyrhsLength (yyrule);]b4_locations_if([ int yylow = 1;])[ int yyi; - YYFPRINTF (stderr, "Reducing stack %ld by rule %d (line %d):\n", - YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule]); + YY_FPRINTF ((stderr, "Reducing stack %ld by rule %d (line %d):\n", + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule])); if (! yynormal) yyfillin (yyvsp, 1, -yynrhs); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { - YYFPRINTF (stderr, " $%d = ", yyi + 1); + YY_FPRINTF ((stderr, " $%d = ", yyi + 1)); yy_symbol_print (stderr, yystos[yyvsp[yyi - yynrhs + 1].yystate.yylrState], &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yysval]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl b4_user_args[); if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved) - YYFPRINTF (stderr, " (unresolved)"); - YYFPRINTF (stderr, "\n"); + YY_FPRINTF ((stderr, " (unresolved)")); + YY_FPRINTF ((stderr, "\n")); } } #endif @@ -1447,9 +1460,9 @@ yyglrReduce (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule, YYRESULTTAG yyflag = yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[); if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULLPTR) - YYDPRINTF ((stderr, - "Parse on stack %ld rejected by rule %d (line %d).\n", - YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule - 1])); + YY_DPRINTF ((stderr, + "Parse on stack %ld rejected by rule %d (line %d).\n", + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule - 1])); if (yyflag != yyok) return yyflag; YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc); @@ -1473,11 +1486,11 @@ yyglrReduce (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule, } yyupdateSplit (yystackp, yys); yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule)); - YYDPRINTF ((stderr, - "Reduced stack %ld by rule %d (line %d); action deferred. " - "Now in state %d.\n", - YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule - 1], - yynewLRState)); + YY_DPRINTF ((stderr, + "Reduced stack %ld by rule %d (line %d); action deferred. " + "Now in state %d.\n", + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule - 1], + yynewLRState)); for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) if (yyi != yyk && yystackp->yytops.yystates[yyi] != YY_NULLPTR) { @@ -1489,8 +1502,8 @@ yyglrReduce (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule, { yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule); yymarkStackDeleted (yystackp, yyk); - YYDPRINTF ((stderr, "Merging stack %ld into stack %ld.\n", - YY_CAST (long, yyk), YY_CAST (long, yyi))); + YY_DPRINTF ((stderr, "Merging stack %ld into stack %ld.\n", + YY_CAST (long, yyk), YY_CAST (long, yyi))); return yyok; } yyp = yyp->yypred; @@ -1732,26 +1745,26 @@ yyreportTree (yySemanticOption* yyx, int yyindent) yystates[0] = yys; if (yyx->yystate->yyposn < yys->yyposn + 1) - YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n", - yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), - yyx->yyrule - 1); + YY_FPRINTF ((stderr, "%*s%s -> <Rule %d, empty>\n", + yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1)); else - YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %ld .. %ld>\n", - yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), - yyx->yyrule - 1, YY_CAST (long, yys->yyposn + 1), - YY_CAST (long, yyx->yystate->yyposn)); + YY_FPRINTF ((stderr, "%*s%s -> <Rule %d, tokens %ld .. %ld>\n", + yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), + yyx->yyrule - 1, YY_CAST (long, yys->yyposn + 1), + YY_CAST (long, yyx->yystate->yyposn))); for (yyi = 1; yyi <= yynrhs; yyi += 1) { if (yystates[yyi]->yyresolved) { if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn) - YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "", - yytokenName (yystos[yystates[yyi]->yylrState])); + YY_FPRINTF ((stderr, "%*s%s <empty>\n", yyindent+2, "", + yytokenName (yystos[yystates[yyi]->yylrState]))); else - YYFPRINTF (stderr, "%*s%s <tokens %ld .. %ld>\n", yyindent+2, "", - yytokenName (yystos[yystates[yyi]->yylrState]), - YY_CAST (long, yystates[yyi-1]->yyposn + 1), - YY_CAST (long, yystates[yyi]->yyposn)); + YY_FPRINTF ((stderr, "%*s%s <tokens %ld .. %ld>\n", yyindent+2, "", + yytokenName (yystos[yystates[yyi]->yylrState]), + YY_CAST (long, yystates[yyi-1]->yyposn + 1), + YY_CAST (long, yystates[yyi]->yyposn))); } else yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); @@ -1767,12 +1780,12 @@ yyreportAmbiguity (yySemanticOption* yyx0, YYUSE (yyx1); #if ]b4_api_PREFIX[DEBUG - YYFPRINTF (stderr, "Ambiguity detected.\n"); - YYFPRINTF (stderr, "Option 1,\n"); + YY_FPRINTF ((stderr, "Ambiguity detected.\n")); + YY_FPRINTF ((stderr, "Option 1,\n")); yyreportTree (yyx0, 2); - YYFPRINTF (stderr, "\nOption 2,\n"); + YY_FPRINTF ((stderr, "\nOption 2,\n")); yyreportTree (yyx1, 2); - YYFPRINTF (stderr, "\n"); + YY_FPRINTF ((stderr, "\n")); #endif yyerror (]b4_yyerror_args[YY_("syntax is ambiguous")); @@ -1970,7 +1983,7 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, while (yystackp->yytops.yystates[yyk] != YY_NULLPTR) { yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState; - YYDPRINTF ((stderr, "Stack %ld Entering state %d\n", yyk, yystate)); + YY_DPRINTF ((stderr, "Stack %ld Entering state %d\n", yyk, yystate)); YYASSERT (yystate != YYFINAL); @@ -1980,17 +1993,17 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule = yydefaultAction (yystate); if (yyrule == 0) { - YYDPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); + YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); yymarkStackDeleted (yystackp, yyk); return yyok; } yyflag = yyglrReduce (yystackp, yyk, yyrule, yyimmediate[yyrule]]b4_user_args[); if (yyflag == yyerr) { - YYDPRINTF ((stderr, - "Stack %ld dies " - "(predicate failure or explicit user error).\n", - YY_CAST (long, yyk))); + YY_DPRINTF ((stderr, + "Stack %ld dies " + "(predicate failure or explicit user error).\n", + YY_CAST (long, yyk))); yymarkStackDeleted (yystackp, yyk); return yyok; } @@ -2008,8 +2021,8 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, { YYRESULTTAG yyflag; ptrdiff_t yynewStack = yysplitStack (yystackp, yyk); - YYDPRINTF ((stderr, "Splitting off stack %ld from %ld.\n", - YY_CAST (long, yynewStack), YY_CAST (long, yyk))); + YY_DPRINTF ((stderr, "Splitting off stack %ld from %ld.\n", + YY_CAST (long, yynewStack), YY_CAST (long, yyk))); yyflag = yyglrReduce (yystackp, yynewStack, *yyconflicts, yyimmediate[*yyconflicts]]b4_user_args[); @@ -2018,7 +2031,7 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, yyposn]b4_pure_args[)); else if (yyflag == yyerr) { - YYDPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yynewStack))); + YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yynewStack))); yymarkStackDeleted (yystackp, yynewStack); } else @@ -2030,7 +2043,7 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, break; else if (yyisErrorAction (yyaction)) { - YYDPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); + YY_DPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); yymarkStackDeleted (yystackp, yyk); break; } @@ -2040,10 +2053,10 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, yyimmediate[-yyaction]]b4_user_args[); if (yyflag == yyerr) { - YYDPRINTF ((stderr, - "Stack %ld dies " - "(predicate failure or explicit user error).\n", - YY_CAST (long, yyk))); + YY_DPRINTF ((stderr, + "Stack %ld dies " + "(predicate failure or explicit user error).\n", + YY_CAST (long, yyk))); yymarkStackDeleted (yystackp, yyk); break; } @@ -2319,7 +2332,7 @@ yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[) yyGLRStack* const yystackp = &yystack; ptrdiff_t yyposn; - YYDPRINTF ((stderr, "Starting parse\n")); + YY_DPRINTF ((stderr, "Starting parse\n")); yychar = YYEMPTY; yylval = yyval_default;]b4_locations_if([ @@ -2350,7 +2363,7 @@ b4_dollar_popdef])[]dnl while (yytrue) { yyStateNum yystate = yystack.yytops.yystates[0]->yylrState; - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + YY_DPRINTF ((stderr, "Entering state %d\n", yystate)); if (yystate == YYFINAL) goto yyacceptlab; if (yyisDefaultedState (yystate)) @@ -2430,7 +2443,7 @@ b4_dollar_popdef])[]dnl 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([[ + YY_DPRINTF ((stderr, "Returning to deterministic operation.\n"));]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[ yyreportSyntaxError (&yystack]b4_user_args[); goto yyuser_error; @@ -2451,19 +2464,19 @@ b4_dollar_popdef])[]dnl int yyaction = yygetLRActions (yystate, yytoken_to_shift, &yyconflicts); /* Note that yyconflicts were handled by yyprocessOneStack. */ - YYDPRINTF ((stderr, "On stack %ld, ", YY_CAST (long, yys))); + YY_DPRINTF ((stderr, "On stack %ld, ", YY_CAST (long, yys))); YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc); yyglrShift (&yystack, yys, yyaction, yyposn, &yylval]b4_locations_if([, &yylloc])[); - YYDPRINTF ((stderr, "Stack %ld now in state #%d\n", - YY_CAST (long, yys), - yystack.yytops.yystates[yys]->yylrState)); + YY_DPRINTF ((stderr, "Stack %ld now in state #%d\n", + YY_CAST (long, yys), + yystack.yytops.yystates[yys]->yylrState)); } if (yystack.yytops.yysize == 1) { YYCHK1 (yyresolveStack (&yystack]b4_user_args[)); - YYDPRINTF ((stderr, "Returning to deterministic operation.\n")); + YY_DPRINTF ((stderr, "Returning to deterministic operation.\n")); yycompressStack (&yystack); break; } @@ -2536,19 +2549,19 @@ yy_yypstack (yyGLRState* yys) if (yys->yypred) { yy_yypstack (yys->yypred); - YYFPRINTF (stderr, " -> "); + YY_FPRINTF ((stderr, " -> ")); } - YYFPRINTF (stderr, "%d@@%ld", yys->yylrState, YY_CAST (long, yys->yyposn)); + YY_FPRINTF ((stderr, "%d@@%ld", yys->yylrState, YY_CAST (long, yys->yyposn))); } static void yypstates (yyGLRState* yyst) { if (yyst == YY_NULLPTR) - YYFPRINTF (stderr, "<null>"); + YY_FPRINTF ((stderr, "<null>")); else yy_yypstack (yyst); - YYFPRINTF (stderr, "\n"); + YY_FPRINTF ((stderr, "\n")); } static void @@ -2569,39 +2582,39 @@ yypdumpstack (yyGLRStack* yystackp) yyGLRStackItem* yyp; for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1) { - YYFPRINTF (stderr, "%3ld. ", - YY_CAST (long, yyp - yystackp->yyitems)); + YY_FPRINTF ((stderr, "%3ld. ", + YY_CAST (long, yyp - yystackp->yyitems))); if (*YY_REINTERPRET_CAST (yybool *, yyp)) { YYASSERT (yyp->yystate.yyisState); YYASSERT (yyp->yyoption.yyisState); - YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %ld, pred: %ld", - yyp->yystate.yyresolved, yyp->yystate.yylrState, - YY_CAST (long, yyp->yystate.yyposn), - YYINDEX (yyp->yystate.yypred)); + YY_FPRINTF ((stderr, "Res: %d, LR State: %d, posn: %ld, pred: %ld", + yyp->yystate.yyresolved, yyp->yystate.yylrState, + YY_CAST (long, yyp->yystate.yyposn), + YYINDEX (yyp->yystate.yypred))); if (! yyp->yystate.yyresolved) - YYFPRINTF (stderr, ", firstVal: %ld", - YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); + YY_FPRINTF ((stderr, ", firstVal: %ld", + YYINDEX (yyp->yystate.yysemantics.yyfirstVal))); } else { YYASSERT (!yyp->yystate.yyisState); YYASSERT (!yyp->yyoption.yyisState); - YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld", - yyp->yyoption.yyrule - 1, - YYINDEX (yyp->yyoption.yystate), - YYINDEX (yyp->yyoption.yynext)); + YY_FPRINTF ((stderr, "Option. rule: %d, state: %ld, next: %ld", + yyp->yyoption.yyrule - 1, + YYINDEX (yyp->yyoption.yystate), + YYINDEX (yyp->yyoption.yynext))); } - YYFPRINTF (stderr, "\n"); + YY_FPRINTF ((stderr, "\n")); } - YYFPRINTF (stderr, "Tops:"); + YY_FPRINTF ((stderr, "Tops:")); { ptrdiff_t yyi; for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) - YYFPRINTF (stderr, "%ld: %ld; ", YY_CAST (long, yyi), - YYINDEX (yystackp->yytops.yystates[yyi])); - YYFPRINTF (stderr, "\n"); + YY_FPRINTF ((stderr, "%ld: %ld; ", YY_CAST (long, yyi), + YYINDEX (yystackp->yytops.yystates[yyi]))); + YY_FPRINTF ((stderr, "\n")); } #undef YYINDEX } diff --git a/data/skeletons/yacc.c b/data/skeletons/yacc.c index 3eff66dd..2830c1de 100644 --- a/data/skeletons/yacc.c +++ b/data/skeletons/yacc.c @@ -854,8 +854,10 @@ yy_lac_stack_realloc (YYPTRDIFF_T *yycapacity, YYPTRDIFF_T yyadd, *yybottom = yybottom_new; *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]), [full], [[ + YY_IGNORE_USELESS_CAST_BEGIN YYDPRINTF ((stderr, "%srealloc to %ld%s", yydebug_prefix, - YY_CAST (long, yyalloc), yydebug_suffix));]])[ + YY_CAST (long, yyalloc), yydebug_suffix)); + YY_IGNORE_USELESS_CAST_END]])[ } return 0; } @@ -1012,7 +1014,9 @@ yy_lac (yy_state_t *yyesa, yy_state_t **yyes, if (yyesp == yyes_prev) { yyesp = *yyes; + YY_IGNORE_USELESS_CAST_BEGIN *yyesp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END } else { @@ -1025,7 +1029,9 @@ yy_lac (yy_state_t *yyesa, yy_state_t **yyes, YYDPRINTF ((stderr, "\n")); return 2; } + YY_IGNORE_USELESS_CAST_BEGIN *++yyesp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END } YYDPRINTF ((stderr, " G%d", yystate)); } @@ -1492,7 +1498,9 @@ yynewstate: yysetstate: YYDPRINTF ((stderr, "Entering state %d\n", yystate)); YY_ASSERT (0 <= yystate && yystate < YYNSTATES); - *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END if (yyss + yystacksize - 1 <= yyssp) #if !defined yyoverflow && !defined YYSTACK_RELOCATE @@ -1552,8 +1560,10 @@ yysetstate: yyvsp = yyvs + yysize - 1;]b4_locations_if([ yylsp = yyls + yysize - 1;])[ + YY_IGNORE_USELESS_CAST_BEGIN YYDPRINTF ((stderr, "Stack size increased to %ld\n", YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END if (yyss + yystacksize - 1 <= yyssp) YYABORT; diff --git a/tests/actions.at b/tests/actions.at index c702373c..e22e2596 100644 --- a/tests/actions.at +++ b/tests/actions.at @@ -1780,7 +1780,7 @@ float: UNTYPED INT yy::parser::token::INT, EOF}]], [[{UNTYPED, INT, EOF}]]), - [AT_VAL.ival = YY_CAST (int, toknum) * 10; + [AT_VAL.ival = toknum * 10; AT_VAL.fval = YY_CAST (float, toknum) / 10.0f;])[ ]AT_MAIN_DEFINE[ ]]) @@ -1897,7 +1897,7 @@ exp: %% ]AT_YYERROR_DEFINE[ -]AT_YYLEX_DEFINE(["bcd"], [*lvalp = YY_CAST (int, (toknum + 1) * 10)])[ +]AT_YYLEX_DEFINE(["bcd"], [*lvalp = (toknum + 1) * 10])[ ]AT_MAIN_DEFINE[ ]]) AT_BISON_OPTION_POPDEFS diff --git a/tests/headers.at b/tests/headers.at index 079fd9f9..31427436 100644 --- a/tests/headers.at +++ b/tests/headers.at @@ -326,7 +326,7 @@ AT_PERL_CHECK([[-n -0777 -e ' |YY_CONSTEXPR |YY_COPY |YY_CPLUSPLUS - |YY_IGNORE_MAYBE_UNINITIALIZED_(?:BEGIN|END) + |YY_IGNORE_(?:MAYBE_UNINITIALIZED|USELESS_CAST)_(?:BEGIN|END) |YY_INITIAL_VALUE |YY_MOVE |YY_MOVE_OR_COPY