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

style: use yyval only, not yysval

Browse Source 
* data/skeletons/glr.c, data/skeletons/glr2.cc: Use yyval, as in
the other skeletons.
This commit is contained in:
Akim Demaille
2020-12-26 11:43:50 +01:00
parent c18dbfcb06
commit 92dc8bf23b
3 changed files with 46 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
TODO
View File

@@ -16,16 +16,10 @@ Discourage the use of YYDEBUG in C++ (see thread with Jot). Stop supporting
Add value_type as a synonym for semantic_type. Add value_type as a synonym for semantic_type.
** Asymmetries ** Asymmetries
In glr_state, we have yysval and yylloc. It should be yyval/yyloc (and Why are yylval and yylloc treated differently?
yylval/yylloc when referring to the lookahead). glr.c should
s/yysval/yyval/.
Also
yystack.yyglrShift (create_state_set_index(0), 0, 0, yylval, &yylloc); yystack.yyglrShift (create_state_set_index(0), 0, 0, yylval, &yylloc);
Why are yylval and yylloc treated differently?
** yyerrok in Java ** yyerrok in Java
And add tests in calc.at, to prepare work for D. And add tests in calc.at, to prepare work for D.

46
data/skeletons/glr.c
View File

@@ -124,7 +124,7 @@ m4_define([b4_rhs_data],
# -------------------------------------------------- # --------------------------------------------------
# Expansion of $$ or $<TYPE>$, for symbol SYMBOL-NUM. # Expansion of $$ or $<TYPE>$, for symbol SYMBOL-NUM.
m4_define([b4_rhs_value], m4_define([b4_rhs_value],
[b4_symbol_value([b4_rhs_data([$1], [$2]).yysemantics.yysval], [$3], [$4])]) [b4_symbol_value([b4_rhs_data([$1], [$2]).yysemantics.yyval], [$3], [$4])])
@@ -502,7 +502,7 @@ struct yyGLRState
{ {
/** Type tag: always true. */ /** Type tag: always true. */
yybool yyisState; yybool yyisState;
/** Type tag for yysemantics. If true, yysval applies, otherwise /** Type tag for yysemantics. If true, yyval applies, otherwise
* yyfirstVal applies. */ * yyfirstVal applies. */
yybool yyresolved; yybool yyresolved;
/** Number of corresponding LALR(1) machine state. */ /** Number of corresponding LALR(1) machine state. */
@@ -517,7 +517,7 @@ struct yyGLRState
* yynext. */ * yynext. */
yySemanticOption* yyfirstVal; yySemanticOption* yyfirstVal;
/** Semantic value for this state. */ /** Semantic value for this state. */
YYSTYPE yysval; YYSTYPE yyval;
} yysemantics;]b4_locations_if([[ } yysemantics;]b4_locations_if([[
/** Source location for this state. */ /** Source location for this state. */
YYLTYPE yyloc;]])[ YYLTYPE yyloc;]])[
@@ -796,9 +796,9 @@ yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
#endif #endif
yyvsp[i].yystate.yyresolved = s->yyresolved; yyvsp[i].yystate.yyresolved = s->yyresolved;
if (s->yyresolved) if (s->yyresolved)
yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval; yyvsp[i].yystate.yysemantics.yyval = s->yysemantics.yyval;
else else
/* The effect of using yysval or yyloc (in an immediate rule) is /* The effect of using yyval or yyloc (in an immediate rule) is
* undefined. */ * undefined. */
yyvsp[i].yystate.yysemantics.yyfirstVal = YY_NULLPTR;]b4_locations_if([[ yyvsp[i].yystate.yysemantics.yyfirstVal = YY_NULLPTR;]b4_locations_if([[
yyvsp[i].yystate.yyloc = s->yyloc;]])[ yyvsp[i].yystate.yyloc = s->yyloc;]])[
@@ -904,7 +904,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
if (yyrhslen == 0) if (yyrhslen == 0)
*yyvalp = yyval_default; *yyvalp = yyval_default;
else else
*yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;]b4_locations_if([[ *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yyval;]b4_locations_if([[
/* Default location. */ /* Default location. */
YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen); YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
yystackp->yyerror_range[1].yystate.yyloc = *yylocp; yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
@@ -970,7 +970,7 @@ yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[)
{ {
if (yys->yyresolved) if (yys->yyresolved)
yydestruct (yymsg, yy_accessing_symbol (yys->yylrState), yydestruct (yymsg, yy_accessing_symbol (yys->yylrState),
&yys->yysemantics.yysval]b4_locuser_args([&yys->yyloc])[); &yys->yysemantics.yyval]b4_locuser_args([&yys->yyloc])[);
else else
{ {
#if ]b4_api_PREFIX[DEBUG #if ]b4_api_PREFIX[DEBUG
@@ -1345,7 +1345,7 @@ yyglrShift (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yy_state_t yylrState,
yynewState->yyposn = yyposn; yynewState->yyposn = yyposn;
yynewState->yyresolved = yytrue; yynewState->yyresolved = yytrue;
yynewState->yypred = yystackp->yytops.yystates[yyk]; yynewState->yypred = yystackp->yytops.yystates[yyk];
yynewState->yysemantics.yysval = *yyvalp;]b4_locations_if([ yynewState->yysemantics.yyval = *yyvalp;]b4_locations_if([
yynewState->yyloc = *yylocp;])[ yynewState->yyloc = *yylocp;])[
yystackp->yytops.yystates[yyk] = yynewState; yystackp->yytops.yystates[yyk] = yynewState;
@@ -1403,7 +1403,7 @@ yy_reduce_print (yybool yynormal, yyGLRStackItem* yyvsp, YYPTRDIFF_T yyk,
YY_FPRINTF ((stderr, " $%d = ", yyi + 1)); YY_FPRINTF ((stderr, " $%d = ", yyi + 1));
yy_symbol_print (stderr, yy_symbol_print (stderr,
yy_accessing_symbol (yyvsp[yyi - yynrhs + 1].yystate.yylrState), yy_accessing_symbol (yyvsp[yyi - yynrhs + 1].yystate.yylrState),
&yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yysval]b4_locations_if([, &yyvsp[yyi - yynrhs + 1].yystate.yysemantics.yyval]b4_locations_if([,
&]b4_rhs_location(yynrhs, yyi + 1))[]dnl &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
b4_user_args[); b4_user_args[);
if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved) if (!yyvsp[yyi - yynrhs + 1].yystate.yyresolved)
@@ -1479,21 +1479,21 @@ yyglrReduce (yyGLRStack* yystackp, YYPTRDIFF_T yyk, yyRuleNum yyrule,
if (yyforceEval || yystackp->yysplitPoint == YY_NULLPTR) if (yyforceEval || yystackp->yysplitPoint == YY_NULLPTR)
{ {
YYSTYPE yysval;]b4_locations_if([[ YYSTYPE yyval;]b4_locations_if([[
YYLTYPE yyloc;]])[ YYLTYPE yyloc;]])[
YYRESULTTAG yyflag = yydoAction (yystackp, yyk, yyrule, &yysval]b4_locuser_args([&yyloc])[); YYRESULTTAG yyflag = yydoAction (yystackp, yyk, yyrule, &yyval]b4_locuser_args([&yyloc])[);
if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULLPTR) if (yyflag == yyerr && yystackp->yysplitPoint != YY_NULLPTR)
YY_DPRINTF ((stderr, YY_DPRINTF ((stderr,
"Parse on stack %ld rejected by rule %d (line %d).\n", "Parse on stack %ld rejected by rule %d (line %d).\n",
YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule])); YY_CAST (long, yyk), yyrule - 1, yyrline[yyrule]));
if (yyflag != yyok) if (yyflag != yyok)
return yyflag; return yyflag;
YY_SYMBOL_PRINT ("-> $$ =", yylhsNonterm (yyrule), &yysval, &yyloc); YY_SYMBOL_PRINT ("-> $$ =", yylhsNonterm (yyrule), &yyval, &yyloc);
yyglrShift (yystackp, yyk, yyglrShift (yystackp, yyk,
yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState, yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
yylhsNonterm (yyrule)), yylhsNonterm (yyrule)),
yyposn, &yysval]b4_locations_if([, &yyloc])[); yyposn, &yyval]b4_locations_if([, &yyloc])[);
} }
else else
{ {
@@ -1624,12 +1624,12 @@ yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
else if (yys0->yyresolved) else if (yys0->yyresolved)
{ {
yys1->yyresolved = yytrue; yys1->yyresolved = yytrue;
yys1->yysemantics.yysval = yys0->yysemantics.yysval; yys1->yysemantics.yyval = yys0->yysemantics.yyval;
} }
else if (yys1->yyresolved) else if (yys1->yyresolved)
{ {
yys0->yyresolved = yytrue; yys0->yyresolved = yytrue;
yys0->yysemantics.yysval = yys1->yysemantics.yysval; yys0->yysemantics.yyval = yys1->yysemantics.yyval;
} }
else else
{ {
@@ -1875,7 +1875,7 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
yySemanticOption* yybest = yyoptionList; yySemanticOption* yybest = yyoptionList;
yySemanticOption** yypp; yySemanticOption** yypp;
yybool yymerge = yyfalse; yybool yymerge = yyfalse;
YYSTYPE yysval; YYSTYPE yyval;
YYRESULTTAG yyflag;]b4_locations_if([ YYRESULTTAG yyflag;]b4_locations_if([
YYLTYPE *yylocp = &yys->yyloc;])[ YYLTYPE *yylocp = &yys->yyloc;])[
@@ -1919,33 +1919,33 @@ yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
{ {
yySemanticOption* yyp; yySemanticOption* yyp;
int yyprec = yydprec[yybest->yyrule]; int yyprec = yydprec[yybest->yyrule];
yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args[); yyflag = yyresolveAction (yybest, yystackp, &yyval]b4_locuser_args[);
if (yyflag == yyok) if (yyflag == yyok)
for (yyp = yybest->yynext; yyp != YY_NULLPTR; yyp = yyp->yynext) for (yyp = yybest->yynext; yyp != YY_NULLPTR; yyp = yyp->yynext)
{ {
if (yyprec == yydprec[yyp->yyrule]) if (yyprec == yydprec[yyp->yyrule])
{ {
YYSTYPE yysval_other;]b4_locations_if([ YYSTYPE yyval_other;]b4_locations_if([
YYLTYPE yydummy;])[ YYLTYPE yydummy;])[
yyflag = yyresolveAction (yyp, yystackp, &yysval_other]b4_locuser_args([&yydummy])[); yyflag = yyresolveAction (yyp, yystackp, &yyval_other]b4_locuser_args([&yydummy])[);
if (yyflag != yyok) if (yyflag != yyok)
{ {
yydestruct ("Cleanup: discarding incompletely merged value for", yydestruct ("Cleanup: discarding incompletely merged value for",
yy_accessing_symbol (yys->yylrState), yy_accessing_symbol (yys->yylrState),
&yysval]b4_locuser_args[); &yyval]b4_locuser_args[);
break; break;
} }
yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); yyuserMerge (yymerger[yyp->yyrule], &yyval, &yyval_other);
} }
} }
} }
else else
yyflag = yyresolveAction (yybest, yystackp, &yysval]b4_locuser_args([yylocp])[); yyflag = yyresolveAction (yybest, yystackp, &yyval]b4_locuser_args([yylocp])[);
if (yyflag == yyok) if (yyflag == yyok)
{ {
yys->yyresolved = yytrue; yys->yyresolved = yytrue;
yys->yysemantics.yysval = yysval; yys->yysemantics.yyval = yyval;
} }
else else
yys->yysemantics.yyfirstVal = YY_NULLPTR; yys->yysemantics.yyfirstVal = YY_NULLPTR;

44
data/skeletons/glr2.cc
View File

@@ -741,7 +741,7 @@ public:
, yylrState (lrState) , yylrState (lrState)
, yyposn (posn) , yyposn (posn)
, yypred (0) , yypred (0)
, yysval (sval)]b4_locations_if([[ , yyval (sval)]b4_locations_if([[
, yyloc (loc)]])[]b4_parse_assert_if([[ , yyloc (loc)]])[]b4_parse_assert_if([[
, magic_ (MAGIC)]])[ , magic_ (MAGIC)]])[
{} {}
@@ -767,7 +767,7 @@ public:
{ {
setPred (other.pred ()); setPred (other.pred ());
if (other.yyresolved) if (other.yyresolved)
new (&yysval) value_type (other.value ()); new (&yyval) value_type (other.value ());
else else
setFirstVal (other.firstVal ());]b4_parse_assert_if([[ setFirstVal (other.firstVal ());]b4_parse_assert_if([[
check_();]])[ check_();]])[
@@ -778,7 +778,7 @@ public:
check_ (); check_ ();
magic_ = 0;]])[ magic_ = 0;]])[
if (yyresolved) if (yyresolved)
yysval.~value_type (); yyval.~value_type ();
} }
glr_state& operator= (const glr_state& other) glr_state& operator= (const glr_state& other)
@@ -786,7 +786,7 @@ public:
check_ (); check_ ();
other.check_ ();]])[ other.check_ ();]])[
if (!yyresolved && other.yyresolved) if (!yyresolved && other.yyresolved)
new (&yysval) value_type; new (&yyval) value_type;
yyresolved = other.yyresolved; yyresolved = other.yyresolved;
yylrState = other.yylrState; yylrState = other.yylrState;
yyposn = other.yyposn; yyposn = other.yyposn;
@@ -799,7 +799,7 @@ public:
return *this; return *this;
} }
/** Type tag for the semantic value. If true, yysval applies, otherwise /** Type tag for the semantic value. If true, yyval applies, otherwise
* yyfirstVal applies. */ * yyfirstVal applies. */
bool yyresolved; bool yyresolved;
/** Number of corresponding LALR(1) machine state. */ /** Number of corresponding LALR(1) machine state. */
@@ -821,13 +821,13 @@ public:
value_type& value () value_type& value ()
{]b4_parse_assert_if([[ {]b4_parse_assert_if([[
check_ ();]])[ check_ ();]])[
return yysval; return yyval;
} }
const value_type& value () const const value_type& value () const
{]b4_parse_assert_if([[ {]b4_parse_assert_if([[
check_ ();]])[ check_ ();]])[
return yysval; return yyval;
} }
void void
@@ -888,7 +888,7 @@ private:
* yyfirstVal. */ * yyfirstVal. */
std::ptrdiff_t yyfirstVal; std::ptrdiff_t yyfirstVal;
/** Semantic value for this state. */ /** Semantic value for this state. */
value_type yysval; value_type yyval;
};]b4_locations_if([[ };]b4_locations_if([[
// FIXME: Why public? // FIXME: Why public?
public: public:
@@ -1702,7 +1702,7 @@ public:
if (s->yyresolved) if (s->yyresolved)
new (&yys.value ()) value_type (s->value ()); new (&yys.value ()) value_type (s->value ());
else else
/* The effect of using yysval or yyloc (in an immediate /* The effect of using yyval or yyloc (in an immediate
* rule) is undefined. */ * rule) is undefined. */
yys.setFirstVal (YY_NULLPTR);]b4_locations_if([[ yys.setFirstVal (YY_NULLPTR);]b4_locations_if([[
yys.yyloc = s->yyloc;]])[ yys.yyloc = s->yyloc;]])[
@@ -2409,10 +2409,10 @@ public:
if (yyforceEval || !yystateStack.isSplit()) if (yyforceEval || !yystateStack.isSplit())
{ {
value_type yysval;]b4_locations_if([[ value_type val;]b4_locations_if([[
location_type loc;]])[ location_type loc;]])[
YYRESULTTAG yyflag = yydoAction (yyk, yyrule, &yysval]b4_locations_if([, &loc])[); YYRESULTTAG yyflag = yydoAction (yyk, yyrule, &val]b4_locations_if([, &loc])[);
if (yyflag == yyerr && yystateStack.isSplit()) if (yyflag == yyerr && yystateStack.isSplit())
{]b4_parse_trace_if([[ {]b4_parse_trace_if([[
YYCDEBUG << "Parse on stack " << yyk.get () YYCDEBUG << "Parse on stack " << yyk.get ()
@@ -2421,11 +2421,11 @@ public:
]])[} ]])[}
if (yyflag != yyok) if (yyflag != yyok)
return yyflag; return yyflag;
YY_SYMBOL_PRINT ("-> $$ =", static_cast<yysymbol_kind_t>(yyr1[yyrule]), &yysval, &loc); YY_SYMBOL_PRINT ("-> $$ =", static_cast<yysymbol_kind_t>(yyr1[yyrule]), &val, &loc);
yyglrShift (yyk, yyglrShift (yyk,
yyLRgotoState (topState(yyk)->yylrState, yyLRgotoState (topState(yyk)->yylrState,
yylhsNonterm (yyrule)), yylhsNonterm (yyrule)),
yyposn, yysval]b4_locations_if([, loc])[); yyposn, val]b4_locations_if([, loc])[);
} }
else else
{ {
@@ -2582,7 +2582,7 @@ private:
semantic_option* yybest = yys.firstVal(); semantic_option* yybest = yys.firstVal();
YYASSERT(yybest != YY_NULLPTR); YYASSERT(yybest != YY_NULLPTR);
bool yymerge = false; bool yymerge = false;
value_type yysval; value_type val;
YYRESULTTAG yyflag;]b4_locations_if([ YYRESULTTAG yyflag;]b4_locations_if([
location_type *yylocp = &yys.yyloc;])[ location_type *yylocp = &yys.yyloc;])[
@@ -2627,7 +2627,7 @@ private:
if (yymerge) if (yymerge)
{ {
int yyprec = yydprec[yybest->yyrule]; int yyprec = yydprec[yybest->yyrule];
yyflag = yyresolveAction (*yybest, &yysval]b4_locations_if([, yylocp])[); yyflag = yyresolveAction (*yybest, &val]b4_locations_if([, yylocp])[);
if (yyflag == yyok) if (yyflag == yyok)
for (semantic_option* yyp = yybest->next(); for (semantic_option* yyp = yybest->next();
yyp != YY_NULLPTR; yyp != YY_NULLPTR;
@@ -2635,28 +2635,28 @@ private:
{ {
if (yyprec == yydprec[yyp->yyrule]) if (yyprec == yydprec[yyp->yyrule])
{ {
value_type yysval_other;]b4_locations_if([ value_type yyval_other;]b4_locations_if([
location_type yydummy;])[ location_type yydummy;])[
yyflag = yyresolveAction (*yyp, &yysval_other]b4_locations_if([, &yydummy])[); yyflag = yyresolveAction (*yyp, &yyval_other]b4_locations_if([, &yydummy])[);
if (yyflag != yyok) if (yyflag != yyok)
{ {
yyparser.yy_destroy_ ("Cleanup: discarding incompletely merged value for", yyparser.yy_destroy_ ("Cleanup: discarding incompletely merged value for",
yy_accessing_symbol(yys.yylrState), yy_accessing_symbol(yys.yylrState),
&yysval]b4_locations_if([, yylocp])[); &yyval]b4_locations_if([, yylocp])[);
break; break;
} }
yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other); yyuserMerge (yymerger[yyp->yyrule], &val, &yyval_other);
} }
} }
} }
else else
yyflag = yyresolveAction (*yybest, &yysval]b4_locations_if([, yylocp])[); yyflag = yyresolveAction (*yybest, &val]b4_locations_if([, yylocp])[);
if (yyflag == yyok) if (yyflag == yyok)
{ {
yys.yyresolved = true; yys.yyresolved = true;
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
new (&yys.value ()) value_type (yysval); new (&yys.value ()) value_type (val);
YY_IGNORE_MAYBE_UNINITIALIZED_END YY_IGNORE_MAYBE_UNINITIALIZED_END
} }
else else