news: restructure, document variants for C++

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index 7ebc3149e0efa367b7a2a00270c1ecdba0838354..eb4883559a414287500ee6bfb3ac01f5b9c524e3 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -206,8 +206,9 @@ b4_location_define])])[
 
     /// Generate an error message.
     /// \param yystate   the state where the error occurred.
-    /// \param yytoken   the lookahead token.
-    virtual std::string yysyntax_error_ (state_type yystate, int yytoken);
+    /// \param yytoken   the lookahead token type, or yyempty_.
+    virtual std::string yysyntax_error_ (state_type yystate,
+                                         symbol_number_type yytoken) const;
 
     /// Compute post-reduction state.
     /// \param yystate   the current state
@@ -222,8 +223,6 @@ b4_location_define])])[
     /// \param yyvalue   the value to check
     static bool yy_table_value_is_error_ (int yyvalue);
 
-    /// Internal symbol numbers.
-    typedef ]b4_int_type_for([b4_translate])[ token_number_type;
     static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
     static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
 
@@ -255,8 +254,7 @@ b4_location_define])])[
     /// \param yyo    The output stream.
     /// \param yysym  The symbol.
     template <typename Base>
-    void yy_print_ (std::ostream& yyo,
-                    const basic_symbol<Base>& yysym) const;
+    void yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const;
 #endif
 
     /// \brief Reclaim the memory associated to a symbol.
@@ -273,23 +271,26 @@ b4_location_define])])[
       /// Default constructor.
       by_state ();
 
+      /// The symbol type as needed by the constructor.
+      typedef state_type kind_type;
+
       /// Constructor.
-      by_state (state_type s);
+      by_state (kind_type s);
 
       /// Copy constructor.
       by_state (const by_state& other);
 
+      /// Steal the symbol type from \a that.
       void move (by_state& that);
 
-      /// The state.
-      state_type state;
+      /// The (internal) type number (corresponding to \a state).
+      /// "empty" when empty.
+      symbol_number_type type_get () const;
 
-      /// The type (corresponding to \a state).
-      /// -1 when empty.
-      int type_get () const;
+      enum { empty = 0 };
 
-      /// The type used to store the symbol type.
-      typedef state_type value_type;
+      /// The state.
+      state_type state;
     };
 
     /// "Internal" symbol: element of the stack.
@@ -524,7 +525,7 @@ m4_if(b4_prefix, [yy], [],
   // by_state.
   inline
   ]b4_parser_class_name[::by_state::by_state ()
-    : state (-1)
+    : state (empty)
   {}
 
   inline
@@ -537,7 +538,7 @@ m4_if(b4_prefix, [yy], [],
   ]b4_parser_class_name[::by_state::move (by_state& that)
   {
     state = that.state;
-    that.state = -1;
+    that.state = empty;
   }
 
   inline
@@ -546,10 +547,10 @@ m4_if(b4_prefix, [yy], [],
   {}
 
   inline
-  int
+  ]b4_parser_class_name[::symbol_number_type
   ]b4_parser_class_name[::by_state::type_get () const
   {
-    return state == -1 ? -1 : yystos_[state];
+    return state == empty ? 0 : yystos_[state];
   }
 
   inline
@@ -558,22 +559,24 @@ m4_if(b4_prefix, [yy], [],
 
 
   inline
-  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s, symbol_type& sym)
-    : super_type (s]b4_locations_if([, sym.location])[)
-  {]b4_variant_if([[
-    ]b4_symbol_variant([sym.type_get ()], [value], [move], [sym.value])],
-    [value = sym.value;])[
-    // sym is emptied.
-    sym.type = -1;
+  ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s, symbol_type& that)
+    : super_type (s]b4_locations_if([, that.location])[)
+  {
+    ]b4_variant_if([b4_symbol_variant([that.type_get ()],
+                                      [value], [move], [that.value])],
+                   [[value = that.value;]])[
+    // that is emptied.
+    that.type = empty;
   }
 
   inline
   ]b4_parser_class_name[::stack_symbol_type&
   ]b4_parser_class_name[::stack_symbol_type::operator= (const stack_symbol_type& that)
   {
-    state = that.state;]b4_variant_if([[
-    ]b4_symbol_variant([that.type_get ()], [value], [copy], [that.value])],
-    [value = that.value;])[]b4_locations_if([
+    state = that.state;
+    ]b4_variant_if([b4_symbol_variant([that.type_get ()],
+                                      [value], [copy], [that.value])],
+                   [[value = that.value;]])[]b4_locations_if([
     location = that.location;])[
     return *this;
   }
@@ -588,7 +591,7 @@ m4_if(b4_prefix, [yy], [],
       YY_SYMBOL_PRINT (yymsg, yysym);]b4_variant_if([], [
 
     // User destructor.
-    int yytype = yysym.type_get ();
+    symbol_number_type yytype = yysym.type_get ();
     switch (yytype)
       {
 ]b4_symbol_foreach([b4_symbol_destructor])dnl
@@ -605,7 +608,7 @@ m4_if(b4_prefix, [yy], [],
   {
     std::ostream& yyoutput = yyo;
     YYUSE (yyoutput);
-    int yytype = yysym.type_get ();
+    symbol_number_type yytype = yysym.type_get ();
     yyo << (yytype < yyntokens_ ? "token" : "nterm")
         << ' ' << yytname_[yytype] << " ("]b4_locations_if([
         << yysym.location << ": "])[;
@@ -776,8 +779,8 @@ b4_dollar_popdef])[]dnl
 
     /* If the proper action on seeing token YYLA.TYPE is to reduce or
        to detect an error, take that action.  */
-    yyn += yyla.type;
-    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type)
+    yyn += yyla.type_get ();
+    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type_get ())
       goto yydefault;
 
     // Reduce or error.
@@ -873,7 +876,7 @@ b4_dollar_popdef])[]dnl
         ++yynerrs_;
         error (]b4_join(b4_locations_if([yyla.location]),
                         [[yysyntax_error_ (yystack_[0].state,
-                                           yyempty ? yyempty_ : yyla.type)]])[);
+                                           yyempty ? yyempty_ : yyla.type_get ())]])[);
       }
 
 ]b4_locations_if([[
@@ -884,7 +887,7 @@ b4_dollar_popdef])[]dnl
            error, discard it.  */
 
         // Return failure if at end of input.
-        if (yyla.type == yyeof_)
+        if (yyla.type_get () == yyeof_)
           YYABORT;
         else if (!yyempty)
           {
@@ -1010,8 +1013,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, int yytoken],
-                    [int, int])[)
+b4_error_verbose_if([state_type yystate, symbol_number_type yytoken],
+                    [state_type, symbol_number_type])[) const
   {]b4_error_verbose_if([[
     std::string yyres;
     // Number of reported tokens (one for the "unexpected", one per