From b20e797a712293b4c62912d3295648885bd1d9cf Mon Sep 17 00:00:00 2001 From: Theophile Ranquet Date: Mon, 28 Jan 2013 17:41:31 +0100 Subject: [PATCH] c++: better inline expansion 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, where 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 + inline ]b4_parser_class_name[::basic_symbol::basic_symbol () : value () {} template + inline ]b4_parser_class_name[::basic_symbol::basic_symbol (const basic_symbol& other) : Base (other) , value ()]b4_locations_if([ @@ -267,6 +269,7 @@ m4_define([b4_public_types_define], template + inline ]b4_parser_class_name[::basic_symbol::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 + inline ]b4_parser_class_name[::basic_symbol::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 + inline void ]b4_parser_class_name[::basic_symbol::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 - inline void yy_destroy_ (const char* yymsg, - basic_symbol& yysym) const; + void yy_destroy_ (const char* yymsg, basic_symbol& 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 + inline void ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, basic_symbol& 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) { -- 2.7.4