c++: style changes

[bison.git] / data / lalr1.cc

diff --git a/data/lalr1.cc b/data/lalr1.cc
index 5a05db768aa2ef89df32f4e1c1470a9d2630259c..24156030c922f62faf882f529674e500eac1edd2 100644 (file)
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -146,7 +146,6 @@ b4_variant_if([m4_include(b4_pkgdatadir/[variant.hh])])
 m4_define([b4_shared_declarations],
 [b4_percent_code_get([[requires]])[
 ]b4_parse_assert_if([# include <cassert>])[
-# include <cstdlib>  // abort
 # include <vector>
 # include <iostream>
 # include <stdexcept>
@@ -229,7 +228,7 @@ b4_location_define])])[
     static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
 
     /// Convert a scanner token number \a t to a symbol number.
-    static inline token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t);
+    static token_number_type yytranslate_ (]b4_token_ctor_if([token_type], [int])[ t);
 
     // Tables.
 ]b4_parser_tables_declare[]b4_error_verbose_if([
@@ -256,8 +255,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.
@@ -265,35 +263,29 @@ b4_location_define])])[
     ///                  If null, print nothing.
     /// \param s         The symbol.
     template <typename Base>
-    inline void yy_destroy_ (const char* yymsg,
-                             basic_symbol<Base>& yysym) const;
+    void yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const;
 
   private:
     /// Type access provider for state based symbols.
     struct by_state
     {
       /// Default constructor.
-      inline by_state ();
+      by_state ();
 
       /// Constructor.
-      inline by_state (state_type s);
+      by_state (state_type s);
 
       /// Copy constructor.
-      inline by_state (const by_state& other);
+      by_state (const by_state& other);
 
-      void move (by_state& that)
-      {
-        state = that.state;
-        that.state = -1;
-      }
+      void move (by_state& that);
 
       /// The state.
       state_type state;
 
       /// The type (corresponding to \a state).
-      ///
       /// -1 when empty.
-      inline int type_get () const;
+      int type_get () const;
 
       /// The type used to store the symbol type.
       typedef state_type value_type;
@@ -308,6 +300,7 @@ b4_location_define])])[
       stack_symbol_type ();
       /// Steal the contents from \a sym to build this.
       stack_symbol_type (state_type s, symbol_type& sym);
+      /// Assignment, needed by push_back.
       stack_symbol_type& operator= (const stack_symbol_type& that);
     };
 
@@ -322,7 +315,7 @@ b4_location_define])])[
     ///             if null, no trace is output.
     /// \param s    the symbol
     /// \warning the contents of \a s.value is stolen.
-    inline void yypush_ (const char* m, stack_symbol_type& s);
+    void yypush_ (const char* m, stack_symbol_type& s);
 
     /// Push a new look ahead token on the state on the stack.
     /// \param m    a debug message to display
@@ -330,10 +323,10 @@ b4_location_define])])[
     /// \param s    the state
     /// \param sym  the symbol (for its value and location).
     /// \warning the contents of \a s.value is stolen.
-    inline void yypush_ (const char* m, state_type s, symbol_type& sym);
+    void yypush_ (const char* m, state_type s, symbol_type& sym);
 
     /// Pop \a n symbols the three stacks.
-    inline void yypop_ (unsigned int n = 1);
+    void yypop_ (unsigned int n = 1);
 
     // Constants.
     enum
@@ -528,18 +521,30 @@ m4_if(b4_prefix, [yy], [],
 ]b4_token_ctor_if([], [b4_public_types_define])[
 
   // by_state.
+  inline
   ]b4_parser_class_name[::by_state::by_state ()
     : state (-1)
   {}
 
+  inline
   ]b4_parser_class_name[::by_state::by_state (const by_state& other)
     : state (other.state)
   {}
 
+  inline
+  void
+  ]b4_parser_class_name[::by_state::move (by_state& that)
+  {
+    state = that.state;
+    that.state = -1;
+  }
+
+  inline
   ]b4_parser_class_name[::by_state::by_state (state_type s)
     : state (s)
   {}
 
+  inline
   int
   ]b4_parser_class_name[::by_state::type_get () const
   {
@@ -552,28 +557,31 @@ 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 = -1;
   }
 
   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;
   }
 
 
   template <typename Base>
+  inline
   void
   ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
   {
@@ -612,6 +620,7 @@ m4_if(b4_prefix, [yy], [],
   }
 #endif
 
+  inline
   void
   ]b4_parser_class_name[::yypush_ (const char* m, state_type s, symbol_type& sym)
   {
@@ -619,6 +628,7 @@ m4_if(b4_prefix, [yy], [],
     yypush_ (m, t);
   }
 
+  inline
   void
   ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s)
   {
@@ -627,6 +637,7 @@ m4_if(b4_prefix, [yy], [],
     yystack_.push (s);
   }
 
+  inline
   void
   ]b4_parser_class_name[::yypop_ (unsigned int n)
   {