[PATCH] c++: better inline expansion

[Theophile Ranquet]

Many 'inline' keywords were in the declarations.  They rather belong in
definitions, so move them.

* data/c++.m4 (basic_symbol, by_type): Many inlines here.
* data/lalr1.cc (yytranslate_, yy_destroy_, by_state, yypush_, yypop_): Inline
these as well.
(move): Move the definition outside the struct, were it belongs.
---
 data/c++.m4   | 39 +++++++++++++++++++++++++--------------
 data/lalr1.cc | 42 ++++++++++++++++++++++++++----------------
 2 files changed, 51 insertions(+), 30 deletions(-)

diff --git a/data/c++.m4 b/data/c++.m4
index 6950360..fcfda23 100644
--- a/data/c++.m4
+++ b/data/c++.m4
@@ -170,24 +170,24 @@ m4_define([b4_public_types_declare],
       typedef Base super_type;
 
       /// Default constructor.
-      inline basic_symbol ();
+      basic_symbol ();
 
       /// Copy constructor.
-      inline basic_symbol (const basic_symbol& other);
+      basic_symbol (const basic_symbol& other);
 
       /// Constructor for valueless symbols.
-      inline basic_symbol (typename Base::value_type t]b4_locations_if([,
-                           const location_type& l])[);
+      basic_symbol (typename Base::value_type t]b4_locations_if([,
+                    const location_type& l])[);
 
       /// Constructor for symbols with semantic value.
-      inline basic_symbol (typename Base::value_type t,
-                           const semantic_type& v]b4_locations_if([,
-                           const location_type& l])[);
+      basic_symbol (typename Base::value_type t,
+                    const semantic_type& v]b4_locations_if([,
+                    const location_type& l])[);
 
       ~basic_symbol ();
 
       /// Destructive move, \a s is emptied into this.
-      inline void move (basic_symbol& s);
+      void move (basic_symbol& s);
 
       /// The semantic value.
       semantic_type value;]b4_locations_if([
@@ -204,13 +204,14 @@ m4_define([b4_public_types_declare],
     struct by_type
     {
       /// Default constructor.
-      inline by_type ();
+      by_type ();
 
       /// Copy constructor.
-      inline by_type (const by_type& other);
+      by_type (const by_type& other);
 
       /// Constructor.
-      inline by_type (token_type t);
+      ///
+      by_type (token_type t);
 
       /// Steal the type of \a that.
       void move (by_type& that);
@@ -221,12 +222,11 @@ m4_define([b4_public_types_declare],
       int type;
 
       /// The type (corresponding to \a type).
-      ///
       /// -1 when this symbol is empty.
-      inline int type_get () const;
+      int type_get () const;
 
       /// The token.
-      inline token_type token () const;
+      token_type token () const;
 
       /// The type used to store the symbol type.
       typedef token_type value_type;
@@ -250,11 +250,13 @@ m4_define([b4_public_types_define],
 
   // basic_symbol.
   template <typename Base>
+  inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol ()
     : value ()
   {}
 
   template <typename Base>
+  inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (const 
basic_symbol& other)
     : Base (other)
     , value ()]b4_locations_if([
@@ -267,6 +269,7 @@ m4_define([b4_public_types_define],
 
 
   template <typename Base>
+  inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
           [typename Base::value_type t],
           [const semantic_type& v],
@@ -279,6 +282,7 @@ m4_define([b4_public_types_define],
     ]b4_symbol_variant([this->type_get ()], [value], [copy], [v])])[}
 
   template <typename Base>
+  inline
   ]b4_parser_class_name[::basic_symbol<Base>::basic_symbol (]b4_join(
           [typename Base::value_type t],
           b4_locations_if([const location_type& l]))[)
@@ -305,6 +309,7 @@ m4_define([b4_public_types_define],
   }
 
   template <typename Base>
+  inline
   void
   ]b4_parser_class_name[::basic_symbol<Base>::move (basic_symbol& s)
   {
@@ -316,14 +321,17 @@ m4_define([b4_public_types_define],
   }
 
   // by_type.
+  inline
   ]b4_parser_class_name[::by_type::by_type ()
      : type (-1)
   {}
 
+  inline
   ]b4_parser_class_name[::by_type::by_type (const by_type& other)
     : type (other.type)
   {}
 
+  inline
   ]b4_parser_class_name[::by_type::by_type (token_type t)
     : type (yytranslate_ (t))
   {}
@@ -336,12 +344,14 @@ m4_define([b4_public_types_define],
     that.type = -1;
   }
 
+  inline
   int
   ]b4_parser_class_name[::by_type::type_get () const
   {
     return type;
   }
 ]b4_token_ctor_if([[
+  inline
   ]b4_parser_class_name[::token_type
   ]b4_parser_class_name[::by_type::token () const
   {
@@ -374,6 +384,7 @@ m4_define([b4_symbol_constructor_define], [])
 # sometimes in the cc file.
 m4_define([b4_yytranslate_define],
 [[  // Symbol number corresponding to token number t.
+  inline
   ]b4_parser_class_name[::token_number_type
   ]b4_parser_class_name[::yytranslate_ (]b4_token_ctor_if([token_type],
                                                           [int])[ t)
diff --git a/data/lalr1.cc b/data/lalr1.cc
index cac4260..7ebc314 100644
--- a/data/lalr1.cc
+++ b/data/lalr1.cc
@@ -228,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([
@@ -264,35 +264,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;
@@ -322,7 +316,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 +324,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 +522,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
   {
@@ -574,6 +580,7 @@ m4_if(b4_prefix, [yy], [],
 
 
   template <typename Base>
+  inline
   void
   ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, basic_symbol<Base>& 
yysym) const
   {
@@ -612,6 +619,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 +627,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 +636,7 @@ m4_if(b4_prefix, [yy], [],
     yystack_.push (s);
   }
 
+  inline
   void
   ]b4_parser_class_name[::yypop_ (unsigned int n)
   {
-- 
1.8.1.1