[PATCH 5/6] c++: symbols can be empty, so use it

[Akim Demaille]

The previous patches ensure that symbols (symbol_type and
stack_symbol_type) can be empty, cleared, and their emptiness can be
checked.  Therefore, yyempty, which codes whether yyla is empty or
not, is now useless.

In C skeletons (e.g., yacc.c), the fact that the lookahead is empty is
coded by "yychar = YYEMPTY", which is exactly what this patch
restores, since yychar/yytoken corresponds to yyla.type.

* data/lalr1.cc (yyempty): Remove.
Rather, depend on yyla.empty ().
---
 data/lalr1.cc | 34 +++++++++++++---------------------
 1 file changed, 13 insertions(+), 21 deletions(-)

diff --git a/data/lalr1.cc b/data/lalr1.cc
index d3ab008..0e0e17a 100644
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -214,9 +214,9 @@ b4_location_define])])[
 
     /// Generate an error message.
     /// \param yystate   the state where the error occurred.
-    /// \param yytoken   the lookahead token type, or empty_symbol.
+    /// \param yyla      the lookahead token.
     virtual std::string yysyntax_error_ (state_type yystate,
-                                         symbol_number_type yytoken) const;
+                                         const symbol_type& yyla) const;
 
     /// Compute post-reduction state.
     /// \param yystate   the current state
@@ -468,7 +468,7 @@ m4_if(b4_prefix, [yy], [],
 #endif // !]b4_api_PREFIX[DEBUG
 
 #define yyerrok         (yyerrstatus_ = 0)
-#define yyclearin       (yyempty = true)
+#define yyclearin       (yyla.clear ())
 
 #define YYACCEPT        goto yyacceptlab
 #define YYABORT         goto yyabortlab
@@ -715,9 +715,6 @@ m4_if(b4_prefix, [yy], [],
     int yynerrs_ = 0;
     int yyerrstatus_ = 0;
 
-    /// Whether yyla contains a lookahead.
-    bool yyempty = true;
-
     /// The lookahead symbol.
     symbol_type yyla;]b4_locations_if([[
 
@@ -765,7 +762,7 @@ b4_dollar_popdef])[]dnl
       goto yydefault;
 
     // Read a lookahead token.
-    if (yyempty)
+    if (yyla.empty ())
       {
         YYCDEBUG << "Reading a token: ";
         try
@@ -779,7 +776,6 @@ b4_dollar_popdef])[]dnl
             error (yyexc);
             goto yyerrlab1;
           }
-        yyempty = false;
       }
     YY_SYMBOL_PRINT ("Next token is", yyla);
 
@@ -799,9 +795,6 @@ b4_dollar_popdef])[]dnl
         goto yyreduce;
       }
 
-    // Discard the token being shifted.
-    yyempty = true;
-
     // Count tokens shifted since error; after three, turn off error status.
     if (yyerrstatus_)
       --yyerrstatus_;
@@ -884,8 +877,7 @@ b4_dollar_popdef])[]dnl
       {
         ++yynerrs_;
         error (]b4_join(b4_locations_if([yyla.location]),
-                        [[yysyntax_error_ (yystack_[0].state,
-                                           yyempty ? empty_symbol : 
yyla.type_get ())]])[);
+                        [[yysyntax_error_ (yystack_[0].state, yyla)]])[);
       }
 
 ]b4_locations_if([[
@@ -898,11 +890,10 @@ b4_dollar_popdef])[]dnl
         // Return failure if at end of input.
         if (yyla.type_get () == yyeof_)
           YYABORT;
-        else if (!yyempty)
+        else if (!yyla.empty ())
           {
             yy_destroy_ ("Error: discarding", yyla);
             yyla.clear ();
-            yyempty = true;
           }
       }
 
@@ -978,7 +969,7 @@ b4_dollar_popdef])[]dnl
     goto yyreturn;
 
   yyreturn:
-    if (!yyempty)
+    if (!yyla.empty ())
       yy_destroy_ ("Cleanup: discarding lookahead", yyla);
 
     /* Do not reclaim the symbols of the rule whose action triggered
@@ -998,7 +989,7 @@ b4_dollar_popdef])[]dnl
                  << std::endl;
         // Do not try to display the values of the reclaimed symbols,
         // as their printer might throw an exception.
-        if (!yyempty)
+        if (!yyla.empty ())
           yy_destroy_ (YY_NULLPTR, yyla);
 
         while (1 < yystack_.size ())
@@ -1020,8 +1011,8 @@ b4_dollar_popdef])[]dnl
   // Generate an error message.
   std::string
   ]b4_parser_class_name[::yysyntax_error_ (]dnl
-b4_error_verbose_if([state_type yystate, symbol_number_type yytoken],
-                    [state_type, symbol_number_type])[) const
+b4_error_verbose_if([state_type yystate, const symbol_type& yyla],
+                    [state_type, const symbol_type&])[) const
   {]b4_error_verbose_if([[
     // Number of reported tokens (one for the "unexpected", one per
     // "expected").
@@ -1036,7 +1027,7 @@ b4_error_verbose_if([state_type yystate, 
symbol_number_type yytoken],
          the only way this function was invoked is if the default action
          is an error action.  In that case, don't check for expected
          tokens because there are none.
-       - The only way there can be no lookahead present (in yytoken) is
+       - The only way there can be no lookahead present (in yyla) is
          if this state is a consistent state with a default action.
          Thus, detecting the absence of a lookahead is sufficient to
          determine that there is no unexpected or expected token to
@@ -1056,8 +1047,9 @@ b4_error_verbose_if([state_type yystate, 
symbol_number_type yytoken],
          token that will not be accepted due to an error action in a
          later state.
     */
-    if (yytoken != empty_symbol)
+    if (!yyla.empty ())
       {
+        int yytoken = yyla.type_get ();
         yyarg[yycount++] = yytname_[yytoken];
         int yyn = yypact_[yystate];
         if (!yy_pact_value_is_default_ (yyn))
-- 
2.2.1