Hi Frank! > Le 1 nov. 2019 à 12:22, Frank Heckenbach <f.heckenb...@fh-soft.de> a écrit : > > Akim Demaille wrote: > >> Please, torture this beta, and report your mileage! > > Using "-Werror -Wold-style-cast", I get the following warning. > Otherwise, it seems to work fine for me. > > In member function 'std::ptrdiff_t yy::TMathParser::stack<T, S>::ssize() > const': > error: use of old-style cast to 'std::ptrdiff_t' {aka 'long int'} > [-Werror=old-style-cast] > > I think this will be fixed by using a simple type conversion (or > otherwise a static_cast) instead of the old-style cast: > > - return (std::ptrdiff_t) size (); > + return std::ptrdiff_t (size ());
Tsss... Shame on me. Thanks! But it was quite something to add this warning to the test suite... I'm happy though that our casts are now easy to find. In fact, in a former branch of mine, it would have helped me a lot tracking some nasty failures. Cheers! commit 3398b0fa905b24cc7aa0fa1409f50525d645d485 Author: Akim Demaille <akim.demai...@gmail.com> Date: Fri Nov 1 16:13:46 2019 +0100 c++: fix old cast warnings We still have a few old C casts in lalr1.cc, let's get rid of them. Reported by Frank Heckenbach. Actually, let's monitor all our casts using easy to grep macros. Let's use these macros to use the C++ standard casts when we are in C++. * data/skeletons/c.m4 (b4_cast_define): New. * data/skeletons/glr.c, data/skeletons/glr.cc, * data/skeletons/lalr1.cc, data/skeletons/stack.hh, * data/skeletons/yacc.c: Use it and/or its casts. * tests/actions.at, tests/cxx-type.at, * tests/glr-regression.at, tests/headers.at, tests/torture.at, * tests/types.at: Use YY_CAST instead of C casts. * configure.ac (warn_cxx): Add -Wold-style-cast. * doc/bison.texi: Disable it. diff --git a/configure.ac b/configure.ac index e5517d24..5a5d8305 100644 --- a/configure.ac +++ b/configure.ac @@ -107,7 +107,8 @@ if test "$enable_gcc_warnings" = yes; then -Wpointer-arith -Wshadow -Wwrite-strings' warn_c='-Wbad-function-cast -Wstrict-prototypes' - warn_cxx='-Wextra-semi -Wnoexcept -Wundefined-func-template -Wweak-vtables' + warn_cxx='-Wextra-semi -Wnoexcept -Wold-style-cast -Wundefined-func-template + -Wweak-vtables' # Warnings for the test suite only. # # -fno-color-diagnostics: Clang's use of colors in the error diff --git a/data/skeletons/c.m4 b/data/skeletons/c.m4 index a1d55d47..756d74ee 100644 --- a/data/skeletons/c.m4 +++ b/data/skeletons/c.m4 @@ -346,6 +346,21 @@ m4_define([b4_attribute_define], ]]) +# b4_cast_define +# -------------- +m4_define([b4_cast_define], +[# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast<Type> (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif[]dnl +]) + + # b4_null_define # -------------- # Portability issues: define a YY_NULLPTR appropriate for the current diff --git a/data/skeletons/glr.c b/data/skeletons/glr.c index 39fb3091..2782ee8b 100644 --- a/data/skeletons/glr.c +++ b/data/skeletons/glr.c @@ -125,7 +125,7 @@ m4_define([b4_lhs_value], # ----------------------------- # See README. m4_define([b4_rhs_data], -[((yyGLRStackItem const *)yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.yystate]) +[YY_CAST (yyGLRStackItem const *, yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.yystate]) # b4_rhs_value(RULE-LENGTH, POS, SYMBOL-NUM, [TYPE]) @@ -235,7 +235,7 @@ b4_copyright([Skeleton implementation for Bison GLR parsers in C], #define yylloc ]b4_prefix[lloc]])]))[ ]b4_user_pre_prologue[ - +]b4_cast_define[ ]b4_null_define[ ]b4_defines_if([[#include "@basename(]b4_spec_header_file[@)"]], @@ -289,7 +289,8 @@ static YYLTYPE yyloc_default][]b4_yyloc_default;])[ # define YYREALLOC realloc #endif -#define YYSIZEMAX (PTRDIFF_MAX < SIZE_MAX ? PTRDIFF_MAX : (ptrdiff_t) SIZE_MAX) +#define YYSIZEMAX \ + (PTRDIFF_MAX < SIZE_MAX ? PTRDIFF_MAX : YY_CAST (ptrdiff_t, SIZE_MAX)) #ifdef __cplusplus typedef bool yybool; @@ -617,7 +618,7 @@ yytnamerr (char *yyres, const char *yystr) if (yyres) return yystpcpy (yyres, yystr) - yyres; else - return (ptrdiff_t) strlen (yystr); + return YY_CAST (ptrdiff_t, strlen (yystr)); } # endif @@ -845,7 +846,8 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, yyGLRStack* yystackp, YYSTYPE* yyvalp]b4_locuser_formals[) { - yybool yynormal YY_ATTRIBUTE_UNUSED = (yybool) (yystackp->yysplitPoint == YY_NULLPTR); + yybool yynormal YY_ATTRIBUTE_UNUSED + = YY_CAST (yybool, yystackp->yysplitPoint == YY_NULLPTR); int yylow; ]b4_parse_param_use([yyvalp], [yylocp])dnl [ YYUSE (yyrhslen); @@ -980,7 +982,7 @@ yylhsNonterm (yyRuleNum yyrule) static inline yybool yyisDefaultedState (yyStateNum yystate) { - return (yybool) yypact_value_is_default (yypact[yystate]); + return YY_CAST (yybool, yypact_value_is_default (yypact[yystate])); } /** The default reduction for YYSTATE, assuming it has one. */ @@ -1040,13 +1042,13 @@ yyLRgotoState (yyStateNum yystate, yySymbol yysym) static inline yybool yyisShiftAction (int yyaction) { - return (yybool) (0 < yyaction); + return YY_CAST (yybool, 0 < yyaction); } static inline yybool yyisErrorAction (int yyaction) { - return (yybool) (yyaction == 0); + return YY_CAST (yybool, yyaction == 0); } /* GLRStates */ @@ -1102,21 +1104,24 @@ yyinitStateSet (yyGLRStateSet* yyset) yyset->yysize = 1; yyset->yycapacity = 16; yyset->yystates - = (yyGLRState**) YYMALLOC ((size_t) yyset->yycapacity - * sizeof yyset->yystates[0]); + = YY_CAST(yyGLRState**, + YYMALLOC (YY_CAST (size_t, yyset->yycapacity) + * sizeof yyset->yystates[0])); if (! yyset->yystates) return yyfalse; yyset->yystates[0] = YY_NULLPTR; yyset->yylookaheadNeeds - = (yybool*) YYMALLOC ((size_t) yyset->yycapacity - * sizeof yyset->yylookaheadNeeds[0]); + = YY_CAST (yybool*, + YYMALLOC (YY_CAST (size_t, yyset->yycapacity) + * sizeof yyset->yylookaheadNeeds[0])); if (! yyset->yylookaheadNeeds) { YYFREE (yyset->yystates); return yyfalse; } memset (yyset->yylookaheadNeeds, - 0, (size_t) yyset->yycapacity * sizeof yyset->yylookaheadNeeds[0]); + 0, + YY_CAST (size_t, yyset->yycapacity) * sizeof yyset->yylookaheadNeeds[0]); return yytrue; } @@ -1134,9 +1139,10 @@ yyinitGLRStack (yyGLRStack* yystackp, ptrdiff_t yysize) yystackp->yyerrState = 0; yynerrs = 0; yystackp->yyspaceLeft = yysize; - yystackp->yyitems = - (yyGLRStackItem*) YYMALLOC ((size_t) yysize - * sizeof yystackp->yynextFree[0]); + yystackp->yyitems + = YY_CAST (yyGLRStackItem*, + YYMALLOC (YY_CAST (size_t, yysize) + * sizeof yystackp->yynextFree[0])); if (!yystackp->yyitems) return yyfalse; yystackp->yynextFree = yystackp->yyitems; @@ -1147,8 +1153,9 @@ yyinitGLRStack (yyGLRStack* yystackp, ptrdiff_t yysize) #if YYSTACKEXPANDABLE -# define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \ - &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE +# define YYRELOC(YYFROMITEMS, YYTOITEMS, YYX, YYTYPE) \ + &((YYTOITEMS) \ + - ((YYFROMITEMS) - YY_REINTERPRET_CAST (yyGLRStackItem*, (YYX))))->YYTYPE /** If *YYSTACKP is expandable, extend it. WARNING: Pointers into the stack from outside should be considered invalid after this call. @@ -1168,8 +1175,10 @@ yyexpandGLRStack (yyGLRStack* yystackp) yynewSize = 2*yysize; if (YYMAXDEPTH < yynewSize) yynewSize = YYMAXDEPTH; - yynewItems = (yyGLRStackItem*) YYMALLOC ((size_t) yynewSize - * sizeof yynewItems[0]); + yynewItems + = YY_CAST (yyGLRStackItem*, + YYMALLOC (YY_CAST (size_t, yynewSize) + * sizeof yynewItems[0])); if (! yynewItems) yyMemoryExhausted (yystackp); for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize; @@ -1177,7 +1186,7 @@ yyexpandGLRStack (yyGLRStack* yystackp) yyn -= 1, yyp0 += 1, yyp1 += 1) { *yyp1 = *yyp0; - if (*(yybool *) yyp0) + if (*YY_REINTERPRET_CAST (yybool *, yyp0)) { yyGLRState* yys0 = &yyp0->yystate; yyGLRState* yys1 = &yyp1->yystate; @@ -1282,7 +1291,7 @@ yyremoveDeletes (yyGLRStack* yystackp) if (yyj != yyi) { YYDPRINTF ((stderr, "Rename stack %ld -> %ld.\n", - (long) yyi, (long) yyj)); + YY_CAST (long, yyi), YY_CAST (long, yyj))); } yyj += 1; } @@ -1353,7 +1362,7 @@ yy_reduce_print (yybool yynormal, yyGLRStackItem* yyvsp, ptrdiff_t yyk, int yylow = 1;])[ int yyi; YYFPRINTF (stderr, "Reducing stack %ld by rule %d (line %d):\n", - (long) yyk, yyrule - 1, yyrline[yyrule]); + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule]); if (! yynormal) yyfillin (yyvsp, 1, -yynrhs); /* The symbols being reduced. */ @@ -1387,7 +1396,8 @@ yydoAction (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule, if (yystackp->yysplitPoint == YY_NULLPTR) { /* Standard special case: single stack. */ - yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk]; + yyGLRStackItem* yyrhs + = YY_REINTERPRET_CAST (yyGLRStackItem*, yystackp->yytops.yystates[yyk]); YYASSERT (yyk == 0); yystackp->yynextFree -= yynrhs; yystackp->yyspaceLeft += yynrhs; @@ -1445,7 +1455,7 @@ yyglrReduce (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule, { YYDPRINTF ((stderr, "Parse on stack %ld rejected by rule %d (line %d).\n", - (long) yyk, yyrule - 1, yyrline[yyrule - 1])); + YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule - 1])); } if (yyflag != yyok) return yyflag; @@ -1473,7 +1483,7 @@ yyglrReduce (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule, YYDPRINTF ((stderr, "Reduced stack %ld by rule %d (line %d); action deferred. " "Now in state %d.\n", - (long) yyk, yyrule - 1, yyrline[yyrule - 1], yynewLRState)); + 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) { @@ -1486,7 +1496,7 @@ 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", - (long) yyk, (long) yyi)); + YY_CAST (long, yyk), YY_CAST (long, yyi))); return yyok; } yyp = yyp->yypred; @@ -1517,18 +1527,20 @@ yysplitStack (yyGLRStack* yystackp, ptrdiff_t yyk) yyMemoryExhausted (yystackp); yystackp->yytops.yycapacity *= 2; - yynewStates = - (yyGLRState**) YYREALLOC (yystackp->yytops.yystates, - ((size_t) yystackp->yytops.yycapacity - * sizeof yynewStates[0])); + yynewStates + = YY_CAST (yyGLRState**, + YYREALLOC (yystackp->yytops.yystates, + (YY_CAST (size_t, yystackp->yytops.yycapacity) + * sizeof yynewStates[0]))); if (yynewStates == YY_NULLPTR) yyMemoryExhausted (yystackp); yystackp->yytops.yystates = yynewStates; - yynewLookaheadNeeds = - (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds, - ((size_t) yystackp->yytops.yycapacity - * sizeof yynewLookaheadNeeds[0])); + yynewLookaheadNeeds + = YY_CAST (yybool*, + YYREALLOC (yystackp->yytops.yylookaheadNeeds, + (YY_CAST (size_t, yystackp->yytops.yycapacity) + * sizeof yynewLookaheadNeeds[0]))); if (yynewLookaheadNeeds == YY_NULLPTR) yyMemoryExhausted (yystackp); yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds; @@ -1731,8 +1743,8 @@ yyreportTree (yySemanticOption* yyx, int yyindent) else YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %ld .. %ld>\n", yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)), - yyx->yyrule - 1, (long) (yys->yyposn + 1), - (long) yyx->yystate->yyposn); + 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) @@ -1743,8 +1755,8 @@ yyreportTree (yySemanticOption* yyx, int yyindent) else YYFPRINTF (stderr, "%*s%s <tokens %ld .. %ld>\n", yyindent+2, "", yytokenName (yystos[yystates[yyi]->yylrState]), - (long) (yystates[yyi-1]->yyposn + 1), - (long) yystates[yyi]->yyposn); + YY_CAST (long, yystates[yyi-1]->yyposn + 1), + YY_CAST (long, yystates[yyi]->yyposn)); } else yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2); @@ -1940,7 +1952,7 @@ yycompressStack (yyGLRStack* yystackp) yyp->yypred = yyr; yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems; - yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1; + yystackp->yynextFree = YY_REINTERPRET_CAST (yyGLRStackItem*, yystackp->yysplitPoint) + 1; yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems; yystackp->yysplitPoint = YY_NULLPTR; yystackp->yylastDeleted = YY_NULLPTR; @@ -1973,7 +1985,7 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, yyRuleNum yyrule = yydefaultAction (yystate); if (yyrule == 0) { - YYDPRINTF ((stderr, "Stack %ld dies.\n", (long) yyk)); + YYDPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); yymarkStackDeleted (yystackp, yyk); return yyok; } @@ -1983,7 +1995,7 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, YYDPRINTF ((stderr, "Stack %ld dies " "(predicate failure or explicit user error).\n", - (long) yyk)); + YY_CAST (long, yyk))); yymarkStackDeleted (yystackp, yyk); return yyok; } @@ -2002,7 +2014,7 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, YYRESULTTAG yyflag; ptrdiff_t yynewStack = yysplitStack (yystackp, yyk); YYDPRINTF ((stderr, "Splitting off stack %ld from %ld.\n", - (long) yynewStack, (long) yyk)); + YY_CAST (long, yynewStack), YY_CAST (long, yyk))); yyflag = yyglrReduce (yystackp, yynewStack, *yyconflicts, yyimmediate[*yyconflicts]]b4_user_args[); @@ -2011,7 +2023,7 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, yyposn]b4_pure_args[)); else if (yyflag == yyerr) { - YYDPRINTF ((stderr, "Stack %ld dies.\n", (long) yynewStack)); + YYDPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yynewStack))); yymarkStackDeleted (yystackp, yynewStack); } else @@ -2023,7 +2035,7 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, break; else if (yyisErrorAction (yyaction)) { - YYDPRINTF ((stderr, "Stack %ld dies.\n", (long) yyk)); + YYDPRINTF ((stderr, "Stack %ld dies.\n", YY_CAST (long, yyk))); yymarkStackDeleted (yystackp, yyk); break; } @@ -2036,7 +2048,7 @@ yyprocessOneStack (yyGLRStack* yystackp, ptrdiff_t yyk, YYDPRINTF ((stderr, "Stack %ld dies " "(predicate failure or explicit user error).\n", - (long) yyk)); + YY_CAST (long, yyk))); yymarkStackDeleted (yystackp, yyk); break; } @@ -2147,7 +2159,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) } { - ptrdiff_t yysz = (ptrdiff_t) strlen (yyformat); + ptrdiff_t yysz = YY_CAST (ptrdiff_t, strlen (yyformat)); if (YYSIZEMAX - yysize < yysz) yysize_overflow = yytrue; else @@ -2155,7 +2167,7 @@ yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[) } if (!yysize_overflow) - yymsg = (char *) YYMALLOC ((size_t) yysize); + yymsg = YY_CAST (char *, YYMALLOC (YY_CAST (size_t, yysize))); if (yymsg) { @@ -2389,7 +2401,7 @@ b4_dollar_popdef])[]dnl ptrdiff_t yys; for (yys = 0; yys < yystack.yytops.yysize; yys += 1) - yystackp->yytops.yylookaheadNeeds[yys] = (yybool) (yychar != YYEMPTY); + yystackp->yytops.yylookaheadNeeds[yys] = YY_CAST (yybool, yychar != YYEMPTY); /* yyprocessOneStack returns one of three things: @@ -2440,12 +2452,12 @@ b4_dollar_popdef])[]dnl int yyaction = yygetLRActions (yystate, yytoken_to_shift, &yyconflicts); /* Note that yyconflicts were handled by yyprocessOneStack. */ - YYDPRINTF ((stderr, "On stack %ld, ", (long) yys)); + YYDPRINTF ((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", - (long) yys, + YY_CAST (long, yys), yystack.yytops.yystates[yys]->yylrState)); } @@ -2527,7 +2539,7 @@ yy_yypstack (yyGLRState* yys) yy_yypstack (yys->yypred); YYFPRINTF (stderr, " -> "); } - YYFPRINTF (stderr, "%d@@%ld", yys->yylrState, (long) yys->yyposn); + YYFPRINTF (stderr, "%d@@%ld", yys->yylrState, YY_CAST (long, yys->yyposn)); } static void @@ -2546,31 +2558,31 @@ yypstack (yyGLRStack* yystackp, ptrdiff_t yyk) yypstates (yystackp->yytops.yystates[yyk]); } -#define YYINDEX(YYX) \ - ((YYX) == YY_NULLPTR ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems) - - static void yypdumpstack (yyGLRStack* yystackp) { +#define YYINDEX(YYX) \ + YY_CAST (long, \ + ((YYX) \ + ? YY_REINTERPRET_CAST (yyGLRStackItem*, (YYX)) - yystackp->yyitems \ + : -1)) + yyGLRStackItem* yyp; - ptrdiff_t yyi; for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1) { YYFPRINTF (stderr, "%3ld. ", - (long) (yyp - yystackp->yyitems)); - if (*(yybool *) yyp) + 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, - (long) yyp->yystate.yyposn, - (long) YYINDEX (yyp->yystate.yypred)); + YY_CAST (long, yyp->yystate.yyposn), + YYINDEX (yyp->yystate.yypred)); if (! yyp->yystate.yyresolved) YYFPRINTF (stderr, ", firstVal: %ld", - (long) YYINDEX (yyp->yystate - .yysemantics.yyfirstVal)); + YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); } else { @@ -2578,16 +2590,21 @@ yypdumpstack (yyGLRStack* yystackp) YYASSERT (!yyp->yyoption.yyisState); YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld", yyp->yyoption.yyrule - 1, - (long) YYINDEX (yyp->yyoption.yystate), - (long) YYINDEX (yyp->yyoption.yynext)); + YYINDEX (yyp->yyoption.yystate), + YYINDEX (yyp->yyoption.yynext)); } YYFPRINTF (stderr, "\n"); } + YYFPRINTF (stderr, "Tops:"); - for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1) - YYFPRINTF (stderr, "%ld: %ld; ", (long) yyi, - (long) YYINDEX (yystackp->yytops.yystates[yyi])); - YYFPRINTF (stderr, "\n"); + { + 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"); + } +#undef YYINDEX } #endif diff --git a/data/skeletons/glr.cc b/data/skeletons/glr.cc index 56d9d7a1..ceb825a9 100644 --- a/data/skeletons/glr.cc +++ b/data/skeletons/glr.cc @@ -257,6 +257,14 @@ b4_percent_code_get([[requires]])[ ]b4_attribute_define[ ]b4_null_define[ +// This skeleton is based on C, yet compiles it as C++. +// So expect warnings about C style casts. +#if defined __clang__ && 306 <= __clang_major__ * 100 + __clang_minor__ +# pragma clang diagnostic ignored "-Wold-style-cast" +#elif defined __GNUC__ && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# pragma GCC diagnostic ignored "-Wold-style-cast" +#endif + // Whether we are compiled with exception support. #ifndef YY_EXCEPTIONS # if defined __GNUC__ && !defined __EXCEPTIONS diff --git a/data/skeletons/lalr1.cc b/data/skeletons/lalr1.cc index 4a7b71dd..64ff81a3 100644 --- a/data/skeletons/lalr1.cc +++ b/data/skeletons/lalr1.cc @@ -174,6 +174,7 @@ m4_define([b4_shared_declarations], ]b4_variant_if([b4_variant_includes])[ ]b4_attribute_define[ +]b4_cast_define[ ]b4_null_define[ ]b4_YYDEBUG_define[ @@ -1195,10 +1196,10 @@ b4_dollar_popdef])[]dnl { std::ptrdiff_t yylen = yyr2_[yyrule]; // First pop from the LAC stack as many tokens as possible. - std::ptrdiff_t lac_size = (std::ptrdiff_t) yylac_stack_.size (); + std::ptrdiff_t lac_size = std::ptrdiff_t (yylac_stack_.size ()); if (yylen < lac_size) { - yylac_stack_.resize ((std::size_t) (lac_size - yylen)); + yylac_stack_.resize (std::size_t (lac_size - yylen)); yylen = 0; } else if (lac_size) diff --git a/data/skeletons/stack.hh b/data/skeletons/stack.hh index cc1c63f4..cb52bcc2 100644 --- a/data/skeletons/stack.hh +++ b/data/skeletons/stack.hh @@ -90,10 +90,11 @@ m4_define([b4_stack_define], { return index_type (seq_.size ()); } + std::ptrdiff_t ssize () const YY_NOEXCEPT { - return (std::ptrdiff_t) size (); + return std::ptrdiff_t (size ()); } /// Iterator on top of the stack (going downwards). diff --git a/data/skeletons/yacc.c b/data/skeletons/yacc.c index 117c9315..0074df9a 100644 --- a/data/skeletons/yacc.c +++ b/data/skeletons/yacc.c @@ -339,13 +339,13 @@ m4_if(b4_api_prefix, [yy], [], #define yylex ]b4_prefix[lex #define yyerror ]b4_prefix[error #define yydebug ]b4_prefix[debug -#define yynerrs ]b4_prefix[nerrs -]]b4_pure_if([], [[ +#define yynerrs ]b4_prefix[nerrs]]b4_pure_if([], [[ #define yylval ]b4_prefix[lval #define yychar ]b4_prefix[char]b4_locations_if([[ #define yylloc ]b4_prefix[lloc]])]))[ ]b4_user_pre_prologue[ +]b4_cast_define[ ]b4_null_define[ /* Enabling verbose error messages. */ @@ -400,10 +400,13 @@ m4_if(b4_api_prefix, [yy], [], # endif #endif -#define YYSIZE_MAXIMUM ((YYPTRDIFF_T) (YYPTRDIFF_MAXIMUM < (YYSIZE_T) -1 \ - ? YYPTRDIFF_MAXIMUM : (YYSIZE_T) -1)) +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) -#define YYSIZEOF(X) ((YYPTRDIFF_T) sizeof (X)) +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) /* Stored state numbers (used for stacks). */ typedef ]b4_int_type(0, m4_eval(b4_states_number - 1))[ yy_state_t; @@ -557,7 +560,7 @@ union yyalloc # ifndef YYCOPY # if defined __GNUC__ && 1 < __GNUC__ # define YYCOPY(Dst, Src, Count) \ - __builtin_memcpy (Dst, Src, (YYSIZE_T) (Count) * sizeof (*(Src))) + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) # else # define YYCOPY(Dst, Src, Count) \ do \ @@ -832,8 +835,8 @@ yy_lac_stack_realloc (YYPTRDIFF_T *yycapacity, YYPTRDIFF_T yyadd, if (YYMAXDEPTH < yyalloc) yyalloc = YYMAXDEPTH; yybottom_new = - (yy_state_t *) YYSTACK_ALLOC ((YYSIZE_T) - (yyalloc * YYSIZEOF (*yybottom_new))); + YY_CAST(yy_state_t *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yyalloc * YYSIZEOF (*yybottom_new)))); if (!yybottom_new) { YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix, @@ -851,7 +854,7 @@ yy_lac_stack_realloc (YYPTRDIFF_T *yycapacity, YYPTRDIFF_T yyadd, *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]), [full], [[ YYDPRINTF ((stderr, "%srealloc to %ld%s", yydebug_prefix, - (long) yyalloc, yydebug_suffix));]])[ + YY_CAST (long, yyalloc), yydebug_suffix));]])[ } return 0; } @@ -1008,7 +1011,7 @@ yy_lac (yy_state_t *yyesa, yy_state_t **yyes, if (yyesp == yyes_prev) { yyesp = *yyes; - *yyesp = (yy_state_t) yystate; + *yyesp = YY_CAST (yy_state_t, yystate); } else { @@ -1021,7 +1024,7 @@ yy_lac (yy_state_t *yyesa, yy_state_t **yyes, YYDPRINTF ((stderr, "\n")); return 2; } - *++yyesp = (yy_state_t) yystate; + *++yyesp = YY_CAST (yy_state_t, yystate); } YYDPRINTF ((stderr, " G%d", yystate)); } @@ -1033,7 +1036,7 @@ yy_lac (yy_state_t *yyesa, yy_state_t **yyes, # ifndef yystrlen # if defined __GLIBC__ && defined _STRING_H -# define yystrlen(S) ((YYPTRDIFF_T) strlen (S)) +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) # else /* Return the length of YYSTR. */ ]b4_function_define([yystrlen], [static YYPTRDIFF_T], @@ -1342,7 +1345,7 @@ b4_function_define([[yyparse]], [[int]], b4_parse_param)[ yypstate *yyps;]b4_pure_if([], [[ if (yypstate_allocated) return YY_NULLPTR;]])[ - yyps = (yypstate *) malloc (sizeof *yyps); + yyps = YY_CAST (yypstate *, malloc (sizeof *yyps)); if (!yyps) return YY_NULLPTR; yyps->yynew = 1;]b4_pure_if([], [[ @@ -1484,7 +1487,7 @@ yynewstate: yysetstate: YYDPRINTF ((stderr, "Entering state %d\n", yystate)); YY_ASSERT (0 <= yystate && yystate < YYNSTATES); - *yyssp = (yy_state_t) yystate; + *yyssp = YY_CAST (yy_state_t, yystate); if (yyss + yystacksize - 1 <= yyssp) #if !defined yyoverflow && !defined YYSTACK_RELOCATE @@ -1527,8 +1530,8 @@ yysetstate: { yy_state_t *yyss1 = yyss; union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC ((YYSIZE_T) - YYSTACK_BYTES (yystacksize)); + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); if (! yyptr) goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); @@ -1545,7 +1548,7 @@ yysetstate: yylsp = yyls + yysize - 1;])[ YYDPRINTF ((stderr, "Stack size increased to %ld\n", - (long) yystacksize)); + YY_CAST (long, yystacksize))); if (yyss + yystacksize - 1 <= yyssp) YYABORT; @@ -1758,7 +1761,7 @@ yyerrlab: { if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); - yymsg = (char *) YYSTACK_ALLOC ((YYSIZE_T) yymsg_alloc); + yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); if (!yymsg) { yymsg = yymsgbuf; diff --git a/doc/bison.texi b/doc/bison.texi index 1c9ed8fb..0f5838c2 100644 --- a/doc/bison.texi +++ b/doc/bison.texi @@ -12251,10 +12251,12 @@ then the parser's to get the set of defined tokens. # pragma GCC diagnostic ignored "-Wnull-dereference" #endif -// Of course, when compiling C as C++, expect warnings about NULL. +// This example uses Flex's C backend, yet compiles it as C++. +// So expect warnings about C style casts and NULL. #if defined __clang__ # pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" #elif defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ +# pragma GCC diagnostic ignored "-Wold-style-cast" # pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" #endif diff --git a/tests/actions.at b/tests/actions.at index 70b80dcf..34325c7a 100644 --- a/tests/actions.at +++ b/tests/actions.at @@ -772,10 +772,10 @@ static static int counter = 0; int c = ]AT_VAL[]m4_ifval([$6], [.ival])[ = counter++; + assert (c <= YY_CAST (int, strlen (source))); /* As in BASIC, line numbers go from 10 to 10. */ ]AT_LOC_FIRST_LINE[ = ]AT_LOC_FIRST_COLUMN[ = (10 * c); ]AT_LOC_LAST_LINE[ = ]AT_LOC_LAST_COLUMN[ = ]AT_LOC_FIRST_LINE[ + 9; - assert (c <= (int) strlen (source)); if (source[c]) fprintf (stderr, "sending: '%c'", source[c]); else @@ -1780,7 +1780,8 @@ float: UNTYPED INT yy::parser::token::INT, EOF}]], [[{UNTYPED, INT, EOF}]]), - [AT_VAL.ival = (int) toknum * 10; AT_VAL.fval = (float) toknum / 10.0f;])[ + [AT_VAL.ival = YY_CAST (int, toknum) * 10; + AT_VAL.fval = YY_CAST (float, toknum) / 10.0f;])[ ]AT_MAIN_DEFINE[ ]]) @@ -1805,7 +1806,6 @@ AT_CLEANUP ]) m4_map_args([AT_TEST], [yacc.c], [glr.c], [lalr1.cc], [glr.cc]) - m4_popdef([AT_TEST]) ## -------------------------------------------------- ## @@ -1897,7 +1897,7 @@ exp: %% ]AT_YYERROR_DEFINE[ -]AT_YYLEX_DEFINE(["bcd"], [*lvalp = (int) ((toknum + 1) * 10)])[ +]AT_YYLEX_DEFINE(["bcd"], [*lvalp = YY_CAST (int, (toknum + 1) * 10)])[ ]AT_MAIN_DEFINE[ ]]) AT_BISON_OPTION_POPDEFS diff --git a/tests/cxx-type.at b/tests/cxx-type.at index 200d3b99..92401172 100644 --- a/tests/cxx-type.at +++ b/tests/cxx-type.at @@ -178,7 +178,7 @@ main (int argc, char **argv) do { - buffer[i++] = (char) c; + buffer[i++] = YY_CAST (char, c); colNum += 1; assert (i != sizeof buffer - 1); c = getchar (); @@ -187,8 +187,8 @@ main (int argc, char **argv) ungetc (c, stdin); buffer[i++] = 0; - tok = isupper ((unsigned char) buffer[0]) ? TYPENAME : ID; - yylval = new_term (strcpy ((char *) malloc (i), buffer)); + tok = isupper (YY_CAST (unsigned char, buffer[0])) ? TYPENAME : ID; + yylval = new_term (strcpy (YY_CAST (char *, malloc (i)), buffer)); } else { @@ -206,7 +206,7 @@ main (int argc, char **argv) static Node * new_nterm (char const *form, Node *child0, Node *child1, Node *child2) { - Node *node = (Node *) malloc (sizeof (Node)); + Node *node = YY_CAST (Node *, malloc (sizeof (Node))); node->nterm.isNterm = 1; node->nterm.parents = 0; node->nterm.form = form; @@ -225,7 +225,7 @@ new_nterm (char const *form, Node *child0, Node *child1, Node *child2) static Node * new_term (char *text) { - Node *node = (Node *) malloc (sizeof (Node)); + Node *node = YY_CAST (Node *, malloc (sizeof (Node))); node->term.isNterm = 0; node->term.parents = 0; node->term.text = text; @@ -255,30 +255,27 @@ free_node (Node *node) static char * node_to_string (Node *node) { - char *child0; - char *child1; - char *child2; - char *buffer; + char *res; if (!node) { - buffer = (char *) malloc (1); - buffer[0] = 0; + res = YY_CAST (char *, malloc (1)); + res[0] = 0; } else if (node->nodeInfo.isNterm == 1) { - child0 = node_to_string (node->nterm.children[0]); - child1 = node_to_string (node->nterm.children[1]); - child2 = node_to_string (node->nterm.children[2]); - buffer = (char *) malloc (strlen (node->nterm.form) + strlen (child0) - + strlen (child1) + strlen (child2) + 1); - sprintf (buffer, node->nterm.form, child0, child1, child2); - free (child0); - free (child1); + char *child0 = node_to_string (node->nterm.children[0]); + char *child1 = node_to_string (node->nterm.children[1]); + char *child2 = node_to_string (node->nterm.children[2]); + res = YY_CAST (char *, malloc (strlen (node->nterm.form) + strlen (child0) + + strlen (child1) + strlen (child2) + 1)); + sprintf (res, node->nterm.form, child0, child1, child2); free (child2); + free (child1); + free (child0); } else - buffer = strdup (node->term.text); - return buffer; + res = strdup (node->term.text); + return res; } ]] diff --git a/tests/glr-regression.at b/tests/glr-regression.at index e6b8c01a..67e3b3f8 100644 --- a/tests/glr-regression.at +++ b/tests/glr-regression.at @@ -153,7 +153,7 @@ var_list: { $$ = $1; } | var ',' var_list { - char *s = (char *) realloc ($1, strlen ($1) + 1 + strlen ($3) + 1); + char *s = YY_CAST (char *, realloc ($1, strlen ($1) + 1 + strlen ($3) + 1)); strcat (s, ","); strcat (s, $3); free ($3); @@ -172,7 +172,6 @@ int yylex (void) { char buf[50]; - char *s; assert (!feof (stdin)); switch (fscanf (input, " %1[a-z,]", buf)) { @@ -181,15 +180,19 @@ yylex (void) case EOF: return 0; default: + if (fscanf (input, "%49s", buf) != 1) + return 0; + else + { + char *s; + assert (strlen (buf) < sizeof buf - 1); + s = YY_CAST (char *, malloc (strlen (buf) + 1)); + strcpy (s, buf); + yylval = s; + return 'V'; + } break; } - if (fscanf (input, "%49s", buf) != 1) - return 0; - assert (strlen (buf) < sizeof buf - 1); - s = (char *) malloc (strlen (buf) + 1); - strcpy (s, buf); - yylval = s; - return 'V'; } int @@ -419,7 +422,7 @@ make_value (char const *parent, char const *child) { char const format[] = "%s <- %s"; char *value = *ptrs_next++ = - (char *) malloc (strlen (parent) + strlen (child) + sizeof format); + YY_CAST (char *, malloc (strlen (parent) + strlen (child) + sizeof format)); sprintf (value, format, parent, child); return value; } @@ -429,7 +432,7 @@ merge (YYSTYPE s1, YYSTYPE s2) { char const format[] = "merge{ %s and %s }"; char *value = *ptrs_next++ = - (char *) malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format); + YY_CAST (char *, malloc (strlen (s1.ptr) + strlen (s2.ptr) + sizeof format)); sprintf (value, format, s1.ptr, s2.ptr); return value; } @@ -601,7 +604,7 @@ stack2: 'a' ; static int yylex (void) { - yylval.node = (count_node*) malloc (sizeof *yylval.node); + yylval.node = YY_CAST (count_node*, malloc (sizeof *yylval.node)); if (!yylval.node) { fprintf (stderr, "Test inconclusive.\n"); @@ -1118,7 +1121,7 @@ change_lookahead: ]AT_YYERROR_DEFINE[ ]AT_YYLEX_DEFINE(["ab"], - [yylval.value = (char) (res + 'A' - 'a')])[ + [yylval.value = YY_CAST (char, res + 'A' - 'a')])[ static void print_lookahead (char const *reduction) @@ -1319,10 +1322,10 @@ yylex (void) { static char const input[] = "abcdddd"; static int toknum = 0; - assert (toknum < (int) sizeof input); + assert (toknum < YY_CAST (int, sizeof input)); yylloc.first_line = yylloc.last_line = 1; yylloc.first_column = yylloc.last_column = toknum + 1; - yylval.value = (char) (input[toknum] + 'A' - 'a'); + yylval.value = YY_CAST (char, input[toknum] + 'A' - 'a'); return input[toknum++]; } @@ -1349,7 +1352,7 @@ print_lookahead (char const *reduction) static char merge (union YYSTYPE s1, union YYSTYPE s2) { - return (char) (s1.value + s2.value); + return YY_CAST (char, s1.value + s2.value); } int @@ -1577,7 +1580,7 @@ yylex (YYSTYPE *lvalp, YYLTYPE *llocp) { static char const input[] = "ab"; static int toknum = 0; - assert (toknum < (int) sizeof input); + assert (toknum < YY_CAST (int, sizeof input)); lvalp->dummy = 0; llocp->first_line = llocp->last_line = 2; llocp->first_column = toknum + 1; diff --git a/tests/headers.at b/tests/headers.at index 11d60f16..079fd9f9 100644 --- a/tests/headers.at +++ b/tests/headers.at @@ -322,6 +322,7 @@ AT_PERL_CHECK([[-n -0777 -e ' |YYPUSH_MORE(?:_DEFINED)? |YYUSE |YY_ATTRIBUTE(?:_PURE|_UNUSED) + |YY(?:_REINTERPRET)?_CAST |YY_CONSTEXPR |YY_COPY |YY_CPLUSPLUS diff --git a/tests/torture.at b/tests/torture.at index 21616b53..a8ba0cc2 100644 --- a/tests/torture.at +++ b/tests/torture.at @@ -446,7 +446,7 @@ get_args (int argc, const char **argv) assert (0 <= res); assert (res <= INT_MAX); assert (errno != ERANGE); - return (int) res; + return YY_CAST (int, res); } int diff --git a/tests/types.at b/tests/types.at index c7d4189e..1c41293a 100644 --- a/tests/types.at +++ b/tests/types.at @@ -166,7 +166,7 @@ m4_foreach([b4_skel], [[yacc.c], [glr.c], [lalr1.cc], [glr.cc]], [if (res) { AT_VAL.ival = (res - '0') * 10; - AT_VAL.fval = (float) (res - '0') / 10.f; + AT_VAL.fval = YY_CAST (float, res - '0') / 10.f; }], [30 0.3]) @@ -197,7 +197,7 @@ m4_foreach([b4_skel], [[yacc.c], [glr.c], [lalr1.cc], [glr.cc]], ["12"], [if (res) { - AT_VAL.up = (struct u *) malloc (sizeof *AT_VAL.up); + AT_VAL.up = YY_CAST (struct u *, malloc (sizeof *AT_VAL.up)); assert (AT_VAL.up); AT_VAL.up->ival = res - '0'; }