diff --git a/exprtk.hpp b/exprtk.hpp
index a1d7366..9cd92ff 100644
--- a/exprtk.hpp
+++ b/exprtk.hpp
@@ -2256,7 +2256,9 @@
          inline void scan_token()
          {
             skip_whitespace();
+
             skip_comments();
+
             if (is_end(s_itr_))
             {
                return;
@@ -2391,14 +2393,20 @@
          {
             /*
                Attempt to match a valid numeric value in one of the following formats:
-               1. 123456
-               2. 123.456
-               3. 123.456e3
-               4. 123.456E3
-               5. 123.456e+3
-               6. 123.456E+3
-               7. 123.456e-3
-               8. 123.456E-3
+               01. 123456
+               02. 123.456
+               03. 123.456e3
+               04. 123.456E3
+               05. 123.456e+3
+               06. 123.456E+3
+               07. 123.456e-3
+               08. 123.456E-3
+               09. .1234
+               10. .1234e3
+               11. .1234E+3
+               12. .1234e+3
+               13. .1234E-3
+               14. .1234e-3
             */
             const char* initial_itr = s_itr_;
             bool dot_found          = false;
@@ -2825,30 +2833,27 @@
             return changes;
          }
 
-         inline virtual int insert(const token&, token& )
-         {
-            return -1;
-         }
+         #define token_inserter_empty_body \
+         {                                 \
+            return -1;                     \
+         }                                 \
+
+         inline virtual int insert(const token&, token&)
+         token_inserter_empty_body
 
          inline virtual int insert(const token&, const token&, token&)
-         {
-            return -1;
-         }
+         token_inserter_empty_body
 
          inline virtual int insert(const token&, const token&, const token&, token&)
-         {
-            return -1;
-         }
+         token_inserter_empty_body
 
          inline virtual int insert(const token&, const token&, const token&, const token&, token&)
-         {
-            return -1;
-         }
+         token_inserter_empty_body
 
          inline virtual int insert(const token&, const token&, const token&, const token&, const token&, token&)
-         {
-            return -1;
-         }
+         token_inserter_empty_body
+
+         #undef token_inserter_empty_body
 
       private:
 
@@ -2888,7 +2893,7 @@
 
             std::size_t changes = 0;
 
-            for (std::size_t i = 0; i < g.token_list_.size() - 1; ++i)
+            for (std::size_t i = 0; i < (g.token_list_.size() - 1); ++i)
             {
                token t;
 
@@ -2912,7 +2917,7 @@
 
             std::size_t changes = 0;
 
-            for (std::size_t i = 0; i < g.token_list_.size() - 2; ++i)
+            for (std::size_t i = 0; i < (g.token_list_.size() - 2); ++i)
             {
                token t;
 
@@ -3023,6 +3028,7 @@
                   t.type     = lexer::token::e_assign;
                   t.value    = ":=";
                   t.position = t0.position;
+
                   return true;
                }
                // '+ =' --> '+='
@@ -3031,6 +3037,7 @@
                   t.type     = lexer::token::e_addass;
                   t.value    = "+=";
                   t.position = t0.position;
+
                   return true;
                }
                // '- =' --> '-='
@@ -3039,6 +3046,7 @@
                   t.type     = lexer::token::e_subass;
                   t.value    = "-=";
                   t.position = t0.position;
+
                   return true;
                }
                // '* =' --> '*='
@@ -3047,6 +3055,7 @@
                   t.type     = lexer::token::e_mulass;
                   t.value    = "*=";
                   t.position = t0.position;
+
                   return true;
                }
                // '/ =' --> '/='
@@ -3055,6 +3064,7 @@
                   t.type     = lexer::token::e_divass;
                   t.value    = "/=";
                   t.position = t0.position;
+
                   return true;
                }
                // '% =' --> '%='
@@ -3063,6 +3073,7 @@
                   t.type     = lexer::token::e_modass;
                   t.value    = "%=";
                   t.position = t0.position;
+
                   return true;
                }
                // '> =' --> '>='
@@ -3071,6 +3082,7 @@
                   t.type     = lexer::token::e_gte;
                   t.value    = ">=";
                   t.position = t0.position;
+
                   return true;
                }
                // '< =' --> '<='
@@ -3079,6 +3091,7 @@
                   t.type     = lexer::token::e_lte;
                   t.value    = "<=";
                   t.position = t0.position;
+
                   return true;
                }
                // '= =' --> '=='
@@ -3087,6 +3100,7 @@
                   t.type     = lexer::token::e_eq;
                   t.value    = "==";
                   t.position = t0.position;
+
                   return true;
                }
                // '! =' --> '!='
@@ -3095,6 +3109,7 @@
                   t.type     = lexer::token::e_ne;
                   t.value    = "!=";
                   t.position = t0.position;
+
                   return true;
                }
                // '< >' --> '<>'
@@ -3103,6 +3118,7 @@
                   t.type     = lexer::token::e_ne;
                   t.value    = "<>";
                   t.position = t0.position;
+
                   return true;
                }
                // '<= >' --> '<=>'
@@ -3111,6 +3127,7 @@
                   t.type     = lexer::token::e_swap;
                   t.value    = "<=>";
                   t.position = t0.position;
+
                   return true;
                }
                // '+ -' --> '-'
@@ -3119,6 +3136,7 @@
                   t.type     = lexer::token::e_sub;
                   t.value    = "-";
                   t.position = t0.position;
+
                   return true;
                }
                // '- +' --> '-'
@@ -3127,6 +3145,7 @@
                   t.type     = lexer::token::e_sub;
                   t.value    = "-";
                   t.position = t0.position;
+
                   return true;
                }
                // '- -' --> '-'
@@ -3139,6 +3158,7 @@
                   t.type     = lexer::token::e_add;
                   t.value    = "+";
                   t.position = t0.position;
+
                   return true;
                }
                else
@@ -3221,14 +3241,14 @@
                   {
                      if (stack_.empty())
                      {
-                        state_ = false;
+                        state_       = false;
                         error_token_ = t;
 
                         return false;
                      }
                      else if (c != stack_.top().first)
                      {
-                        state_ = false;
+                        state_       = false;
                         error_token_ = t;
 
                         return false;
@@ -3558,6 +3578,7 @@
                }
 
                token_scanner_list.push_back(scanner);
+
                return true;
             }
 
@@ -3571,6 +3592,7 @@
                }
 
                token_modifier_list.push_back(modifier);
+
                return true;
             }
 
@@ -3584,6 +3606,7 @@
                }
 
                token_joiner_list.push_back(joiner);
+
                return true;
             }
 
@@ -3597,13 +3620,13 @@
                }
 
                token_inserter_list.push_back(inserter);
+
                return true;
             }
 
             inline bool run_modifiers(lexer::generator& g)
             {
                error_token_modifier = reinterpret_cast<lexer::token_modifier*>(0);
-               bool result = true;
 
                for (std::size_t i = 0; i < token_modifier_list.size(); ++i)
                {
@@ -3615,17 +3638,17 @@
                   if (!modifier.result())
                   {
                      error_token_modifier = token_modifier_list[i];
+
                      return false;
                   }
                }
 
-               return result;
+               return true;
             }
 
             inline bool run_joiners(lexer::generator& g)
             {
                error_token_joiner = reinterpret_cast<lexer::token_joiner*>(0);
-               bool result = true;
 
                for (std::size_t i = 0; i < token_joiner_list.size(); ++i)
                {
@@ -3637,17 +3660,17 @@
                   if (!joiner.result())
                   {
                      error_token_joiner = token_joiner_list[i];
+
                      return false;
                   }
                }
 
-               return result;
+               return true;
             }
 
             inline bool run_inserters(lexer::generator& g)
             {
                error_token_inserter = reinterpret_cast<lexer::token_inserter*>(0);
-               bool result = true;
 
                for (std::size_t i = 0; i < token_inserter_list.size(); ++i)
                {
@@ -3659,17 +3682,17 @@
                   if (!inserter.result())
                   {
                      error_token_inserter = token_inserter_list[i];
+
                      return false;
                   }
                }
 
-               return result;
+               return true;
             }
 
             inline bool run_scanners(lexer::generator& g)
             {
                error_token_scanner = reinterpret_cast<lexer::token_scanner*>(0);
-               bool result = true;
 
                for (std::size_t i = 0; i < token_scanner_list.size(); ++i)
                {
@@ -3681,11 +3704,12 @@
                   if (!scanner.result())
                   {
                      error_token_scanner = token_scanner_list[i];
+
                      return false;
                   }
                }
 
-               return result;
+               return true;
             }
 
             std::vector<lexer::token_scanner*>  token_scanner_list;
@@ -14235,120 +14259,85 @@
       virtual ~ifunction()
       {}
 
+      #define empty_method_body                      \
+      {                                              \
+         return std::numeric_limits<T>::quiet_NaN(); \
+      }                                              \
+
       inline virtual T operator()()
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&,const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&, const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
 
       inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&,
                                   const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&)
-      {
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      empty_method_body
+
+      #undef empty_method_body
 
       std::size_t param_count;
    };
@@ -14391,33 +14380,27 @@
       virtual ~igeneric_function()
       {}
 
+      #define igeneric_function_empty_body(N)        \
+      {                                              \
+         exprtk_debug(("igeneric_function::operator() - Operator has not been overridden. ["#N"]\n")); \
+         return std::numeric_limits<T>::quiet_NaN(); \
+      }                                              \
+
       // f(i_0,i_1,....,i_N) --> Scalar
       inline virtual T operator()(parameter_list_t)
-      {
-         exprtk_debug(("igeneric_function::operator() - Operator has not been overridden. [1]\n"));
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      igeneric_function_empty_body(1)
 
       // f(i_0,i_1,....,i_N) --> String
       inline virtual T operator()(std::string&, parameter_list_t)
-      {
-         exprtk_debug(("igeneric_function::operator() - Operator has not been overridden. [2]\n"));
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      igeneric_function_empty_body(2)
 
       // f(psi,i_0,i_1,....,i_N) --> Scalar
       inline virtual T operator()(const std::size_t&, parameter_list_t)
-      {
-         exprtk_debug(("igeneric_function::operator() - Operator has not been overridden. [3]\n"));
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      igeneric_function_empty_body(3)
 
       // f(psi,i_0,i_1,....,i_N) --> String
       inline virtual T operator()(const std::size_t&, std::string&, parameter_list_t)
-      {
-         exprtk_debug(("igeneric_function::operator() - Operator has not been overridden. [4]\n"));
-         return std::numeric_limits<T>::quiet_NaN();
-      }
+      igeneric_function_empty_body(4)
 
       std::string parameter_sequence;
       return_type rtrn_type;
@@ -14436,6 +14419,7 @@
       typedef T (*ff3_functor)(T,T,T);
       typedef T (*ff4_functor)(T,T,T,T);
       typedef T (*ff5_functor)(T,T,T,T,T);
+      typedef T (*ff6_functor)(T,T,T,T,T,T);
 
    protected:
 
@@ -14479,6 +14463,14 @@
          ff5_functor f;
       };
 
+      struct freefunc6 : public exprtk::ifunction<T>
+      {
+         freefunc6(ff6_functor ff) : exprtk::ifunction<T>(6), f(ff) {}
+         inline T operator()(const T& v0, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5)
+         { return f(v0,v1,v2,v3,v4,v5); }
+         ff5_functor f;
+      };
+
       template <typename Type, typename RawType>
       struct type_store
       {
@@ -14762,6 +14754,7 @@
             static RawType null_type = init_type::set(RawType());
 
             tm_const_itr_t itr = map.find(symbol_name);
+
             if (map.end() == itr)
                return null_type;
             else
@@ -15372,6 +15365,22 @@
          return add_function(function_name,(*local_data().free_function_list_.back()));
       }
 
+      inline bool add_function(const std::string& function_name, ff6_functor function)
+      {
+         if (!valid())
+            return false;
+         else if (!valid_symbol(function_name))
+            return false;
+         else if (symbol_exists(function_name))
+            return false;
+
+         exprtk::ifunction<T>* ifunc = new freefunc6(function);
+
+         local_data().free_function_list_.push_back(ifunc);
+
+         return add_function(function_name,(*local_data().free_function_list_.back()));
+      }
+
       inline bool add_reserved_function(const std::string& function_name, function_t& function)
       {
          if (!valid())
@@ -25968,6 +25977,7 @@
                   if (synthesize_sf4ext_expression::template compile_left<vtype>(expr_gen,v,operation,branch[0],result))
                   {
                      free_node(*expr_gen.node_allocator_,branch[0]);
+
                      return result;
                   }
                }
@@ -26247,6 +26257,7 @@
                      if (details::e_pow == boc_opr)
                      {
                         bocnode->set_c(bocnode->c() * c);
+
                         return bocnode;
                      }
                   }
@@ -26362,6 +26373,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
                                        (cobnode->c() / c,cobnode->move_branch(0));
+
                         free_node(*expr_gen.node_allocator_,branch[0]);
                      }
                   }
@@ -26415,6 +26427,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::cob_node<Type,details::sub_op<Type> > >
                                        (c - cobnode->c(),cobnode->move_branch(0));
+
                         free_node(*expr_gen.node_allocator_,branch[1]);
                      }
                   }
@@ -26430,6 +26443,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::cob_node<Type,details::add_op<Type> > >
                                        (c - cobnode->c(),cobnode->move_branch(0));
+
                         free_node(*expr_gen.node_allocator_,branch[1]);
                      }
                   }
@@ -26445,6 +26459,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
                                        (c / cobnode->c(),cobnode->move_branch(0));
+
                         free_node(*expr_gen.node_allocator_,branch[1]);
                      }
                   }
@@ -26460,6 +26475,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::cob_node<Type,details::mul_op<Type> > >
                                        (c / cobnode->c(),cobnode->move_branch(0));
+
                         free_node(*expr_gen.node_allocator_,branch[1]);
                      }
                   }
@@ -26517,6 +26533,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::boc_node<Type,details::add_op<Type> > >
                                        (bocnode->move_branch(0),c - bocnode->c());
+
                         free_node(*expr_gen.node_allocator_,branch[0]);
                      }
                      else if (details::e_sub == operation)
@@ -26561,6 +26578,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::cob_node<Type,details::sub_op<Type> > >
                                        (c - bocnode->c(),bocnode->move_branch(0));
+
                         free_node(*expr_gen.node_allocator_,branch[1]);
                      }
                   }
@@ -26571,6 +26589,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::boc_node<Type,details::add_op<Type> > >
                                        (bocnode->move_branch(0),c - bocnode->c());
+
                         free_node(*expr_gen.node_allocator_,branch[1]);
                      }
                      else if (details::e_sub == operation)
@@ -26578,6 +26597,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::cob_node<Type,details::sub_op<Type> > >
                                        (c + bocnode->c(),bocnode->move_branch(0));
+
                         free_node(*expr_gen.node_allocator_,branch[1]);
                      }
                   }
@@ -26593,6 +26613,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
                                        (c / bocnode->c(),bocnode->move_branch(0));
+
                         free_node(*expr_gen.node_allocator_,branch[1]);
                      }
                   }
@@ -26608,6 +26629,7 @@
                         result = expr_gen.node_allocator_->
                                     template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > >
                                        (c * bocnode->c(),bocnode->move_branch(0));
+
                         free_node(*expr_gen.node_allocator_,branch[1]);
                      }
                   }
@@ -32504,66 +32526,71 @@
       virtual ~polynomial()
       {}
 
+      #define poly_rtrn(NN) \
+      return (NN != N) ? std::numeric_limits<T>::quiet_NaN() :
+
       inline virtual T operator()(const T& x, const T& c1, const T& c0)
       {
-         return ((1 == N) ? poly_impl<T,1>::evaluate(x,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(1) poly_impl<T,1>::evaluate(x,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c2, const T& c1, const T& c0)
       {
-         return ((2 == N) ? poly_impl<T,2>::evaluate(x,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(2) poly_impl<T,2>::evaluate(x,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((3 == N) ? poly_impl<T,3>::evaluate(x,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(3) poly_impl<T,3>::evaluate(x,c3,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((4 == N) ? poly_impl<T,4>::evaluate(x,c4,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(4) poly_impl<T,4>::evaluate(x,c4,c3,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((5 == N) ? poly_impl<T,5>::evaluate(x,c5,c4,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(5) poly_impl<T,5>::evaluate(x,c5,c4,c3,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((6 == N) ? poly_impl<T,6>::evaluate(x,c6,c5,c4,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(6) poly_impl<T,6>::evaluate(x,c6,c5,c4,c3,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((7 == N) ? poly_impl<T,7>::evaluate(x,c7,c6,c5,c4,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(7) poly_impl<T,7>::evaluate(x,c7,c6,c5,c4,c3,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((8 == N) ? poly_impl<T,8>::evaluate(x,c8,c7,c6,c5,c4,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(8) poly_impl<T,8>::evaluate(x,c8,c7,c6,c5,c4,c3,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c9, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((9 == N) ? poly_impl<T,9>::evaluate(x,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(9) poly_impl<T,9>::evaluate(x,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c10, const T& c9, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((10 == N) ? poly_impl<T,10>::evaluate(x,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(10) poly_impl<T,10>::evaluate(x,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c11, const T& c10, const T& c9, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((11 == N) ? poly_impl<T,11>::evaluate(x,c11,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(11) poly_impl<T,11>::evaluate(x,c11,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0);
       }
 
       inline virtual T operator()(const T& x, const T& c12, const T& c11, const T& c10, const T& c9, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0)
       {
-         return ((12 == N) ? poly_impl<T,12>::evaluate(x,c12,c11,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0) : std::numeric_limits<T>::quiet_NaN());
+         poly_rtrn(12) poly_impl<T,12>::evaluate(x,c12,c11,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0);
       }
 
+      #undef poly_rtrn
+
       inline virtual T operator()()
       {
          return std::numeric_limits<T>::quiet_NaN();
@@ -32645,6 +32672,19 @@
             v_.push_back(v2); v_.push_back(v3);
          }
 
+         function(const std::string& name,
+                  const std::string& expression,
+                  const std::string& v0, const std::string& v1,
+                  const std::string& v2, const std::string& v3,
+                  const std::string& v4)
+         : name_(name),
+           expression_(expression)
+         {
+            v_.push_back(v0); v_.push_back(v1);
+            v_.push_back(v2); v_.push_back(v3);
+            v_.push_back(v4);
+         }
+
          inline function& name(const std::string& n)
          {
             name_ = n;
@@ -32672,12 +32712,12 @@
 
       struct base_func : public exprtk::ifunction<T>
       {
-         typedef const T& type;
-         typedef exprtk::ifunction<T> function_t;
-         typedef std::vector<T*> varref_t;
-         typedef std::vector<T> var_t;
+         typedef const T&                       type;
+         typedef exprtk::ifunction<T>     function_t;
+         typedef std::vector<T*>            varref_t;
+         typedef std::vector<T>                var_t;
          typedef std::pair<T*,std::size_t> lvarref_t;
-         typedef std::vector<lvarref_t> lvr_vec_t;
+         typedef std::vector<lvarref_t>    lvr_vec_t;
 
          base_func(const std::size_t& pc = 0)
          : exprtk::ifunction<T>(pc),
@@ -32893,16 +32933,30 @@
 
       typedef const T& type;
 
+      template <typename BaseFuncType>
+      struct scoped_bft
+      {
+         scoped_bft(BaseFuncType& bft) : bft_(bft) { bft_.pre (); }
+        ~scoped_bft()                              { bft_.post(); }
+
+         BaseFuncType& bft_;
+
+      private:
+
+         scoped_bft(scoped_bft&);
+         scoped_bft& operator=(scoped_bft&);
+      };
+
       struct func_1param : public base_func
       {
          func_1param() : base_func(1) {}
 
          inline T operator()(type v0)
          {
-            base_func::pre();
+            scoped_bft<func_1param> sb(*this);
             base_func::update(v0);
             T result = this->value(base_func::expression);
-            base_func::post();
+
             return result;
          }
       };
@@ -32913,10 +32967,10 @@
 
          inline T operator()(type v0, type v1)
          {
-            base_func::pre();
+            scoped_bft<func_2param> sb(*this);
             base_func::update(v0,v1);
             T result = this->value(base_func::expression);
-            base_func::post();
+
             return result;
          }
       };
@@ -32927,10 +32981,10 @@
 
          inline T operator()(type v0, type v1, type v2)
          {
-            base_func::pre();
+            scoped_bft<func_3param> sb(*this);
             base_func::update(v0,v1,v2);
             T result = this->value(base_func::expression);
-            base_func::post();
+
             return result;
          }
       };
@@ -32941,10 +32995,10 @@
 
          inline T operator()(type v0, type v1, type v2, type v3)
          {
-            base_func::pre();
+            scoped_bft<func_4param> sb(*this);
             base_func::update(v0,v1,v2,v3);
             T result = this->value(base_func::expression);
-            base_func::post();
+
             return result;
          }
       };
@@ -32955,10 +33009,10 @@
 
          inline T operator()(type v0, type v1, type v2, type v3, type v4)
          {
-            base_func::pre();
+            scoped_bft<func_5param> sb(*this);
             base_func::update(v0,v1,v2,v3,v4);
             T result = this->value(base_func::expression);
-            base_func::post();
+
             return result;
          }
       };
@@ -32969,10 +33023,10 @@
 
          inline T operator()(type v0, type v1, type v2, type v3, type v4, type v5)
          {
-            base_func::pre();
+            scoped_bft<func_6param> sb(*this);
             base_func::update(v0,v1,v2,v3,v4,v5);
             T result = this->value(base_func::expression);
-            base_func::post();
+
             return result;
          }
       };
@@ -33040,6 +33094,7 @@
          if (compile_expression(name,expression,var_list))
          {
             fp_map_[n][name]->setup(expr_map_[name]);
+
             return true;
          }
          else
diff --git a/readme.txt b/readme.txt
index 224da97..24f542b 100644
--- a/readme.txt
+++ b/readme.txt
@@ -94,6 +94,7 @@
 
   (a) Download:   http://www.partow.net/programming/exprtk/index.html
   (b) Repository: https://github.com/ArashPartow/exprtk
+                  https://github.com/ArashPartow/exprtk-extras
 
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -240,7 +241,7 @@
 | ceil     | Smallest integer that is greater than or equal to x.    |
 +----------+---------------------------------------------------------+
 | clamp    | Clamp x in range between r0 and r1, where r0 < r1.      |
-|          | (eg: clamp(r0,x,r1)                                     |
+|          | (eg: clamp(r0,x,r1))                                    |
 +----------+---------------------------------------------------------+
 | equal    | Equality test between x and y using normalized epsilon  |
 +----------+---------------------------------------------------------+
@@ -762,12 +763,12 @@
  Variable(z)            [Multiplication]
                 ____________/      \___________
                /                               \
-              /                          [Unary-Func(sin)]
+              /                      [Unary-Function(sin)]
          [Addition]                            |
       ____/      \____                    [Division]
      /                \                 ___/      \___
  Variable(x)   [Exponentiation]        /              \
-              ______/   \______  Constant(pi)  [Binary-Func(min)]
+              ______/   \______  Constant(pi) [Binary-Function(min)]
              /                 \                ____/    \____
         Variable(y)        [Negation]          /              \
                                |              /           Variable(v)
@@ -801,6 +802,118 @@
 and  its  location  within  the  input  provided  by  the  'get_error'
 interface.
 
+
+Note: The exprtk::expression  and exprtk::symbol_table components  are
+reference counted entities. Copy constructing or assigning to or  from
+either component will result in  a shallow copy and a  reference count
+increment,  rather  than  a  complete  replication.  Furthermore   the
+expression  and symbol_table  components being  Default-Constructible,
+Copy-Constructible  and  Copy-Assignable  make  them  compatible  with
+various  C++  standard  library   containers  and  adaptors  such   as
+std::vector, std::map, std::stack etc.
+
+The following is  an example of  two unique expressions,  after having
+being instantiated and  compiled, one expression  is  assigned to  the
+other. The diagrams depict  their initial and post  assignment states,
+including  which  control  block each  expression references and their
+associated reference counts.
+
+
+  exprtk::expression e0; // constructed expression, eg: x + 1
+  exprtk::expression e1; // constructed expression, eg: 2z + y
+
+  +-----[ e0 cntrl block]----+     +-----[ e1 cntrl block]-----+
+  | 1. Expression Node 'x+1' |     | 1. Expression Node '2z+y' |
+  | 2. Ref Count: 1          |<-+  | 2. Ref Count: 1           |<-+
+  +--------------------------+  |  +---------------------------+  |
+                                |                                 |
+    +--[ e0 expression]--+      |    +--[ e1 expression]--+       |
+    | 1. Reference to    ]------+    | 1. Reference to    ]-------+
+    | e0 Control Block   |           | e1 Control Block   |
+    +--------------------+           +--------------------+
+
+
+  e0 = e1; // e0 and e1 are now 2z+y
+
+               +-----[ e1 cntrl block]-----+
+               | 1. Expression Node '2z+y' |
+  +----------->| 2. Ref Count: 2           |<----------+
+  |            +---------------------------+           |
+  |                                                    |
+  |   +--[ e0 expression]--+  +--[ e1 expression]--+   |
+  +---[ 1. Reference to    |  | 1. Reference to    ]---+
+      | e1 Control Block   |  | e1 Control Block   |
+      +--------------------+  +--------------------+
+
+The reason for  the above complexity  and restrictions of  deep copies
+for the expression and symbol_table components is because  expressions
+may include user defined variables or functions. These are embedded as
+references into the expression's AST. When copying an expression, said
+references  need to  also  be  copied. if  the references  are blindly
+copied,  then it  will  result  in two  or more  identical expressions
+utilizing the exact same  references for variables. This  obviously is
+not the  default assumed  scenario and  will give  rise to non-obvious
+behaviours  when  using the  expressions in  various contexts such  as
+muli-threading et al.
+
+The prescribed method for cloning an expression is to compile it  from
+its string form. Doing so will allow the one to properly consider  the
+exact source of user defined variables and functions.
+
+Note:  The  exprtk::parser  is  a  non-copyable  and  non-thread  safe
+component, and should only be shared via either a reference, a  shared
+pointer  or  a  std::ref  mechanism,  and  considerations  relating to
+synchronisation  taken  into  account  where  appropriate.  The parser
+represents an object factory,  specifically a factory of  expressions,
+and generally should  not be instantiated  solely on a  per expression
+compilation basis.
+
+The  following  diagram  and  example depicts  the  flow  of  data and
+operations  for  compiling  multiple expressions  via  the  parser and
+inserting  the  newly  minted  exprtk::expression  instances  into   a
+std::vector.
+
+
+                        +--[exprtk::parser]--+
+                        | expression factory |
+                     +---->- compile(....) ->---+
+                     |  +--------------------+  |
+  Expressions        |                          |   Expressions as
+  in string form     A                          V   exprtk::expression
+                     |                          |   instances
+  [s0:'x+1'     ]-+  |                          |   +-[e0: x+1]
+                  |  |                          |   |
+  [s1:'2z+y']-----+--+                          +-->+-[e1: 2z+y]
+                  |                                 |
+  [s2:'sin(k+w)']-+                                 +-[e2: sin(k+w)]
+
+
+   const std::string expression_str[3]
+                       = { "x + 1", "2x + y", "sin(k + w)" };
+
+   std::vector<expression_t> expression_list;
+
+   parser_t             parser;
+   expression_t     expression;
+   symbol_table_t symbol_table;
+
+   expression.register_symbol_table(symbol_table);
+
+   for (std::size_t i = 0; i < 3; ++i)
+   {
+      if (parser.compile(expression_str[i],expression))
+      {
+         expression_list.push_back(expression);
+      }
+      else
+        std::cout << "Error in " << expression_str[i] << "\n";
+   }
+
+   for (auto e : expression_list)
+   {
+      e.value();
+   }
+
      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 [11 - COMPILATION OPTIONS]
@@ -1060,9 +1173,9 @@
 
 
 (3) String Definition
-Strings are a sequence of  8-bit characters. They can only  be defined
-with an explicit initialisation  value. The following are  examples of
-string variable definitions:
+Strings are sequences comprised of 8-bit characters. They can only be
+defined  with an explicit  initialisation  value. The  following  are
+examples of string variable definitions:
 
    (a) Initialise to a string
        var x := 'abc';
@@ -1096,6 +1209,9 @@
 will be returned. Where as for vectors, the value of the first element
 (eg: v[0]) will be returned.
 
+   8 == ((var x := 7;) + 1)
+   4 == (var y[3] := {4, 5, 6};)
+
 
 (5) Variable/Vector Assignment
 The value of a variable can be assigned to a vector and a vector or  a
@@ -1700,7 +1816,7 @@
    {
       foo() : exprtk::ifunction<T>(3)
       {
-          exprtk::disable_has_side_effects(*this);
+         exprtk::disable_has_side_effects(*this);
       }
 
       T operator()(const T& v1, const T& v2, const T& v3)