diff --git a/exprtk.hpp b/exprtk.hpp
index b11c6a9..3d4ada1 100644
--- a/exprtk.hpp
+++ b/exprtk.hpp
@@ -221,7 +221,7 @@
          if (('0' <= h) && (h <= '9'))
             return (h - '0');
          else
-            return (std::toupper(h) - 'A');
+            return static_cast<unsigned char>(std::toupper(h) - 'A');
       }
 
       template <typename Iterator>
@@ -410,6 +410,30 @@
 
       static const std::size_t cntrl_struct_list_size = sizeof(cntrl_struct_list) / sizeof(std::string);
 
+      static const std::string arithmetic_ops_list[] =
+                                  {
+                                    "+", "-", "*", "/", "%",  "^"
+                                  };
+
+      static const std::size_t arithmetic_ops_list_size = sizeof(arithmetic_ops_list) / sizeof(std::string);
+
+      static const std::string assignment_ops_list[] =
+                                  {
+                                    ":=", "+=", "-=",
+                                    "*=", "/=", "%="
+                                  };
+
+      static const std::size_t assignment_ops_list_size = sizeof(assignment_ops_list) / sizeof(std::string);
+
+      static const std::string inequality_ops_list[] =
+                                  {
+                                     "<",  "<=", "==",
+                                     "=",  "!=", "<>",
+                                    ">=",  ">"
+                                  };
+
+      static const std::size_t inequality_ops_list_size = sizeof(inequality_ops_list) / sizeof(std::string);
+
       inline bool is_reserved_word(const std::string& symbol)
       {
          for (std::size_t i = 0; i < reserved_words_size; ++i)
@@ -594,12 +618,12 @@
          {
             if ('*' == (*p_itr))
             {
-               const char target = std::toupper(*(p_itr - 1));
+               const char target = static_cast<char>(std::toupper(*(p_itr - 1)));
 
                if ('*' == target)
                {
                   diff_index = std::distance(str.begin(),s_itr);
-                  diff_value = std::toupper(*p_itr);
+                  diff_value = static_cast<char>(std::toupper(*p_itr));
 
                   return false;
                }
@@ -622,7 +646,7 @@
                     )
             {
                diff_index = std::distance(str.begin(),s_itr);
-               diff_value = std::toupper(*p_itr);
+               diff_value = static_cast<char>(std::toupper(*p_itr));
 
                return false;
             }
@@ -3078,6 +3102,34 @@
                   t.position = t0.position;
                   return true;
                }
+               // '+ -' --> '-'
+               else if ((t0.type == lexer::token::e_add) && (t1.type == lexer::token::e_sub))
+               {
+                  t.type     = lexer::token::e_sub;
+                  t.value    = "-";
+                  t.position = t0.position;
+                  return true;
+               }
+               // '- +' --> '-'
+               else if ((t0.type == lexer::token::e_sub) && (t1.type == lexer::token::e_add))
+               {
+                  t.type     = lexer::token::e_sub;
+                  t.value    = "-";
+                  t.position = t0.position;
+                  return true;
+               }
+               // '- -' --> '-'
+               else if ((t0.type == lexer::token::e_sub) && (t1.type == lexer::token::e_sub))
+               {
+                  /*
+                     Note: May need to reconsider this when wanting to implement
+                     pre/postfix decrement operator
+                  */
+                  t.type     = lexer::token::e_add;
+                  t.value    = "+";
+                  t.position = t0.position;
+                  return true;
+               }
                else
                   return false;
             }
@@ -4067,9 +4119,38 @@
          e_sf4ext44 = 2044, e_sf4ext45 = 2045, e_sf4ext46 = 2046, e_sf4ext47 = 2047,
          e_sf4ext48 = 2048, e_sf4ext49 = 2049, e_sf4ext50 = 2050, e_sf4ext51 = 2051,
          e_sf4ext52 = 2052, e_sf4ext53 = 2053, e_sf4ext54 = 2054, e_sf4ext55 = 2055,
-         e_sf4ext56 = 2056, e_sf4ext57 = 2057, e_sf4ext58 = 2058, e_sf4ext59 = 2059
+         e_sf4ext56 = 2056, e_sf4ext57 = 2057, e_sf4ext58 = 2058, e_sf4ext59 = 2059,
+         e_sf4ext60 = 2060
       };
 
+      std::string to_str(const operator_type opr)
+      {
+         switch (opr)
+         {
+            case e_add    : return  "+";
+            case e_sub    : return  "-";
+            case e_mul    : return  "*";
+            case e_div    : return  "/";
+            case e_mod    : return  "%";
+            case e_pow    : return  "^";
+            case e_assign : return ":=";
+            case e_addass : return "+=";
+            case e_subass : return "-=";
+            case e_mulass : return "*=";
+            case e_divass : return "/=";
+            case e_modass : return "%=";
+            case e_lt     : return  "<";
+            case e_lte    : return "<=";
+            case e_eq     : return "==";
+            case e_equal  : return  "=";
+            case e_ne     : return "!=";
+            case e_nequal : return "<>";
+            case e_gte    : return ">=";
+            case e_gt     : return  ">";
+            default       : return"N/A";
+         }
+      }
+
       struct base_operation_t
       {
          base_operation_t(const operator_type t, const unsigned int& np)
@@ -4792,6 +4873,9 @@
 
          typedef range_pack<T> range_t;
 
+         virtual ~range_interface()
+         {}
+
          virtual range_t& range_ref() = 0;
 
          virtual const range_t& range_ref() const = 0;
@@ -4804,6 +4888,9 @@
 
          typedef range_data_type<T> range_data_type_t;
 
+         virtual ~string_base_node()
+         {}
+
          virtual std::string str () const = 0;
 
          virtual const char* base() const = 0;
@@ -5976,6 +6063,9 @@
       {
       public:
 
+         virtual ~ivariable()
+         {}
+
          virtual T& ref() = 0;
          virtual const T& ref() const = 0;
       };
@@ -6276,10 +6366,13 @@
       public:
 
          typedef expression_node<T>* expression_ptr;
+         typedef vector_holder<T>    vector_holder_t;
+         typedef vector_holder_t*    vector_holder_ptr;
 
-         vector_elem_node(expression_ptr index, T* vector_base)
+         vector_elem_node(expression_ptr index, vector_holder_ptr vec_holder)
          : index_(index),
-           vector_base_(vector_base),
+           vec_holder_(vec_holder),
+           vector_base_((*vec_holder)[0]),
            index_deletable_(branch_deletable(index_))
          {}
 
@@ -6311,9 +6404,15 @@
             return expression_node<T>::e_vecelem;
          }
 
+         inline vector_holder_t& vec_holder()
+         {
+            return (*vec_holder_);
+         }
+
       private:
 
          expression_ptr index_;
+         vector_holder_ptr vec_holder_;
          T* vector_base_;
          bool index_deletable_;
       };
@@ -6473,7 +6572,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
                {
                   vec0_node_ptr_ = vi->vec();
                }
@@ -6483,7 +6582,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
                {
                   vec1_node_ptr_ = vi->vec();
                }
@@ -6493,6 +6592,7 @@
             {
                vec_size_ = std::min(vec0_node_ptr_->ref().size(),
                                     vec1_node_ptr_->ref().size());
+
                initialised_ = true;
             }
          }
@@ -6648,7 +6748,7 @@
            rp_(rp)
          {}
 
-        ~string_range_node()
+         virtual ~string_range_node()
          {
             rp_.free();
          }
@@ -7979,6 +8079,7 @@
       define_sfop4(ext57,((x - y) + (z - w)),"(t-t)+(t-t)")
       define_sfop4(ext58,((x - y) - (z - w)),"(t-t)-(t-t)")
       define_sfop4(ext59,((x / y) + (z * w)),"(t/t)+(t*t)")
+      define_sfop4(ext60,(((x * y) * z) / w),"((t*t)*t)/t")
 
       #undef define_sfop3
       #undef define_sfop4
@@ -8415,7 +8516,8 @@
          : binary_node<T>(opr,branch0,branch1),
            vec0_node_ptr_(0),
            vec1_node_ptr_(0),
-           vec_size_     (0)
+           vec_size_     (0),
+           initialised_(false)
          {
             if (is_vector_node(binary_node<T>::branch_[0].first))
             {
@@ -8430,7 +8532,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
                {
                   vec1_node_ptr_ = vi->vec();
                }
@@ -8440,6 +8542,8 @@
             {
                vec_size_ = std::min(vec0_node_ptr_->ref().size(),
                                     vec1_node_ptr_->ref().size());
+
+               initialised_ = true;
             }
          }
 
@@ -8447,7 +8551,7 @@
          {
             binary_node<T>::branch_[1].first->value();
 
-            if (vec0_node_ptr_ && vec1_node_ptr_)
+            if (initialised_)
             {
                vector_holder<T>& vec0 = vec0_node_ptr_->ref();
                vector_holder<T>& vec1 = vec1_node_ptr_->ref();
@@ -8488,6 +8592,7 @@
          vector_node<T>* vec0_node_ptr_;
          vector_node<T>* vec1_node_ptr_;
          std::size_t     vec_size_;
+         bool            initialised_;
       };
 
       template <typename T, typename Operation>
@@ -8642,12 +8747,13 @@
          typedef vector_node<T>*     vector_node_ptr;
 
          assignment_vecvec_op_node(const operator_type& opr,
-                                expression_ptr branch0,
-                                expression_ptr branch1)
+                                   expression_ptr branch0,
+                                   expression_ptr branch1)
          : binary_node<T>(opr,branch0,branch1),
            vec0_node_ptr_(0),
            vec1_node_ptr_(0),
-           vec_size_     (0)
+           vec_size_     (0),
+           initialised_(false)
          {
             if (is_vector_node(binary_node<T>::branch_[0].first))
             {
@@ -8662,7 +8768,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
                {
                   vec1_node_ptr_ = vi->vec();
                }
@@ -8672,12 +8778,14 @@
             {
                vec_size_ = std::min(vec0_node_ptr_->ref().size(),
                                     vec1_node_ptr_->ref().size());
+
+               initialised_ = true;
             }
          }
 
          inline T value() const
          {
-            if (vec0_node_ptr_ && vec1_node_ptr_)
+            if (initialised_)
             {
                binary_node<T>::branch_[0].first->value();
                binary_node<T>::branch_[1].first->value();
@@ -8723,6 +8831,7 @@
          vector_node<T>* vec0_node_ptr_;
          vector_node<T>* vec1_node_ptr_;
          std::size_t     vec_size_;
+         bool            initialised_;
       };
 
       template <typename T, typename Operation>
@@ -8740,7 +8849,8 @@
          : binary_node<T>(opr,branch0,branch1),
            vec0_node_ptr_(0),
            vec1_node_ptr_(0),
-           vec_size_     (0)
+           vec_size_     (0),
+           initialised_(false)
          {
 
             if (is_vector_node(binary_node<T>::branch_[0].first))
@@ -8751,7 +8861,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
                {
                   vec0_node_ptr_ = vi->vec();
                }
@@ -8765,7 +8875,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
                {
                   vec1_node_ptr_ = vi->vec();
                }
@@ -8775,12 +8885,14 @@
             {
                vec_size_ = std::min(vec0_node_ptr_->ref().size(),
                                     vec1_node_ptr_->ref().size());
+
+               initialised_ = true;
             }
          }
 
          inline T value() const
          {
-            if (vec0_node_ptr_ && vec1_node_ptr_)
+            if (initialised_)
             {
                binary_node<T>::branch_[0].first->value();
                binary_node<T>::branch_[1].first->value();
@@ -8827,6 +8939,7 @@
          vector_node<T>* vec0_node_ptr_;
          vector_node<T>* vec1_node_ptr_;
          std::size_t     vec_size_;
+         bool            initialised_;
       };
 
       template <typename T, typename Operation>
@@ -8853,7 +8966,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
                {
                   vec_node_ptr_ = vi->vec();
                }
@@ -8938,7 +9051,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
                {
                   vec_node_ptr_ = vi->vec();
                }
@@ -9018,7 +9131,8 @@
            vec_size_     (0),
            data_         (0),
            temp_         (0),
-           temp_vec_node_(0)
+           temp_vec_node_(0),
+           initialised_(false)
          {
             if (is_vector_node(binary_node<T>::branch_[0].first))
             {
@@ -9028,7 +9142,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
                {
                   vec0_node_ptr_ = vi->vec();
                }
@@ -9042,7 +9156,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
                {
                   vec1_node_ptr_ = vi->vec();
                }
@@ -9057,6 +9171,8 @@
                data_          = new T[vec_size_];
                temp_          = new vector_holder<T>(data_,vec_size_);
                temp_vec_node_ = new vector_node<T>  (temp_);
+
+               initialised_ = true;
             }
          }
 
@@ -9069,7 +9185,7 @@
 
          inline T value() const
          {
-            if (vec0_node_ptr_ && vec1_node_ptr_)
+            if (initialised_)
             {
                binary_node<T>::branch_[0].first->value();
                binary_node<T>::branch_[1].first->value();
@@ -9122,6 +9238,7 @@
          T*                data_;
          vector_holder_ptr temp_;
          vector_node_ptr   temp_vec_node_;
+         bool              initialised_;
       };
 
       template <typename T, typename Operation>
@@ -9152,7 +9269,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))
                {
                   vec0_node_ptr_ = vi->vec();
                }
@@ -9257,7 +9374,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))
                {
                   vec1_node_ptr_ = vi->vec();
                }
@@ -9360,7 +9477,7 @@
             {
                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);
 
-               if ((vi = dynamic_cast<vector_interface<T>*>(unary_node<T>::branch_)))
+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(unary_node<T>::branch_)))
                {
                   vec0_node_ptr_ = vi->vec();
                }
@@ -9903,7 +10020,7 @@
            arg_list_(arg_list)
          {}
 
-        ~generic_function_node()
+         virtual ~generic_function_node()
          {
             cleanup_branches::execute(branch_);
          }
@@ -10260,6 +10377,9 @@
       {
       public:
 
+         virtual ~null_igenfunc()
+         {}
+
          typedef type_store<T> generic_type;
          typedef typename generic_type::parameter_list parameter_list_t;
 
@@ -11383,6 +11503,9 @@
       {
       public:
 
+         virtual ~vov_base_node()
+         {}
+
          inline virtual operator_type operation() const
          {
             return details::e_default;
@@ -11398,6 +11521,9 @@
       {
       public:
 
+       virtual ~cov_base_node()
+          {}
+
          inline virtual operator_type operation() const
          {
             return details::e_default;
@@ -11413,6 +11539,9 @@
       {
       public:
 
+         virtual ~voc_base_node()
+         {}
+
          inline virtual operator_type operation() const
          {
             return details::e_default;
@@ -11428,6 +11557,9 @@
       {
       public:
 
+         virtual ~vob_base_node()
+         {}
+
          virtual const T& v() const = 0;
       };
 
@@ -11436,6 +11568,9 @@
       {
       public:
 
+         virtual ~bov_base_node()
+         {}
+
          virtual const T& v() const = 0;
       };
 
@@ -11444,6 +11579,9 @@
       {
       public:
 
+       virtual ~cob_base_node()
+       {}
+
          inline virtual operator_type operation() const
          {
             return details::e_default;
@@ -11461,6 +11599,9 @@
       {
       public:
 
+         virtual ~boc_base_node()
+       {}
+
          inline virtual operator_type operation() const
          {
             return details::e_default;
@@ -11478,6 +11619,9 @@
       {
       public:
 
+         virtual ~uv_base_node()
+         {}
+
          inline virtual operator_type operation() const
          {
             return details::e_default;
@@ -11491,6 +11635,9 @@
       {
       public:
 
+         virtual ~sos_base_node()
+         {}
+
          inline virtual operator_type operation() const
          {
             return details::e_default;
@@ -11502,6 +11649,9 @@
       {
       public:
 
+         virtual ~sosos_base_node()
+         {}
+
          inline virtual operator_type operation() const
          {
             return details::e_default;
@@ -11513,6 +11663,9 @@
       {
       public:
 
+         virtual ~T0oT1oT2_base_node()
+         {}
+
          virtual std::string type_id() const = 0;
       };
 
@@ -11521,6 +11674,9 @@
       {
       public:
 
+         virtual ~T0oT1oT2oT3_base_node()
+         {}
+
          virtual std::string type_id() const = 0;
       };
 
@@ -12274,6 +12430,9 @@
       {
       public:
 
+         virtual ~sf3ext_type_node()
+         {}
+
          virtual T0 t0() const = 0;
 
          virtual T1 t1() const = 0;
@@ -13900,7 +14059,9 @@
 
       function_traits()
       : allow_zero_parameters_(false),
-        has_side_effects_(true)
+        has_side_effects_(true),
+        min_num_args_(0),
+        max_num_args_(std::numeric_limits<std::size_t>::max())
       {}
 
       inline bool& allow_zero_parameters()
@@ -13913,16 +14074,33 @@
          return has_side_effects_;
       }
 
+      std::size_t& min_num_args()
+      {
+         return min_num_args_;
+      }
+
+      std::size_t& max_num_args()
+      {
+         return max_num_args_;
+      }
+
    private:
 
       bool allow_zero_parameters_;
       bool has_side_effects_;
+      std::size_t min_num_args_;
+      std::size_t max_num_args_;
    };
 
    template <typename FunctionType>
    void enable_zero_parameters(FunctionType& func)
    {
       func.allow_zero_parameters() = true;
+
+      if (0 != func.min_num_args())
+      {
+         func.min_num_args() = 0;
+      }
    }
 
    template <typename FunctionType>
@@ -13943,6 +14121,21 @@
       func.has_side_effects() = false;
    }
 
+   template <typename FunctionType>
+   void set_min_num_args(FunctionType& func, const std::size_t& num_args)
+   {
+      func.min_num_args() = num_args;
+
+      if ((0 != func.min_num_args()) && func.allow_zero_parameters())
+         func.allow_zero_parameters() = false;
+   }
+
+   template <typename FunctionType>
+   void set_max_num_args(FunctionType& func, const std::size_t& num_args)
+   {
+      func.max_num_args() = num_args;
+   }
+
    template <typename T>
    class ifunction : public function_traits
    {
@@ -14093,18 +14286,25 @@
    {
    public:
 
+      enum return_type
+      {
+         e_rtrn_scalar = 0,
+         e_rtrn_string = 1
+      };
+
       typedef T type;
       typedef type_store<T> generic_type;
       typedef typename generic_type::parameter_list parameter_list_t;
 
-      igeneric_function(const std::string& param_seq = "")
-      : parameter_sequence(param_seq)
+      igeneric_function(const std::string& param_seq = "", const return_type rtr_type = e_rtrn_scalar)
+      : parameter_sequence(param_seq),
+        rtrn_type(rtr_type)
       {}
 
       virtual ~igeneric_function()
       {}
 
-      // f(i_0,i_1,....,i_N) --> Number
+      // 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"));
@@ -14118,7 +14318,7 @@
          return std::numeric_limits<T>::quiet_NaN();
       }
 
-      // f(psi,i_0,i_1,....,i_N) --> Number
+      // 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"));
@@ -14133,6 +14333,7 @@
       }
 
       std::string parameter_sequence;
+      return_type rtrn_type;
    };
 
    template <typename T> class parser;
@@ -14141,8 +14342,56 @@
    template <typename T>
    class symbol_table
    {
+   public:
+
+      typedef T (*ff1_functor)(T);
+      typedef T (*ff2_functor)(T,T);
+      typedef T (*ff3_functor)(T,T,T);
+      typedef T (*ff4_functor)(T,T,T,T);
+      typedef T (*ff5_functor)(T,T,T,T,T);
+
    protected:
 
+      struct freefunc1 : public exprtk::ifunction<T>
+      {
+         freefunc1(ff1_functor ff) : exprtk::ifunction<T>(1), f(ff) {}
+         inline T operator()(const T& v0)
+         { return f(v0); }
+         ff1_functor f;
+      };
+
+      struct freefunc2 : public exprtk::ifunction<T>
+      {
+         freefunc2(ff2_functor ff) : exprtk::ifunction<T>(2), f(ff) {}
+         inline T operator()(const T& v0, const T& v1)
+         { return f(v0,v1); }
+         ff2_functor f;
+      };
+
+      struct freefunc3 : public exprtk::ifunction<T>
+      {
+         freefunc3(ff3_functor ff) : exprtk::ifunction<T>(3), f(ff) {}
+         inline T operator()(const T& v0, const T& v1, const T& v2)
+         { return f(v0,v1,v2); }
+         ff3_functor f;
+      };
+
+      struct freefunc4 : public exprtk::ifunction<T>
+      {
+         freefunc4(ff4_functor ff) : exprtk::ifunction<T>(4), f(ff) {}
+         inline T operator()(const T& v0, const T& v1, const T& v2, const T& v3)
+         { return f(v0,v1,v2,v3); }
+         ff4_functor f;
+      };
+
+      struct freefunc5 : public exprtk::ifunction<T>
+      {
+         freefunc5(ff5_functor ff) : exprtk::ifunction<T>(5), f(ff) {}
+         inline T operator()(const T& v0, const T& v1, const T& v2, const T& v3, const T& v4)
+         { return f(v0,v1,v2,v3,v4); }
+         ff5_functor f;
+      };
+
       template <typename Type, typename RawType>
       struct type_store
       {
@@ -14554,14 +14803,23 @@
                }
             }
 
+           ~st_data()
+            {
+               for (std::size_t i = 0; i < free_function_list_.size(); ++i)
+               {
+                  delete free_function_list_[i];
+               }
+            }
+
             inline bool is_reserved_symbol(const std::string& symbol) const
             {
                return (reserved_symbol_table_.end() != reserved_symbol_table_.find(symbol));
             }
 
-            std::list<T> local_symbol_list_;
-            std::list<std::string> local_stringvar_list_;
-            std::set<std::string> reserved_symbol_table_;
+            std::list<T>               local_symbol_list_;
+            std::list<std::string>     local_stringvar_list_;
+            std::set<std::string>      reserved_symbol_table_;
+            std::vector<ifunction<T>*> free_function_list_;
          };
 
          st_holder()
@@ -14929,14 +15187,7 @@
             return local_data().vararg_function_store.add(vararg_function_name,vararg_function);
       }
 
-      enum func_type
-      {
-         e_ft_unknown   = 0,
-         e_ft_basicfunc = 1,
-         e_ft_strfunc   = 2
-      };
-
-      inline bool add_function(const std::string& function_name, generic_function_t& function, const func_type ft = e_ft_basicfunc)
+      inline bool add_function(const std::string& function_name, generic_function_t& function)
       {
          if (!valid())
             return false;
@@ -14946,14 +15197,94 @@
             return false;
          else if (std::string::npos != function.parameter_sequence.find_first_not_of("STV*?|"))
             return false;
-         else if (e_ft_basicfunc == ft)
+         else if (generic_function_t::e_rtrn_scalar == function.rtrn_type)
             return local_data().generic_function_store.add(function_name,function);
-         else if (e_ft_strfunc == ft)
+         else if (generic_function_t::e_rtrn_string == function.rtrn_type)
             return local_data().string_function_store.add(function_name, function);
          else
             return false;
       }
 
+      inline bool add_function(const std::string& function_name, ff1_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 freefunc1(function);
+
+         local_data().free_function_list_.push_back(ifunc);
+
+         return add_function(function_name,(*local_data().free_function_list_.back()));
+      }
+
+      inline bool add_function(const std::string& function_name, ff2_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 freefunc2(function);
+
+         local_data().free_function_list_.push_back(ifunc);
+
+         return add_function(function_name,(*local_data().free_function_list_.back()));
+      }
+
+      inline bool add_function(const std::string& function_name, ff3_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 freefunc3(function);
+
+         local_data().free_function_list_.push_back(ifunc);
+
+         return add_function(function_name,(*local_data().free_function_list_.back()));
+      }
+
+      inline bool add_function(const std::string& function_name, ff4_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 freefunc4(function);
+
+         local_data().free_function_list_.push_back(ifunc);
+
+         return add_function(function_name,(*local_data().free_function_list_.back()));
+      }
+
+      inline bool add_function(const std::string& function_name, ff5_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 freefunc5(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())
@@ -14978,7 +15309,7 @@
             return local_data().vararg_function_store.add(vararg_function_name,vararg_function);
       }
 
-      inline bool add_reserved_function(const std::string& function_name, generic_function_t& function, const func_type ft = e_ft_basicfunc)
+      inline bool add_reserved_function(const std::string& function_name, generic_function_t& function)
       {
          if (!valid())
             return false;
@@ -14988,9 +15319,9 @@
             return false;
          else if (std::string::npos != function.parameter_sequence.find_first_not_of("STV*?|"))
             return false;
-         else if (e_ft_basicfunc == ft)
+         else if (generic_function_t::e_rtrn_scalar == function.rtrn_type)
             return local_data().generic_function_store.add(function_name,function);
-         else if (e_ft_strfunc == ft)
+         else if (generic_function_t::e_rtrn_string == function.rtrn_type)
             return local_data().string_function_store.add(function_name, function);
          else
             return false;
@@ -15330,7 +15661,7 @@
                for (std::size_t i = 0; i < name_list.size(); ++i)
                {
                   exprtk::igeneric_function<T>& ifunc = *st.get_string_function(name_list[i]);
-                  add_function(name_list[i],ifunc,e_ft_strfunc);
+                  add_function(name_list[i],ifunc);
                }
             }
          }
@@ -16241,9 +16572,11 @@
                case scope_element::e_vecelem : if (se.var_node) delete se.var_node;
                                                break;
 
+               #ifndef exprtk_disable_string_capabilities
                case scope_element::e_string  : if (se.data    ) delete (std::string*) se.data;
                                                if (se.str_node) delete se.str_node;
                                                break;
+               #endif
 
                default                       : return;
             }
@@ -16825,11 +17158,12 @@
          e_st_unknown        = 0,
          e_st_variable       = 1,
          e_st_vector         = 2,
-         e_st_string         = 3,
-         e_st_function       = 4,
-         e_st_local_variable = 5,
-         e_st_local_vector   = 6,
-         e_st_local_string   = 7
+         e_st_vecelem        = 3,
+         e_st_string         = 4,
+         e_st_function       = 5,
+         e_st_local_variable = 6,
+         e_st_local_vector   = 7,
+         e_st_local_string   = 8
       };
 
       class dependent_entity_collector
@@ -17049,6 +17383,28 @@
             e_logic_xor, e_logic_scand, e_logic_scor
          };
 
+         enum settings_arithmetic_opr
+         {
+            e_arith_unknown = 0,
+            e_arith_add, e_arith_sub, e_arith_mul,
+            e_arith_div, e_arith_mod, e_arith_pow
+         };
+
+         enum settings_assignment_opr
+         {
+            e_assign_unknown = 0,
+            e_assign_assign, e_assign_addass, e_assign_subass,
+            e_assign_mulass, e_assign_divass, e_assign_modass
+         };
+
+         enum settings_inequality_opr
+         {
+            e_ineq_unknown = 0,
+            e_ineq_lt,    e_ineq_lte, e_ineq_eq,
+            e_ineq_equal, e_ineq_ne,  e_ineq_nequal,
+            e_ineq_gte,   e_ineq_gt
+         };
+
          static const std::size_t compile_all_opts = e_replacer          +
                                                      e_joiner            +
                                                      e_numeric_check     +
@@ -17080,6 +17436,30 @@
             return *this;
          }
 
+         settings_store& enable_all_arithmetic_ops()
+         {
+            disabled_arithmetic_set_.clear();
+            return *this;
+         }
+
+         settings_store& enable_all_assignment_ops()
+         {
+            disabled_assignment_set_.clear();
+            return *this;
+         }
+
+         settings_store& enable_all_inequality_ops()
+         {
+            disabled_inequality_set_.clear();
+            return *this;
+         }
+
+         settings_store& enable_local_vardef()
+         {
+            disable_vardef_ = false;
+            return *this;
+         }
+
          settings_store& disable_all_base_functions()
          {
             std::copy(details::base_function_list,
@@ -17107,6 +17487,39 @@
             return *this;
          }
 
+         settings_store& disable_all_arithmetic_ops()
+         {
+            std::copy(details::arithmetic_ops_list,
+                      details::arithmetic_ops_list + details::arithmetic_ops_list_size,
+                      std::insert_iterator<disabled_entity_set_t>
+                        (disabled_arithmetic_set_,disabled_arithmetic_set_.begin()));
+            return *this;
+         }
+
+         settings_store& disable_all_assignment_ops()
+         {
+            std::copy(details::assignment_ops_list,
+                      details::assignment_ops_list + details::assignment_ops_list_size,
+                      std::insert_iterator<disabled_entity_set_t>
+                        (disabled_assignment_set_,disabled_assignment_set_.begin()));
+            return *this;
+         }
+
+         settings_store& disable_all_inequality_ops()
+         {
+            std::copy(details::inequality_ops_list,
+                      details::inequality_ops_list + details::inequality_ops_list_size,
+                      std::insert_iterator<disabled_entity_set_t>
+                        (disabled_inequality_set_,disabled_inequality_set_.begin()));
+            return *this;
+         }
+
+         settings_store& disable_local_vardef()
+         {
+            disable_vardef_ = true;
+            return *this;
+         }
+
          bool replacer_enabled           () const { return enable_replacer_;           }
          bool commutative_check_enabled  () const { return enable_commutative_check_;  }
          bool joiner_enabled             () const { return enable_joiner_;             }
@@ -17145,6 +17558,30 @@
                return (disabled_logic_set_.end() == disabled_logic_set_.find(logic_operation));
          }
 
+         bool arithmetic_enabled(const details::operator_type& arithmetic_operation)
+         {
+            if (disabled_logic_set_.empty())
+               return true;
+            else
+               return (disabled_arithmetic_set_.end() == disabled_arithmetic_set_.find(arith_opr_to_string(arithmetic_operation)));
+         }
+
+         bool assignment_enabled(const details::operator_type& assignment)
+         {
+            if (disabled_assignment_set_.empty())
+               return true;
+            else
+               return (disabled_assignment_set_.end() == disabled_assignment_set_.find(assign_opr_to_string(assignment)));
+         }
+
+         bool inequality_enabled(const details::operator_type& inequality)
+         {
+            if (disabled_inequality_set_.empty())
+               return true;
+            else
+               return (disabled_inequality_set_.end() == disabled_inequality_set_.find(inequality_opr_to_string(inequality)));
+         }
+
          bool function_disabled(const std::string& function_name)
          {
             if (disabled_func_set_.empty())
@@ -17169,11 +17606,35 @@
                return (disabled_logic_set_.end() != disabled_logic_set_.find(logic_operation));
          }
 
+         bool assignment_disabled(const details::operator_type assignment_operation)
+         {
+            if (disabled_assignment_set_.empty())
+               return false;
+            else
+               return (disabled_assignment_set_.end() != disabled_assignment_set_.find(assign_opr_to_string(assignment_operation)));
+         }
+
+         bool arithmetic_disabled(const details::operator_type arithmetic_operation)
+         {
+            if (disabled_arithmetic_set_.empty())
+               return false;
+            else
+               return (disabled_arithmetic_set_.end() != disabled_arithmetic_set_.find(arith_opr_to_string(arithmetic_operation)));
+         }
+
+         bool inequality_disabled(const details::operator_type& inequality)
+         {
+            if (disabled_inequality_set_.empty())
+               return false;
+            else
+               return (disabled_inequality_set_.end() != disabled_inequality_set_.find(inequality_opr_to_string(inequality)));
+         }
+
          settings_store& disable_base_function(settings_base_funcs bf)
          {
             if (
                  (e_bf_unknown != bf) &&
-                 (bf < details::base_function_list_size)
+                 (static_cast<std::size_t>(bf) < details::base_function_list_size)
                )
             {
                disabled_func_set_.insert(details::base_function_list[bf - 1]);
@@ -17186,7 +17647,7 @@
          {
             if (
                  (e_ctrl_unknown != ctrl_struct) &&
-                 (ctrl_struct < details::cntrl_struct_list_size)
+                 (static_cast<std::size_t>(ctrl_struct) < details::cntrl_struct_list_size)
                )
             {
                disabled_ctrl_set_.insert(details::cntrl_struct_list[ctrl_struct - 1]);
@@ -17199,7 +17660,7 @@
          {
             if (
                  (e_logic_unknown != logic) &&
-                 (logic < details::logic_ops_list_size)
+                 (static_cast<std::size_t>(logic) < details::logic_ops_list_size)
                )
             {
                disabled_logic_set_.insert(details::logic_ops_list[logic - 1]);
@@ -17208,11 +17669,50 @@
             return *this;
          }
 
+         settings_store& disable_arithmetic_operation(settings_arithmetic_opr arithmetic)
+         {
+            if (
+                 (e_arith_unknown != arithmetic) &&
+                 (static_cast<std::size_t>(arithmetic) < details::arithmetic_ops_list_size)
+               )
+            {
+               disabled_arithmetic_set_.insert(details::arithmetic_ops_list[arithmetic - 1]);
+            }
+
+            return *this;
+         }
+
+         settings_store& disable_assignment_operation(settings_assignment_opr assignment)
+         {
+            if (
+                 (e_assign_unknown != assignment) &&
+                 (static_cast<std::size_t>(assignment) < details::assignment_ops_list_size)
+               )
+            {
+               disabled_assignment_set_.insert(details::assignment_ops_list[assignment - 1]);
+            }
+
+            return *this;
+         }
+
+         settings_store& disable_inequality_operation(settings_inequality_opr inequality)
+         {
+            if (
+                 (e_assign_unknown != inequality) &&
+                 (static_cast<std::size_t>(inequality) < details::inequality_ops_list_size)
+               )
+            {
+               disabled_inequality_set_.insert(details::inequality_ops_list[inequality - 1]);
+            }
+
+            return *this;
+         }
+
          settings_store& enable_base_function(settings_base_funcs bf)
          {
             if (
                  (e_bf_unknown != bf) &&
-                 (bf < details::base_function_list_size)
+                 (static_cast<std::size_t>(bf) < details::base_function_list_size)
                )
             {
                des_itr_t itr = disabled_func_set_.find(details::base_function_list[bf - 1]);
@@ -17230,7 +17730,7 @@
          {
             if (
                  (e_ctrl_unknown != ctrl_struct) &&
-                 (ctrl_struct < details::cntrl_struct_list_size)
+                 (static_cast<std::size_t>(ctrl_struct) < details::cntrl_struct_list_size)
                )
             {
                des_itr_t itr = disabled_ctrl_set_.find(details::cntrl_struct_list[ctrl_struct - 1]);
@@ -17248,7 +17748,7 @@
          {
             if (
                  (e_logic_unknown != logic) &&
-                 (logic < details::logic_ops_list_size)
+                 (static_cast<std::size_t>(logic) < details::logic_ops_list_size)
                )
             {
                des_itr_t itr = disabled_logic_set_.find(details::logic_ops_list[logic - 1]);
@@ -17262,6 +17762,60 @@
             return *this;
          }
 
+         settings_store& enable_arithmetic_operation(settings_arithmetic_opr arithmetic)
+         {
+            if (
+                 (e_arith_unknown != arithmetic) &&
+                 (static_cast<std::size_t>(arithmetic) < details::arithmetic_ops_list_size)
+               )
+            {
+               des_itr_t itr = disabled_arithmetic_set_.find(details::arithmetic_ops_list[arithmetic - 1]);
+
+               if (disabled_arithmetic_set_.end() != itr)
+               {
+                  disabled_arithmetic_set_.erase(itr);
+               }
+            }
+
+            return *this;
+         }
+
+         settings_store& enable_assignment_operation(settings_assignment_opr assignment)
+         {
+            if (
+                 (e_assign_unknown != assignment) &&
+                 (static_cast<std::size_t>(assignment) < details::assignment_ops_list_size)
+               )
+            {
+               des_itr_t itr = disabled_assignment_set_.find(details::assignment_ops_list[assignment - 1]);
+
+               if (disabled_assignment_set_.end() != itr)
+               {
+                  disabled_assignment_set_.erase(itr);
+               }
+            }
+
+            return *this;
+         }
+
+         settings_store& enable_inequality_operation(settings_inequality_opr inequality)
+         {
+            if (
+                 (e_ineq_unknown != inequality) &&
+                 (static_cast<std::size_t>(inequality) < details::inequality_ops_list_size)
+               )
+            {
+               des_itr_t itr = disabled_inequality_set_.find(details::inequality_ops_list[inequality - 1]);
+
+               if (disabled_inequality_set_.end() != itr)
+               {
+                  disabled_inequality_set_.erase(itr);
+               }
+            }
+
+            return *this;
+         }
+
       private:
 
          void load_compile_options(const std::size_t compile_options)
@@ -17281,6 +17835,49 @@
             disable_zero_return_       = (compile_options & e_disable_zero_return ) == e_disable_zero_return;
          }
 
+         std::string assign_opr_to_string(details::operator_type opr)
+         {
+            switch (opr)
+            {
+               case details::e_assign : return ":=";
+               case details::e_addass : return "+=";
+               case details::e_subass : return "-=";
+               case details::e_mulass : return "*=";
+               case details::e_divass : return "/=";
+               case details::e_modass : return "%=";
+               default                : return   "";
+            }
+         }
+
+         std::string arith_opr_to_string(details::operator_type opr)
+         {
+            switch (opr)
+            {
+               case details::e_add : return "+";
+               case details::e_sub : return "-";
+               case details::e_mul : return "*";
+               case details::e_div : return "/";
+               case details::e_mod : return "%";
+               default             : return  "";
+            }
+         }
+
+         std::string inequality_opr_to_string(details::operator_type opr)
+         {
+            switch (opr)
+            {
+               case details::e_lt    : return  "<";
+               case details::e_lte   : return "<=";
+               case details::e_eq    : return "==";
+               case details::e_equal : return  "=";
+               case details::e_ne    : return "!=";
+               case details::e_nequal: return "<>";
+               case details::e_gte   : return ">=";
+               case details::e_gt    : return  ">";
+               default               : return   "";
+            }
+         }
+
          bool enable_replacer_;
          bool enable_joiner_;
          bool enable_numeric_check_;
@@ -17298,6 +17895,9 @@
          disabled_entity_set_t disabled_func_set_ ;
          disabled_entity_set_t disabled_ctrl_set_ ;
          disabled_entity_set_t disabled_logic_set_;
+         disabled_entity_set_t disabled_arithmetic_set_;
+         disabled_entity_set_t disabled_assignment_set_;
+         disabled_entity_set_t disabled_inequality_set_;
 
          friend class parser<T>;
       };
@@ -17489,7 +18089,7 @@
             sem_.cleanup  ();
             return_cleanup();
 
-            if (0 != e)
+            if ((0 != e) && branch_deletable(e))
             {
                delete e;
             }
@@ -17729,6 +18329,21 @@
                settings_.function_enabled(symbol);
       }
 
+      bool is_invalid_arithmetic_operation(const details::operator_type operation)
+      {
+         return settings_.arithmetic_disabled(operation);
+      }
+
+      bool is_invalid_assignment_operation(const details::operator_type operation)
+      {
+         return settings_.assignment_disabled(operation);
+      }
+
+      bool is_invalid_inequality_operation(const details::operator_type operation)
+      {
+         return settings_.inequality_disabled(operation);
+      }
+
       #ifdef exprtk_enable_debugging
       inline void next_token()
       {
@@ -17849,8 +18464,9 @@
 
          inline void reset()
          {
-            left  = e_level00;
-            right = e_level00;
+            left      = e_level00;
+            right     = e_level00;
+            operation = details::e_default;
          }
 
          precedence_level left;
@@ -17960,17 +18576,17 @@
                                            }
                                            else if (details::imatch(current_token().value,s_in))
                                            {
-                                              current_state.set(e_level03,e_level04,details::e_in);
+                                              current_state.set(e_level04,e_level04,details::e_in);
                                               break;
                                            }
                                            else if (details::imatch(current_token().value,s_like))
                                            {
-                                              current_state.set(e_level03,e_level04,details::e_like);
+                                              current_state.set(e_level04,e_level04,details::e_like);
                                               break;
                                            }
                                            else if (details::imatch(current_token().value,s_ilike))
                                            {
-                                              current_state.set(e_level03,e_level04,details::e_ilike);
+                                              current_state.set(e_level04,e_level04,details::e_ilike);
                                               break;
                                            }
                                         }
@@ -17993,7 +18609,41 @@
             expression_node_ptr right_branch   = error_node();
             expression_node_ptr new_expression = error_node();
 
-            if ((right_branch = parse_expression(current_state.right)))
+            if (is_invalid_arithmetic_operation(current_state.operation))
+            {
+               free_node(node_allocator_,expression);
+
+               set_error(
+                  make_error(parser_error::e_syntax,
+                             prev_token,
+                             "ERR008 - Invalid arithmetic operation '" + details::to_str(current_state.operation) + "'"));
+
+               return error_node();
+            }
+            else if (is_invalid_inequality_operation(current_state.operation))
+            {
+               free_node(node_allocator_,expression);
+
+               set_error(
+                  make_error(parser_error::e_syntax,
+                             prev_token,
+                             "ERR009 - Invalid inequality operation '" + details::to_str(current_state.operation) + "'"));
+
+               return error_node();
+            }
+            else if (is_invalid_assignment_operation(current_state.operation))
+            {
+               free_node(node_allocator_,expression);
+
+               set_error(
+                  make_error(parser_error::e_syntax,
+                             prev_token,
+                             "ERR010 - Invalid assignment operation '" + details::to_str(current_state.operation) + "'"));
+
+               return error_node();
+            }
+
+            if (0 != (right_branch = parse_expression(current_state.right)))
             {
                if (
                     details::is_return_node(  expression) ||
@@ -18006,7 +18656,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 prev_token,
-                                "ERR008 - Return statements cannot be part of sub-expressions"));
+                                "ERR011 - Return statements cannot be part of sub-expressions"));
 
                   return error_node();
                }
@@ -18028,7 +18678,7 @@
                                 prev_token,
                                 !synthesis_error_.empty() ?
                                 synthesis_error_ :
-                                "ERR009 - General parsing error at token: '" + prev_token.value + "'"));
+                                "ERR012 - General parsing error at token: '" + prev_token.value + "'"));
                }
 
                free_node(node_allocator_,expression);
@@ -18069,9 +18719,9 @@
          }
 
          {
-            typedef details::unary_variable_node<T,details::neg_op<T> > ubn_t;
+            typedef details::unary_variable_node<T,details::neg_op<T> > uvn_t;
 
-            ubn_t* n = dynamic_cast<ubn_t*>(node);
+            uvn_t* n = dynamic_cast<uvn_t*>(node);
 
             if (n)
             {
@@ -18079,8 +18729,8 @@
                expression_node_ptr return_node = error_node();
 
                if (
-                    (return_node = symtab_store_.get_variable(v)) ||
-                    (return_node = sem_         .get_variable(v))
+                    (0 != (return_node = symtab_store_.get_variable(v))) ||
+                    (0 != (return_node = sem_         .get_variable(v)))
                   )
                {
                   free_node(node_allocator_,node);
@@ -18093,7 +18743,8 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR010 - Failed to find variable node in symbol table"));
+                                "ERR013 - Failed to find variable node in symbol table"));
+
                   free_node(node_allocator_,node);
 
                   return false;
@@ -18271,7 +18922,7 @@
                          set_error(
                             make_error(parser_error::e_syntax,
                                        current_token(),
-                                       "ERR011 - Invalid number of parameters for function: '" + function_name + "'"));
+                                       "ERR014 - Invalid number of parameters for function: '" + function_name + "'"));
 
                          return error_node();
                       }
@@ -18284,7 +18935,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR012 - Failed to generate call to function: '" + function_name + "'"));
+                          "ERR015 - Failed to generate call to function: '" + function_name + "'"));
 
             return error_node();
          }
@@ -18298,7 +18949,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR013 - Expecting ifunction '" + function_name + "' to have non-zero parameter count"));
+                          "ERR016 - Expecting ifunction '" + function_name + "' to have non-zero parameter count"));
 
             return error_node();
          }
@@ -18316,7 +18967,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR014 - Expecting argument list for function: '" + function_name + "'"));
+                          "ERR017 - Expecting argument list for function: '" + function_name + "'"));
 
             return error_node();
          }
@@ -18330,7 +18981,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR015 - Failed to parse argument " + details::to_str(i) + " for function: '" + function_name + "'"));
+                             "ERR018 - Failed to parse argument " + details::to_str(i) + " for function: '" + function_name + "'"));
 
                return error_node();
             }
@@ -18341,7 +18992,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR016 - Invalid number of arguments for function: '" + function_name + "'"));
+                                "ERR019 - Invalid number of arguments for function: '" + function_name + "'"));
 
                   return error_node();
                }
@@ -18353,7 +19004,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR017 - Invalid number of arguments for function: '" + function_name + "'"));
+                          "ERR020 - Invalid number of arguments for function: '" + function_name + "'"));
 
             return error_node();
          }
@@ -18381,7 +19032,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR018 - Expecting '()' to proceed call to function: '" + function_name + "'"));
+                          "ERR021 - Expecting '()' to proceed call to function: '" + function_name + "'"));
 
             free_node(node_allocator_,result);
 
@@ -18405,7 +19056,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR019 - Expected a '(' at start of function call, instead got: '" + current_token().value + "'"));
+                          "ERR022 - Expected a '(' at start of function call, instead got: '" + current_token().value + "'"));
 
             return 0;
          }
@@ -18417,9 +19068,7 @@
             param_list[param_index] = parse_expression();
 
             if (0 == param_list[param_index])
-            {
                return 0;
-            }
             else if (token_is(token_t::e_rbracket))
                break;
             else if (token_is(token_t::e_comma))
@@ -18429,7 +19078,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR020 - Expected a ',' between function input parameters, instead got: '" + current_token().value + "'"));
+                             "ERR023 - Expected a ',' between function input parameters, instead got: '" + current_token().value + "'"));
 
                return 0;
             }
@@ -18452,7 +19101,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR021 - No entry found for base operation: " + operation_name));
+                          "ERR024 - No entry found for base operation: " + operation_name));
 
             return error_node();
          }
@@ -18502,7 +19151,7 @@
          set_error(
             make_error(parser_error::e_syntax,
                        current_token(),
-                       "ERR022 - Invalid number of parameters for call to function: '" + operation_name + "'"));
+                       "ERR025 - Invalid number of parameters for call to function: '" + operation_name + "'"));
 
          return error_node();
       }
@@ -18521,7 +19170,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR023 - Expected ',' between if-statement condition and consequent"));
+                          "ERR026 - Expected ',' between if-statement condition and consequent"));
             result = false;
          }
          else if (0 == (consequent = parse_expression()))
@@ -18529,7 +19178,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR024 - Failed to parse consequent for if-statement"));
+                          "ERR027 - Failed to parse consequent for if-statement"));
             result = false;
          }
          else if (!token_is(token_t::e_comma))
@@ -18537,7 +19186,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR025 - Expected ',' between if-statement consequent and alternative"));
+                          "ERR028 - Expected ',' between if-statement consequent and alternative"));
             result = false;
          }
          else if (0 == (alternative = parse_expression()))
@@ -18545,7 +19194,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR026 - Failed to parse alternative for if-statement"));
+                          "ERR029 - Failed to parse alternative for if-statement"));
             result = false;
          }
          else if (!token_is(token_t::e_rbracket))
@@ -18553,7 +19202,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR027 - Expected ')' at the end of if-statement"));
+                          "ERR030 - Expected ')' at the end of if-statement"));
             result = false;
          }
 
@@ -18574,7 +19223,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR028 - Return types of ternary if-statement differ"));
+                             "ERR031 - Return types of ternary if-statement differ"));
 
                result = false;
             }
@@ -18608,7 +19257,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR029 - Failed to parse body of consequent for if-statement"));
+                             "ERR032 - Failed to parse body of consequent for if-statement"));
                result = false;
             }
          }
@@ -18629,7 +19278,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR030 - Expected ';' at the end of the consequent for if-statement"));
+                                "ERR033 - Expected ';' at the end of the consequent for if-statement"));
                   result = false;
                }
             }
@@ -18638,7 +19287,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR031 - Failed to parse body of consequent for if-statement"));
+                             "ERR034 - Failed to parse body of consequent for if-statement"));
                result = false;
             }
          }
@@ -18656,7 +19305,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR032 - Failed to parse body of the 'else' for if-statement"));
+                                   "ERR035 - Failed to parse body of the 'else' for if-statement"));
                      result = false;
                   }
                }
@@ -18667,7 +19316,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR033 - Failed to parse body of if-else statement"));
+                                   "ERR036 - Failed to parse body of if-else statement"));
                      result = false;
                   }
                }
@@ -18678,7 +19327,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR034 - Expected ';' at the end of the 'else-if' for the if-statement"));
+                                   "ERR037 - Expected ';' at the end of the 'else-if' for the if-statement"));
                      result = false;
                   }
                }
@@ -18687,7 +19336,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR035 - Failed to parse body of the 'else' for if-statement"));
+                                "ERR038 - Failed to parse body of the 'else' for if-statement"));
                   result = false;
                }
             }
@@ -18710,7 +19359,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR036 - Return types of ternary if-statement differ"));
+                             "ERR039 - Return types of ternary if-statement differ"));
 
                result = false;
             }
@@ -18741,7 +19390,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR037 - Expected '(' at start of if-statement, instead got: '" + current_token().value + "'"));
+                          "ERR040 - Expected '(' at start of if-statement, instead got: '" + current_token().value + "'"));
 
             return error_node();
          }
@@ -18750,7 +19399,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR038 - Failed to parse condition for if-statement"));
+                          "ERR041 - Failed to parse condition for if-statement"));
 
             return error_node();
          }
@@ -18781,7 +19430,7 @@
          set_error(
             make_error(parser_error::e_syntax,
                        current_token(),
-                       "ERR039 - Invalid if-statement"));
+                       "ERR042 - Invalid if-statement"));
 
          free_node(node_allocator_,condition);
 
@@ -18801,7 +19450,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR040 - Encountered invalid condition branch for ternary if-statement"));
+                          "ERR043 - Encountered invalid condition branch for ternary if-statement"));
 
             return error_node();
          }
@@ -18810,7 +19459,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR041 - Expected '?' after condition of ternary if-statement"));
+                          "ERR044 - Expected '?' after condition of ternary if-statement"));
 
             result = false;
          }
@@ -18819,7 +19468,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR042 - Failed to parse consequent for ternary if-statement"));
+                          "ERR045 - Failed to parse consequent for ternary if-statement"));
 
             result = false;
          }
@@ -18828,7 +19477,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR043 - Expected ':' between ternary if-statement consequent and alternative"));
+                          "ERR046 - Expected ':' between ternary if-statement consequent and alternative"));
 
             result = false;
          }
@@ -18837,7 +19486,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR044 - Failed to parse alternative for ternary if-statement"));
+                          "ERR047 - Failed to parse alternative for ternary if-statement"));
 
             result = false;
          }
@@ -18859,7 +19508,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR045 - Return types of ternary if-statement differ"));
+                             "ERR048 - Return types of ternary if-statement differ"));
 
                result = false;
             }
@@ -18895,7 +19544,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR046 - Expected '(' at start of while-loop condition statement"));
+                          "ERR049 - Expected '(' at start of while-loop condition statement"));
 
             return error_node();
          }
@@ -18904,7 +19553,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR047 - Failed to parse condition for while-loop"));
+                          "ERR050 - Failed to parse condition for while-loop"));
 
             return error_node();
          }
@@ -18913,7 +19562,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR048 - Expected ')' at end of while-loop condition statement"));
+                          "ERR051 - Expected ')' at end of while-loop condition statement"));
             result = false;
          }
 
@@ -18926,7 +19575,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR049 - Failed to parse body of while-loop"));
+                             "ERR052 - Failed to parse body of while-loop"));
                result = false;
             }
             else if (0 == (result_node = expression_generator_.while_loop(condition,
@@ -18936,7 +19585,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR050 - Failed to synthesize while-loop"));
+                             "ERR053 - Failed to synthesize while-loop"));
                result = false;
             }
          }
@@ -19010,7 +19659,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR051 - Expected '" + token_t::to_str(seperator) + "' in body of repeat until loop"));
+                                "ERR054 - Expected '" + token_t::to_str(seperator) + "' in body of repeat until loop"));
 
                   return error_node();
                }
@@ -19024,14 +19673,16 @@
 
             branch = simplify(arg_list,side_effect_list);
 
-            if ((sdd.delete_ptr = (0 == branch)))
+            sdd.delete_ptr = (0 == branch);
+
+            if (sdd.delete_ptr)
             {
                brkcnt_list_.pop_front();
 
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR052 - Failed to parse body of repeat until loop"));
+                             "ERR055 - Failed to parse body of repeat until loop"));
 
                return error_node();
             }
@@ -19044,7 +19695,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR053 - Expected '(' before condition statement of repeat until loop"));
+                          "ERR056 - Expected '(' before condition statement of repeat until loop"));
 
             free_node(node_allocator_,branch);
 
@@ -19057,7 +19708,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR054 - Failed to parse condition for repeat until loop"));
+                          "ERR057 - Failed to parse condition for repeat until loop"));
 
             free_node(node_allocator_,branch);
 
@@ -19068,7 +19719,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR055 - Expected ')' after condition of repeat until loop"));
+                          "ERR058 - Expected ')' after condition of repeat until loop"));
 
             free_node(node_allocator_,    branch);
             free_node(node_allocator_, condition);
@@ -19088,7 +19739,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR056 - Failed to synthesize repeat until loop"));
+                          "ERR059 - Failed to synthesize repeat until loop"));
 
             free_node(node_allocator_, condition);
             brkcnt_list_.pop_front();
@@ -19122,7 +19773,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR057 - Expected '(' at start of for-loop"));
+                          "ERR060 - Expected '(' at start of for-loop"));
 
             return error_node();
          }
@@ -19141,7 +19792,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR058 - Expected a variable at the start of initialiser section of for-loop"));
+                                "ERR061 - Expected a variable at the start of initialiser section of for-loop"));
 
                   return error_node();
                }
@@ -19150,7 +19801,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR059 - Expected variable assignment of initialiser section of for-loop"));
+                                "ERR062 - Expected variable assignment of initialiser section of for-loop"));
 
                   return error_node();
                }
@@ -19164,7 +19815,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR060 - For-loop variable '" + loop_counter_symbol+ "' is being shadowed by a previous declaration"));
+                                "ERR063 - For-loop variable '" + loop_counter_symbol+ "' is being shadowed by a previous declaration"));
 
                   return error_node();
                }
@@ -19195,7 +19846,7 @@
                         set_error(
                            make_error(parser_error::e_syntax,
                                       current_token(),
-                                      "ERR061 - Failed to add new local variable '" + loop_counter_symbol + "' to SEM"));
+                                      "ERR064 - Failed to add new local variable '" + loop_counter_symbol + "' to SEM"));
 
                         sem_.free_element(nse);
 
@@ -19216,7 +19867,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR062 - Failed to parse initialiser of for-loop"));
+                             "ERR065 - Failed to parse initialiser of for-loop"));
                result = false;
             }
             else if (!token_is(token_t::e_eof))
@@ -19224,7 +19875,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR063 - Expected ';' after initialiser of for-loop"));
+                             "ERR066 - Expected ';' after initialiser of for-loop"));
                result = false;
             }
          }
@@ -19236,7 +19887,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR064 - Failed to parse condition of for-loop"));
+                             "ERR067 - Failed to parse condition of for-loop"));
                result = false;
             }
             else if (!token_is(token_t::e_eof))
@@ -19244,7 +19895,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR065 - Expected ';' after condition section of for-loop"));
+                             "ERR068 - Expected ';' after condition section of for-loop"));
                result = false;
             }
          }
@@ -19256,7 +19907,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR066 - Failed to parse incrementor of for-loop"));
+                             "ERR069 - Failed to parse incrementor of for-loop"));
                result = false;
             }
             else if (!token_is(token_t::e_rbracket))
@@ -19264,7 +19915,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR067 - Expected ')' after incrementor section of for-loop"));
+                             "ERR070 - Expected ')' after incrementor section of for-loop"));
                result = false;
             }
          }
@@ -19277,7 +19928,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR068 - Failed to parse body of for-loop"));
+                             "ERR071 - Failed to parse body of for-loop"));
                result = false;
             }
          }
@@ -19327,7 +19978,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR069 - Expected keyword 'switch'"));
+                          "ERR072 - Expected keyword 'switch'"));
 
             return error_node();
          }
@@ -19341,7 +19992,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR070 - Expected '{' for call to switch statement"));
+                          "ERR073 - Expected '{' for call to switch statement"));
 
             return error_node();
          }
@@ -19353,7 +20004,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR071 - Expected either a 'case' or 'default' statement"));
+                             "ERR074 - Expected either a 'case' or 'default' statement"));
 
                return error_node();
             }
@@ -19369,7 +20020,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR072 - Expected ':' for case of switch statement"));
+                             "ERR075 - Expected ':' for case of switch statement"));
 
                return error_node();
             }
@@ -19383,7 +20034,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR073 - Expected ';' at end of case for switch statement"));
+                             "ERR076 - Expected ';' at end of case for switch statement"));
 
                return error_node();
             }
@@ -19411,7 +20062,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR074 - Expected ':' for default of switch statement"));
+                                "ERR077 - Expected ':' for default of switch statement"));
 
                   return error_node();
                }
@@ -19432,7 +20083,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR075 - Expected ';' at end of default for switch statement"));
+                                "ERR078 - Expected ';' at end of default for switch statement"));
 
                   return error_node();
                }
@@ -19447,7 +20098,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR076 - Expected '}' at end of switch statement"));
+                          "ERR079 - Expected '}' at end of switch statement"));
 
             return error_node();
          }
@@ -19469,7 +20120,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR077 - Expected token '[*]'"));
+                          "ERR080 - Expected token '[*]'"));
 
             return error_node();
          }
@@ -19483,7 +20134,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR078 - Expected '{' for call to [*] statement"));
+                          "ERR081 - Expected '{' for call to [*] statement"));
 
             return error_node();
          }
@@ -19495,7 +20146,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR079 - Expected a 'case' statement for multi-switch"));
+                             "ERR082 - Expected a 'case' statement for multi-switch"));
 
                return error_node();
             }
@@ -19512,7 +20163,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR080 - Expected ':' for case of [*] statement"));
+                             "ERR083 - Expected ':' for case of [*] statement"));
 
                return error_node();
             }
@@ -19527,7 +20178,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR081 - Expected ';' at end of case for [*] statement"));
+                             "ERR084 - Expected ';' at end of case for [*] statement"));
 
                return error_node();
             }
@@ -19558,7 +20209,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR082 - Expected '}' at end of [*] statement"));
+                          "ERR085 - Expected '}' at end of [*] statement"));
 
             return error_node();
          }
@@ -19599,7 +20250,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR083 - Unsupported vararg function: " + symbol));
+                          "ERR086 - Unsupported vararg function: " + symbol));
 
             return error_node();
          }
@@ -19614,7 +20265,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR084 - Expected '(' for call to vararg function: " + symbol));
+                          "ERR087 - Expected '(' for call to vararg function: " + symbol));
 
             return error_node();
          }
@@ -19635,7 +20286,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR085 - Expected ',' for call to vararg function: " + symbol));
+                             "ERR088 - Expected ',' for call to vararg function: " + symbol));
 
                return error_node();
             }
@@ -19655,7 +20306,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR086 - Expected '[' as start of string range definition"));
+                          "ERR089 - Expected '[' as start of string range definition"));
 
             free_node(node_allocator_,expression);
 
@@ -19682,7 +20333,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR087 - Failed to generate string range node"));
+                          "ERR090 - Failed to generate string range node"));
 
             free_node(node_allocator_,expression);
          }
@@ -19814,7 +20465,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR088 - Expected '" + token_t::to_str(close_bracket) + "' for call to multi-sequence" +
+                             "ERR091 - Expected '" + token_t::to_str(close_bracket) + "' for call to multi-sequence" +
                              ((!source.empty()) ? std::string(" section of " + source): "")));
 
                return error_node();
@@ -19860,7 +20511,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR089 - Expected '" + details::to_str(seperator) + "' for call to multi-sequence section of " + source));
+                             "ERR092 - Expected '" + details::to_str(seperator) + "' for call to multi-sequence section of " + source));
 
                return error_node();
             }
@@ -19893,7 +20544,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR090 - Expected '[' for start of range"));
+                          "ERR093 - Expected '[' for start of range"));
 
             return false;
          }
@@ -19913,7 +20564,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR091 - Failed parse begin section of range"));
+                             "ERR094 - Failed parse begin section of range"));
 
                return false;
 
@@ -19936,7 +20587,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR092 - Range lower bound less than zero! Constraint: r0 >= 0"));
+                                "ERR095 - Range lower bound less than zero! Constraint: r0 >= 0"));
 
                   return false;
                }
@@ -19952,7 +20603,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR093 - Expected ':' for break  in range"));
+                             "ERR096 - Expected ':' for break  in range"));
 
                rp.free();
                return false;
@@ -19973,7 +20624,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR094 - Failed parse end section of range"));
+                             "ERR097 - Failed parse end section of range"));
 
                rp.free();
                return false;
@@ -19997,7 +20648,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR095 - Range upper bound less than zero! Constraint: r1 >= 0"));
+                                "ERR098 - Range upper bound less than zero! Constraint: r1 >= 0"));
 
                   return false;
                }
@@ -20013,7 +20664,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR096 - Expected ']' for start of range"));
+                             "ERR099 - Expected ']' for start of range"));
 
                rp.free();
                return false;
@@ -20032,7 +20683,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR097 - Invalid range, Constraint: r0 <= r1"));
+                             "ERR100 - Invalid range, Constraint: r0 <= r1"));
 
                return false;
             }
@@ -20047,6 +20698,7 @@
          dec_.add_symbol(symbol,st);
       }
 
+      #ifndef exprtk_disable_string_capabilities
       inline expression_node_ptr parse_string()
       {
          const std::string symbol = current_token().value;
@@ -20056,7 +20708,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR098 - Unknown string symbol"));
+                          "ERR101 - Unknown string symbol"));
 
             return error_node();
          }
@@ -20120,7 +20772,14 @@
 
          return result;
       }
+      #else
+      inline expression_node_ptr parse_string()
+      {
+         return error_node();
+      }
+      #endif
 
+      #ifndef exprtk_disable_string_capabilities
       inline expression_node_ptr parse_const_string()
       {
          const std::string const_str = current_token().value;
@@ -20165,7 +20824,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR099 - Overflow in range for string: '" + const_str + "'[" +
+                             "ERR102 - Overflow in range for string: '" + const_str + "'[" +
                              (rp.n0_c.first ? details::to_str(rp.n0_c.second) : "?") + ":" +
                              (rp.n1_c.first ? details::to_str(rp.n1_c.second) : "?") + "]"));
 
@@ -20182,6 +20841,12 @@
 
          return result;
       }
+      #else
+      inline expression_node_ptr parse_const_string()
+      {
+         return error_node();
+      }
+      #endif
 
       inline expression_node_ptr parse_vector()
       {
@@ -20202,7 +20867,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR100 - Symbol '" + symbol+ " not a vector"));
+                             "ERR103 - Symbol '" + symbol+ " not a vector"));
 
                return error_node();
             }
@@ -20227,7 +20892,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR101 - Failed to parse index for vector: '" + symbol + "'"));
+                          "ERR104 - Failed to parse index for vector: '" + symbol + "'"));
 
             return error_node();
          }
@@ -20236,7 +20901,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR102 - Expected ']' for index of vector: '" + symbol + "'"));
+                          "ERR105 - Expected ']' for index of vector: '" + symbol + "'"));
 
             free_node(node_allocator_,index_expr);
 
@@ -20264,7 +20929,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR103 - Zero parameter call to vararg function: "
+                                "ERR106 - Zero parameter call to vararg function: "
                                 + vararg_function_name + " not allowed"));
 
                   return error_node();
@@ -20288,7 +20953,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR104 - Expected ',' for call to vararg function: "
+                                   "ERR107 - Expected ',' for call to vararg function: "
                                    + vararg_function_name));
 
                      return error_node();
@@ -20301,12 +20966,35 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR105 - Zero parameter call to vararg function: "
+                          "ERR108 - Zero parameter call to vararg function: "
                           + vararg_function_name + " not allowed"));
 
             return error_node();
          }
 
+         if (arg_list.size() < vararg_function->min_num_args())
+         {
+            set_error(
+               make_error(parser_error::e_syntax,
+                          current_token(),
+                          "ERR109 - Invalid number of parameters to call to vararg function: "
+                          + vararg_function_name + ", require at least "
+                          + details::to_str( vararg_function->min_num_args()) + " parameters"));
+
+            return error_node();
+         }
+         else if (arg_list.size() > vararg_function->max_num_args())
+         {
+            set_error(
+               make_error(parser_error::e_syntax,
+                          current_token(),
+                          "ERR110 - Invalid number of parameters to call to vararg function: "
+                          + vararg_function_name + ", require no more than "
+                          + details::to_str( vararg_function->max_num_args()) + " parameters"));
+
+            return error_node();
+         }
+
          result = expression_generator_.vararg_function_call(vararg_function,arg_list);
 
          sdd.delete_ptr = (0 == result);
@@ -20362,7 +21050,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 parser_.current_token(),
-                                "ERR106 - Failed parameter type check for function '" + function_name_ + "', "
+                                "ERR111 - Failed parameter type check for function '" + function_name_ + "', "
                                 "Expected '" + param_seq_list_[0] + "'  call set: '" + param_seq +"'"));
             }
             else
@@ -20382,7 +21070,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 parser_.current_token(),
-                                "ERR107 - Failed parameter type check for function '" + function_name_ + "', "
+                                "ERR112 - Failed parameter type check for function '" + function_name_ + "', "
                                 "Best match: '" + param_seq_list_[max_diff_index] + "'  call set: '" + param_seq +"'"));
             }
 
@@ -20453,7 +21141,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    parser_.current_token(),
-                                   "ERR108 - Invalid parameter sequence of '" + err_param_seq +
+                                   "ERR113 - Invalid parameter sequence of '" + err_param_seq +
                                    "'  for function: " + function_name_));
 
                   return;
@@ -20474,7 +21162,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    parser_.current_token(),
-                                   "ERR109 - Invalid parameter sequence of '" + err_param_seq +
+                                   "ERR114 - Invalid parameter sequence of '" + err_param_seq +
                                    "'  for function: " + function_name_));
                   return;
                }
@@ -20507,7 +21195,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR110 - Type checker instantiation failure for generic function: " + function_name));
+                          "ERR115 - Type checker instantiation failure for generic function: " + function_name));
 
             return error_node();
          }
@@ -20521,7 +21209,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR111 - Zero parameter call to generic function: "
+                                "ERR116 - Zero parameter call to generic function: "
                                 + function_name + " not allowed"));
 
                   return error_node();
@@ -20552,7 +21240,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR112 - Expected ',' for call to generic function: " + function_name));
+                                   "ERR117 - Expected ',' for call to generic function: " + function_name));
 
                      return error_node();
                   }
@@ -20564,7 +21252,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR113 - Zero parameter call to generic function: "
+                          "ERR118 - Zero parameter call to generic function: "
                           + function_name + " not allowed"));
 
             return error_node();
@@ -20577,7 +21265,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR114 - Expected ',' for call to generic function: " + function_name));
+                          "ERR119 - Expected ',' for call to generic function: " + function_name));
 
             return error_node();
          }
@@ -20643,7 +21331,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR115 - Expected ',' for call to string function: " + function_name));
+                                   "ERR120 - Expected ',' for call to string function: " + function_name));
 
                      return error_node();
                   }
@@ -20658,7 +21346,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR116 - Expected ',' for call to string function: " + function_name));
+                          "ERR121 - Expected ',' for call to string function: " + function_name));
 
             return error_node();
          }
@@ -20694,7 +21382,7 @@
                p.set_error(
                     make_error(parser_error::e_syntax,
                                p.current_token(),
-                               "ERR117 - Expected '(' for special function"));
+                               "ERR122 - Expected '(' for special function"));
 
                return error_node();
             }
@@ -20714,7 +21402,7 @@
                      p.set_error(
                           make_error(parser_error::e_syntax,
                                      p.current_token(),
-                                     "ERR118 - Expected ',' before next parameter of special function"));
+                                     "ERR123 - Expected ',' before next parameter of special function"));
 
                      return p.error_node();
                   }
@@ -20743,7 +21431,7 @@
             set_error(
                make_error(parser_error::e_token,
                           current_token(),
-                          "ERR119 - Invalid special function[1]: " + current_token().value));
+                          "ERR124 - Invalid special function[1]: " + current_token().value));
 
             return error_node();
          }
@@ -20755,7 +21443,7 @@
             set_error(
                make_error(parser_error::e_token,
                           current_token(),
-                          "ERR120 - Invalid special function[2]: " + current_token().value));
+                          "ERR125 - Invalid special function[2]: " + current_token().value));
 
             return error_node();
          }
@@ -20786,7 +21474,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR121 - Break call within a break call is not allowed"));
+                          "ERR126 - Break call within a break call is not allowed"));
 
             return error_node();
          }
@@ -20808,7 +21496,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR122 - Failed to parse return expression for 'break' statement"));
+                                "ERR127 - Failed to parse return expression for 'break' statement"));
 
                   return error_node();
                }
@@ -20817,7 +21505,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR123 - Expected ']' at the completion of break's return expression"));
+                                "ERR128 - Expected ']' at the completion of break's return expression"));
 
                   free_node(node_allocator_,return_expr);
 
@@ -20834,7 +21522,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR124 - Invalid use of 'break', allowed only in the scope of a loop"));
+                          "ERR129 - Invalid use of 'break', allowed only in the scope of a loop"));
          }
 
          return error_node();
@@ -20856,7 +21544,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR125 - Invalid use of 'continue', allowed only in the scope of a loop"));
+                          "ERR130 - Invalid use of 'continue', allowed only in the scope of a loop"));
 
             return error_node();
          }
@@ -20872,7 +21560,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR126 - Expected '[' as part of vector size definition"));
+                          "ERR131 - Expected '[' as part of vector size definition"));
 
             return error_node();
          }
@@ -20881,7 +21569,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR127 - Failed to determine size of vector '" + vec_name + "'"));
+                          "ERR132 - Failed to determine size of vector '" + vec_name + "'"));
 
             return error_node();
          }
@@ -20892,7 +21580,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR128 - Expected a literal number as size of vector '" + vec_name + "'"));
+                          "ERR133 - Expected a literal number as size of vector '" + vec_name + "'"));
 
             return error_node();
          }
@@ -20910,7 +21598,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR129 - Invalid vector size. Must be an integer greater than zero, size: " +
+                          "ERR134 - Invalid vector size. Must be an integer greater than zero, size: " +
                           details::to_str(details::numeric::to_int32(vector_size))));
 
             return error_node();
@@ -20927,7 +21615,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR130 - Expected ']' as part of vector size definition"));
+                          "ERR135 - Expected ']' as part of vector size definition"));
 
             return error_node();
          }
@@ -20938,7 +21626,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR131 - Expected ':=' as part of vector definition"));
+                             "ERR136 - Expected ':=' as part of vector definition"));
 
                return error_node();
             }
@@ -20951,7 +21639,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR132 - Failed to parse single vector initialiser"));
+                                "ERR137 - Failed to parse single vector initialiser"));
 
                   return error_node();
                }
@@ -20963,7 +21651,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR133 - Expected ']' to close single value vector initialiser"));
+                                "ERR138 - Expected ']' to close single value vector initialiser"));
 
                   return error_node();
                }
@@ -20975,7 +21663,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR134 - Expected '{' as part of vector initialiser list"));
+                             "ERR139 - Expected '{' as part of vector initialiser list"));
 
                return error_node();
             }
@@ -20990,7 +21678,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR135 - Expected '{' as part of vector initialiser list"));
+                                   "ERR140 - Expected '{' as part of vector initialiser list"));
 
                      return error_node();
                   }
@@ -21007,7 +21695,7 @@
                      set_error(
                         make_error(parser_error::e_syntax,
                                    current_token(),
-                                   "ERR136 - Expected ',' between vector initialisers"));
+                                   "ERR141 - Expected ',' between vector initialisers"));
 
                      return error_node();
                   }
@@ -21028,7 +21716,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR137 - Expected ';' at end of vector definition"));
+                                "ERR142 - Expected ';' at end of vector definition"));
 
                   return error_node();
                }
@@ -21039,7 +21727,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR138 - Initialiser list larger than the number of elements in the vector: '" + vec_name + "'"));
+                             "ERR143 - Initialiser list larger than the number of elements in the vector: '" + vec_name + "'"));
 
                return error_node();
             }
@@ -21058,7 +21746,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR139 - Illegal redefinition of local vector: '" + vec_name + "'"));
+                             "ERR144 - Illegal redefinition of local vector: '" + vec_name + "'"));
 
                return error_node();
             }
@@ -21091,7 +21779,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR140 - Failed to add new local vector '" + vec_name + "' to SEM"));
+                             "ERR145 - Failed to add new local vector '" + vec_name + "' to SEM"));
 
                sem_.free_element(nse);
 
@@ -21136,7 +21824,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR141 - Illegal redefinition of local variable: '" + str_name + "'"));
+                             "ERR146 - Illegal redefinition of local variable: '" + str_name + "'"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -21167,7 +21855,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR142 - Failed to add new local string variable '" + str_name + "' to SEM"));
+                             "ERR147 - Failed to add new local string variable '" + str_name + "' to SEM"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -21212,7 +21900,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR143 - Illegal variable definition"));
+                          "ERR148 - Illegal variable definition"));
 
             return error_node();
          }
@@ -21232,7 +21920,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR144 - Expected a symbol for variable definition"));
+                          "ERR149 - Expected a symbol for variable definition"));
 
             return error_node();
          }
@@ -21241,7 +21929,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR145 - Illegal redefinition of reserved keyword: '" + var_name + "'"));
+                          "ERR150 - Illegal redefinition of reserved keyword: '" + var_name + "'"));
 
             return error_node();
          }
@@ -21250,7 +21938,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR146 - Illegal redefinition of variable '" + var_name + "'"));
+                          "ERR151 - Illegal redefinition of variable '" + var_name + "'"));
 
             return error_node();
          }
@@ -21259,7 +21947,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR147 - Illegal redefinition of local variable: '" + var_name + "'"));
+                          "ERR152 - Illegal redefinition of local variable: '" + var_name + "'"));
 
             return error_node();
          }
@@ -21278,7 +21966,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR148 - Failed to parse initialisation expression"));
+                             "ERR153 - Failed to parse initialisation expression"));
 
                return error_node();
             }
@@ -21295,7 +21983,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR149 - Expected ';' after variable definition"));
+                             "ERR154 - Expected ';' after variable definition"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -21322,7 +22010,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR150 - Illegal redefinition of local variable: '" + var_name + "'"));
+                             "ERR155 - Illegal redefinition of local variable: '" + var_name + "'"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -21353,7 +22041,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR151 - Failed to add new local variable '" + var_name + "' to SEM"));
+                             "ERR156 - Failed to add new local variable '" + var_name + "' to SEM"));
 
                free_node(node_allocator_,initialisation_expression);
 
@@ -21389,7 +22077,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR152 - Expected a '{}' for uninitialised var definition"));
+                          "ERR157 - Expected a '{}' for uninitialised var definition"));
 
             return error_node();
          }
@@ -21398,7 +22086,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR153 - Expected ';' after uninitialised variable definition"));
+                          "ERR158 - Expected ';' after uninitialised variable definition"));
 
             return error_node();
          }
@@ -21414,7 +22102,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR154 - Illegal redefinition of local variable: '" + var_name + "'"));
+                             "ERR159 - Illegal redefinition of local variable: '" + var_name + "'"));
 
                return error_node();
             }
@@ -21443,7 +22131,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR155 - Failed to add new local variable '" + var_name + "' to SEM"));
+                             "ERR160 - Failed to add new local variable '" + var_name + "' to SEM"));
 
                sem_.free_element(nse);
 
@@ -21475,7 +22163,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR156 - Expected '(' at start of swap statement"));
+                          "ERR161 - Expected '(' at start of swap statement"));
 
             return error_node();
          }
@@ -21493,7 +22181,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR157 - Expected a symbol for variable or vector element definition"));
+                          "ERR162 - Expected a symbol for variable or vector element definition"));
 
             return error_node();
          }
@@ -21504,7 +22192,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR158 - First parameter to swap is an invalid vector element: '" + var0_name + "'"));
+                             "ERR163 - First parameter to swap is an invalid vector element: '" + var0_name + "'"));
 
                return error_node();
             }
@@ -21536,7 +22224,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR159 - First parameter to swap is an invalid variable: '" + var0_name + "'"));
+                             "ERR164 - First parameter to swap is an invalid variable: '" + var0_name + "'"));
 
                return error_node();
             }
@@ -21549,7 +22237,7 @@
             set_error(
                 make_error(parser_error::e_syntax,
                            current_token(),
-                           "ERR160 - Expected ',' between parameters to swap"));
+                           "ERR165 - Expected ',' between parameters to swap"));
 
             if (variable0_generated)
             {
@@ -21566,7 +22254,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR161 - Expected a symbol for variable or vector element definition"));
+                          "ERR166 - Expected a symbol for variable or vector element definition"));
 
             if (variable0_generated)
             {
@@ -21582,7 +22270,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR162 - Second parameter to swap is an invalid vector element: '" + var1_name + "'"));
+                             "ERR167 - Second parameter to swap is an invalid vector element: '" + var1_name + "'"));
 
                if (variable0_generated)
                {
@@ -21619,7 +22307,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR163 - Second parameter to swap is an invalid variable: '" + var1_name + "'"));
+                             "ERR168 - Second parameter to swap is an invalid variable: '" + var1_name + "'"));
 
                if (variable0_generated)
                {
@@ -21637,7 +22325,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR164 - Expected ')' at end of swap statement"));
+                          "ERR169 - Expected ')' at end of swap statement"));
 
             if (variable0_generated)
             {
@@ -21690,7 +22378,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR165 - Return call within a return call is not allowed"));
+                          "ERR170 - Return call within a return call is not allowed"));
 
             return error_node();
          }
@@ -21713,13 +22401,12 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR166 - Expected '[' at start of return statement"));
+                          "ERR171 - Expected '[' at start of return statement"));
 
             return error_node();
          }
          else if (!token_is(token_t::e_rsqrbracket))
          {
-
             for ( ; ; )
             {
                expression_node_ptr arg = parse_expression();
@@ -21736,7 +22423,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR167 - Expected ',' between values during call to return"));
+                                "ERR172 - Expected ',' between values during call to return"));
 
                   return error_node();
                }
@@ -21747,7 +22434,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR168 - Zero parameter return statement not allowed"));
+                          "ERR173 - Zero parameter return statement not allowed"));
 
             return error_node();
          }
@@ -21761,7 +22448,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              prev_token,
-                             "ERR169 - Invalid ']' found during return call"));
+                             "ERR174 - Invalid ']' found during return call"));
 
                return error_node();
             }
@@ -21807,7 +22494,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR170 - Invalid sequence of variable '"+ symbol + "' and bracket"));
+                             "ERR175 - Invalid sequence of variable '"+ symbol + "' and bracket"));
 
                return false;
             }
@@ -21852,7 +22539,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR171 - Invalid sequence of brackets"));
+                             "ERR176 - Invalid sequence of brackets"));
 
                return false;
             }
@@ -21953,7 +22640,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR172 - Failed to generate node for function: '" + symbol + "'"));
+                                "ERR177 - Failed to generate node for function: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -21978,7 +22665,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR173 - Failed to generate node for vararg function: '" + symbol + "'"));
+                                "ERR178 - Failed to generate node for vararg function: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22003,7 +22690,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR174 - Failed to generate node for generic function: '" + symbol + "'"));
+                                "ERR179 - Failed to generate node for generic function: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22028,7 +22715,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR175 - Failed to generate node for string function: '" + symbol + "'"));
+                                "ERR180 - Failed to generate node for string function: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22049,7 +22736,7 @@
                   set_error(
                      make_error(parser_error::e_syntax,
                                 current_token(),
-                                "ERR176 - Invalid use of reserved symbol '" + symbol + "'"));
+                                "ERR181 - Invalid use of reserved symbol '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22106,7 +22793,7 @@
                   set_error(
                      make_error(parser_error::e_symtab,
                                 current_token(),
-                                "ERR177 - Failed to create variable: '" + symbol + "'"));
+                                "ERR182 - Failed to create variable: '" + symbol + "'"));
 
                   return error_node();
                }
@@ -22116,7 +22803,7 @@
          set_error(
             make_error(parser_error::e_syntax,
                        current_token(),
-                       "ERR178 - Undefined symbol: '" + symbol + "'"));
+                       "ERR183 - Undefined symbol: '" + symbol + "'"));
 
          return error_node();
       }
@@ -22217,7 +22904,7 @@
             set_error(
                make_error(parser_error::e_symtab,
                           current_token(),
-                          "ERR179 - Variable or function detected, yet symbol-table is invalid, Symbol: " + current_token().value));
+                          "ERR184 - Variable or function detected, yet symbol-table is invalid, Symbol: " + current_token().value));
 
             return error_node();
          }
@@ -22242,7 +22929,7 @@
                set_error(
                   make_error(parser_error::e_numeric,
                              current_token(),
-                             "ERR180 - Failed to convert '" + current_token().value + "' to a number"));
+                             "ERR185 - Failed to convert '" + current_token().value + "' to a number"));
 
                return error_node();
             }
@@ -22268,7 +22955,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR181 - Expected ')' instead of: '" + current_token().value + "'"));
+                             "ERR186 - Expected ')' instead of: '" + current_token().value + "'"));
 
                free_node(node_allocator_,branch);
 
@@ -22292,7 +22979,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR182 - Expected ']' instead of: '" + current_token().value + "'"));
+                             "ERR187 - Expected ']' instead of: '" + current_token().value + "'"));
 
                free_node(node_allocator_,branch);
 
@@ -22316,7 +23003,7 @@
                set_error(
                   make_error(parser_error::e_syntax,
                              current_token(),
-                             "ERR183 - Expected '}' instead of: '" + current_token().value + "'"));
+                             "ERR188 - Expected '}' instead of: '" + current_token().value + "'"));
 
                free_node(node_allocator_,branch);
 
@@ -22355,7 +23042,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR184 - Premature end of expression[1]"));
+                          "ERR189 - Premature end of expression[1]"));
 
             return error_node();
          }
@@ -22364,7 +23051,7 @@
             set_error(
                make_error(parser_error::e_syntax,
                           current_token(),
-                          "ERR185 - Premature end of expression[2]"));
+                          "ERR190 - Premature end of expression[2]"));
 
             return error_node();
          }
@@ -22547,6 +23234,7 @@
             return node_allocator_->allocate<literal_node_t>(v);
          }
 
+         #ifndef exprtk_disable_string_capabilities
          inline expression_node_ptr operator()(const std::string& s) const
          {
             return node_allocator_->allocate<string_literal_node_t>(s);
@@ -22569,6 +23257,7 @@
             else
                return error_node();
          }
+         #endif
 
          inline bool unary_optimizable(const details::operator_type& operation) const
          {
@@ -22664,11 +23353,14 @@
 
          inline bool is_assignment_operation(const details::operator_type& operation) const
          {
-            return (details::e_addass == operation) ||
-                   (details::e_subass == operation) ||
-                   (details::e_mulass == operation) ||
-                   (details::e_divass == operation) ||
-                   (details::e_modass == operation) ;
+            return (
+                      (details::e_addass == operation) ||
+                      (details::e_subass == operation) ||
+                      (details::e_mulass == operation) ||
+                      (details::e_divass == operation) ||
+                      (details::e_modass == operation)
+                   ) &&
+                   parser_->settings_.assignment_enabled(operation);
          }
 
          #ifndef exprtk_disable_string_capabilities
@@ -23236,8 +23928,6 @@
                         allocate<conditional_string_node_t>(condition,consequent,alternative);
             else
                return error_node();
-               //return node_allocator_->
-               //         allocate<cons_conditional_str_node_t>(condition,consequent);
          }
          #else
          inline expression_node_ptr conditional_string(expression_node_ptr ,
@@ -23530,6 +24220,7 @@
                     )
             {
                details::free_all_nodes(*node_allocator_,arg_list);
+
                return error_node();
             }
             else if (is_constant_foldable(arg_list))
@@ -23704,7 +24395,7 @@
             }
 
             T v = temp_node->value();
-            node_allocator_->free(temp_node);
+
             details::free_node(*node_allocator_,temp_node);
 
             return node_allocator_->allocate<literal_node_t>(v);
@@ -24217,19 +24908,24 @@
                )
             {
                strfunc_node_ptr->init_branches();
+
                Type v = result->value();
+
                details::free_node(*node_allocator_,result);
+
                return node_allocator_->allocate<literal_node_t>(v);
             }
             else if (strfunc_node_ptr->init_branches())
             {
                parser_->state_.activate_side_effect("string_function_call()");
+
                return result;
             }
             else
             {
                details::free_node(*node_allocator_,result);
                details::free_all_nodes(*node_allocator_,arg_list);
+
                return error_node();
             }
          }
@@ -24252,12 +24948,14 @@
             if (return_node_ptr->init_branches())
             {
                parser_->state_.activate_side_effect("return_call()");
+
                return result;
             }
             else
             {
                details::free_node(*node_allocator_,result);
                details::free_all_nodes(*node_allocator_,arg_list);
+
                return error_node();
             }
          }
@@ -24285,7 +24983,9 @@
             if (details::is_constant_node(index))
             {
                std::size_t i = static_cast<std::size_t>(details::numeric::to_int64(index->value()));
+
                details::free_node(*node_allocator_,index);
+
                Type* v = (*vector_base)[i];
 
                scope_element& se = parser_->sem_.get_element(symbol,i);
@@ -24323,7 +25023,7 @@
                }
             }
             else
-               result = node_allocator_->allocate<details::vector_elem_node<Type> >(index,(*vector_base)[0]);
+               result = node_allocator_->allocate<details::vector_elem_node<Type> >(index,vector_base);
 
             return result;
          }
@@ -24390,6 +25090,17 @@
                                     }
                                     break;
 
+               case e_st_vecelem   : {
+                                       typedef details::vector_holder<T> vector_holder_t;
+
+                                       vector_holder_t& vh = static_cast<vector_elem_node_t*>(node)->vec_holder();
+
+                                       symbol_name = parser_->symtab_store_.get_vector_name(&vh);
+
+                                       cst = e_st_vector;
+                                    }
+                                    break;
+
                default            : return;
             }
 
@@ -24408,7 +25119,11 @@
                return synthesize_expression<assignment_node_t,2>(operation,branch);
             }
             else if (details::is_vector_elem_node(branch[0]))
-               return synthesize_expression<assignment_vec_elem_node_t,2>(operation,branch);
+            {
+               lodge_assignment(e_st_vecelem,branch[0]);
+
+               return synthesize_expression<assignment_vec_elem_node_t, 2>(operation, branch);
+            }
             #ifndef exprtk_disable_string_capabilities
             else if (details::is_string_node(branch[0]))
             {
@@ -25179,8 +25894,26 @@
                                                       expression_node_ptr (&branch)[2])
             {
                const Type c = static_cast<details::literal_node<Type>*>(branch[0])->value();
+
                free_node(*expr_gen.node_allocator_,branch[0]);
 
+               if ((T(0) == c) && (details::e_mul == operation))
+               {
+                  free_node(*expr_gen.node_allocator_,branch[1]);
+
+                  return expr_gen(T(0));
+               }
+               else if ((T(0) == c) && (details::e_div == operation))
+               {
+                  free_node(*expr_gen.node_allocator_, branch[1]);
+
+                  return expr_gen(T(0));
+               }
+               else if ((T(0) == c) && (details::e_add == operation))
+                  return branch[1];
+               else if ((T(1) == c) && (details::e_mul == operation))
+                  return branch[1];
+
                if (details::is_cob_node(branch[1]))
                {
                   // Simplify expressions of the form:
@@ -25295,8 +26028,26 @@
                                                       expression_node_ptr (&branch)[2])
             {
                const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
+
                details::free_node(*(expr_gen.node_allocator_),branch[1]);
 
+               if ((T(0) == c) && (details::e_mul == operation))
+               {
+                  free_node(*expr_gen.node_allocator_,branch[0]);
+
+                  return expr_gen(T(0));
+               }
+               else if ((T(0) == c) && (details::e_div == operation))
+               {
+                  free_node(*expr_gen.node_allocator_, branch[0]);
+
+                  return expr_gen(std::numeric_limits<T>::quiet_NaN());
+               }
+               else if ((T(0) == c) && (details::e_add == operation))
+                  return branch[0];
+               else if ((T(1) == c) && (details::e_mul == operation))
+                  return branch[0];
+
                if (details::is_boc_node(branch[0]))
                {
                   // Simplify expressions of the form:
@@ -25386,6 +26137,36 @@
                   details::cob_base_node<Type>* cobnode = static_cast<details::cob_base_node<Type>*>(branch[0]);
                   const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
 
+                  if ((T(0) == c) && (details::e_mul == operation))
+                  {
+                     free_node(*expr_gen.node_allocator_,branch[0]);
+                     free_node(*expr_gen.node_allocator_,branch[1]);
+
+                     return expr_gen(T(0));
+                  }
+                  else if ((T(0) == c) && (details::e_div == operation))
+                  {
+                     free_node(*expr_gen.node_allocator_,branch[0]);
+                     free_node(*expr_gen.node_allocator_,branch[1]);
+
+                     return expr_gen(T(std::numeric_limits<T>::quiet_NaN()));
+                  }
+                  else if ((T(0) == c) && (details::e_add == operation))
+                  {
+                     free_node(*expr_gen.node_allocator_, branch[1]);
+                     return branch[0];
+                  }
+                  else if ((T(1) == c) && (details::e_mul == operation))
+                  {
+                     free_node(*expr_gen.node_allocator_, branch[1]);
+                     return branch[0];
+                  }
+                  else if ((T(1) == c) && (details::e_div == operation))
+                  {
+                     free_node(*expr_gen.node_allocator_, branch[1]);
+                     return branch[0];
+                  }
+
                   bool op_addsub = (details::e_add == cobnode->operation()) ||
                                    (details::e_sub == cobnode->operation());
 
@@ -25439,6 +26220,31 @@
                   details::cob_base_node<Type>* cobnode = static_cast<details::cob_base_node<Type>*>(branch[1]);
                   const Type c = static_cast<details::literal_node<Type>*>(branch[0])->value();
 
+                  if ((T(0) == c) && (details::e_mul == operation))
+                  {
+                     free_node(*expr_gen.node_allocator_,branch[0]);
+                     free_node(*expr_gen.node_allocator_,branch[1]);
+
+                     return expr_gen(T(0));
+                  }
+                  else if ((T(0) == c) && (details::e_div == operation))
+                  {
+                     free_node(*expr_gen.node_allocator_,branch[0]);
+                     free_node(*expr_gen.node_allocator_,branch[1]);
+
+                     return expr_gen(T(0));
+                  }
+                  else if ((T(0) == c) && (details::e_add == operation))
+                  {
+                     free_node(*expr_gen.node_allocator_, branch[0]);
+                     return branch[1];
+                  }
+                  else if ((T(1) == c) && (details::e_mul == operation))
+                  {
+                     free_node(*expr_gen.node_allocator_, branch[0]);
+                     return branch[1];
+                  }
+
                   if (details::e_add == cobnode->operation())
                   {
                      if (details::e_add == operation)
@@ -25716,6 +26522,15 @@
 
                details::free_node(*(expr_gen.node_allocator_),branch[0]);
 
+               if ((T(0) == c) && (details::e_mul == operation))
+                  return expr_gen(T(0));
+               else if ((T(0) == c) && (details::e_div == operation))
+                  return expr_gen(T(0));
+               else if ((T(0) == c) && (details::e_add == operation))
+                  return static_cast<details::variable_node<Type>*>(branch[1]);
+               else if ((T(1) == c) && (details::e_mul == operation))
+                  return static_cast<details::variable_node<Type>*>(branch[1]);
+
                switch (operation)
                {
                   #define case_stmt(op0,op1)                                                       \
@@ -25749,6 +26564,16 @@
                   else
                      return expr_gen.cardinal_pow_optimization(v,c);
                }
+               else if ((T(0) == c) && (details::e_mul == operation))
+                  return expr_gen(T(0));
+               else if ((T(0) == c) && (details::e_div == operation))
+                  return expr_gen(std::numeric_limits<T>::quiet_NaN());
+               else if ((T(0) == c) && (details::e_add == operation))
+                  return static_cast<details::variable_node<Type>*>(branch[0]);
+               else if ((T(1) == c) && (details::e_mul == operation))
+                  return static_cast<details::variable_node<Type>*>(branch[0]);
+               else if ((T(1) == c) && (details::e_div == operation))
+                  return static_cast<details::variable_node<Type>*>(branch[0]);
 
                switch (operation)
                {
@@ -25876,6 +26701,7 @@
                   case_stmt(details::e_sf4ext54,details::sfext54_op) case_stmt(details::e_sf4ext55,details::sfext55_op)
                   case_stmt(details::e_sf4ext56,details::sfext56_op) case_stmt(details::e_sf4ext57,details::sfext57_op)
                   case_stmt(details::e_sf4ext58,details::sfext58_op) case_stmt(details::e_sf4ext59,details::sfext59_op)
+                  case_stmt(details::e_sf4ext60,details::sfext60_op)
 
                   #undef case_stmt
                   default : return error_node();
@@ -26993,6 +27819,39 @@
 
                      return (synthesis_result) ? result : error_node();
                   }
+                  // (v0 + v1) / (v2 / v3) --> (vovovov) (v0 + v1) * (v3 / v2)
+                  else if ((details::e_add == o0) && (details::e_div == o1) && (details::e_div == o2))
+                  {
+                     const bool synthesis_result =
+                        synthesize_sf4ext_expression::
+                           template compile<vtype,vtype,vtype,vtype>(expr_gen,"(t+t)*(t/t)",v0,v1,v3,v2,result);
+
+                     exprtk_debug(("(v0 + v1) / (v2 / v3) --> (vovovov) (v0 + v1) * (v3 / v2)\n"));
+
+                     return (synthesis_result) ? result : error_node();
+                  }
+                  // (v0 - v1) / (v2 / v3) --> (vovovov) (v0 + v1) * (v3 / v2)
+                  else if ((details::e_sub == o0) && (details::e_div == o1) && (details::e_div == o2))
+                  {
+                     const bool synthesis_result =
+                        synthesize_sf4ext_expression::
+                           template compile<vtype,vtype,vtype,vtype>(expr_gen,"(t-t)*(t/t)",v0,v1,v3,v2,result);
+
+                     exprtk_debug(("(v0 - v1) / (v2 / v3) --> (vovovov) (v0 - v1) * (v3 / v2)\n"));
+
+                     return (synthesis_result) ? result : error_node();
+                  }
+                  // (v0 * v1) / (v2 / v3) --> (vovovov) ((v0 * v1) * v3) / v2
+                  else if ((details::e_mul == o0) && (details::e_div == o1) && (details::e_div == o2))
+                  {
+                     const bool synthesis_result =
+                        synthesize_sf4ext_expression::
+                           template compile<vtype,vtype,vtype,vtype>(expr_gen,"((t*t)*t)/t",v0,v1,v3,v2,result);
+
+                     exprtk_debug(("(v0 * v1) / (v2 / v3) --> (vovovov) ((v0 * v1) * v3) / v2\n"));
+
+                     return (synthesis_result) ? result : error_node();
+                  }
                }
 
                if (synthesize_sf4ext_expression::template compile<T0,T1,T2,T3>(expr_gen,id(expr_gen,o0,o1,o2),v0,v1,v2,v3,result))
@@ -27727,7 +28586,7 @@
 
                      const bool synthesis_result =
                         synthesize_sf3ext_expression::
-                           template compile<ctype,vtype,vtype>(expr_gen,specfunc,c0,v0,v1,result);
+                           template compile<vtype,vtype,ctype>(expr_gen,specfunc,v0,v1,c0,result);
 
                      exprtk_debug(("(v0 / c) +/- (v1 / c) --> (vovoc) (v0 +/- v1) / c\n"));
 
@@ -28086,6 +28945,7 @@
                           )
                   {
                      std::string specfunc;
+
                      switch (o1)
                      {
                         case details::e_add : specfunc = "t*(t+t)"; break;
@@ -28138,9 +28998,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 (v1 o1 (v2 o2 v3))
-               typedef typename synthesize_vovov_expression1::node_type vovov_t;
+               typedef typename synthesize_vovov_expression1::node_type lcl_vovov_t;
 
-               const vovov_t* vovov = static_cast<const vovov_t*>(branch[1]);
+               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type& v1 = vovov->t0();
                const Type& v2 = vovov->t1();
@@ -28190,9 +29050,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 (v1 o1 (v2 o2 c))
-               typedef typename synthesize_vovoc_expression1::node_type vovoc_t;
+               typedef typename synthesize_vovoc_expression1::node_type lcl_vovoc_t;
 
-               const vovoc_t* vovoc = static_cast<const vovoc_t*>(branch[1]);
+               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type& v1 = vovoc->t0();
                const Type& v2 = vovoc->t1();
@@ -28242,9 +29102,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 (v1 o1 (c o2 v2))
-               typedef typename synthesize_vocov_expression1::node_type vocov_t;
+               typedef typename synthesize_vocov_expression1::node_type lcl_vocov_t;
 
-               const vocov_t* vocov = static_cast<const vocov_t*>(branch[1]);
+               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type& v1 = vocov->t0();
                const Type   c = vocov->t1();
@@ -28294,9 +29154,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 (c o1 (v1 o2 v2))
-               typedef typename synthesize_covov_expression1::node_type covov_t;
+               typedef typename synthesize_covov_expression1::node_type lcl_covov_t;
 
-               const covov_t* covov = static_cast<const covov_t*>(branch[1]);
+               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type   c = covov->t0();
                const Type& v1 = covov->t1();
@@ -28346,9 +29206,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // c o0 (v0 o1 (v1 o2 v2))
-               typedef typename synthesize_vovov_expression1::node_type vovov_t;
+               typedef typename synthesize_vovov_expression1::node_type lcl_vovov_t;
 
-               const vovov_t* vovov = static_cast<const vovov_t*>(branch[1]);
+               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[1]);
                const Type   c = static_cast<details::literal_node<Type>*>(branch[0])->value();
                const Type& v0 = vovov->t0();
                const Type& v1 = vovov->t1();
@@ -28399,9 +29259,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // c0 o0 (v0 o1 (c1 o2 v1))
-               typedef typename synthesize_vocov_expression1::node_type vocov_t;
+               typedef typename synthesize_vocov_expression1::node_type lcl_vocov_t;
 
-               const vocov_t* vocov = static_cast<const vocov_t*>(branch[1]);
+               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[1]);
                const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
                const Type& v0 = vocov->t0();
                const Type  c1 = vocov->t1();
@@ -28452,9 +29312,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 (c0 o1 (v1 o2 c2))
-               typedef typename synthesize_covoc_expression1::node_type covoc_t;
+               typedef typename synthesize_covoc_expression1::node_type lcl_covoc_t;
 
-               const covoc_t* covoc = static_cast<const covoc_t*>(branch[1]);
+               const lcl_covoc_t* covoc = static_cast<const lcl_covoc_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type  c0 = covoc->t0();
                const Type& v1 = covoc->t1();
@@ -28503,9 +29363,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // c0 o0 (v0 o1 (v1 o2 c1))
-               typedef typename synthesize_vovoc_expression1::node_type vovoc_t;
+               typedef typename synthesize_vovoc_expression1::node_type lcl_vovoc_t;
 
-               const vovoc_t* vovoc = static_cast<const vovoc_t*>(branch[1]);
+               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[1]);
                const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
                const Type& v0 = vovoc->t0();
                const Type& v1 = vovoc->t1();
@@ -28556,9 +29416,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 (c0 o1 (c1 o2 v1))
-               typedef typename synthesize_cocov_expression1::node_type cocov_t;
+               typedef typename synthesize_cocov_expression1::node_type lcl_cocov_t;
 
-               const cocov_t* cocov = static_cast<const cocov_t*>(branch[1]);
+               const lcl_cocov_t* cocov = static_cast<const lcl_cocov_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type  c0 = cocov->t0();
                const Type  c1 = cocov->t1();
@@ -28608,9 +29468,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 ((v1 o1 v2) o2 v3)
-               typedef typename synthesize_vovov_expression0::node_type vovov_t;
+               typedef typename synthesize_vovov_expression0::node_type lcl_vovov_t;
 
-               const vovov_t* vovov = static_cast<const vovov_t*>(branch[1]);
+               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type& v1 = vovov->t0();
                const Type& v2 = vovov->t1();
@@ -28660,9 +29520,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 ((v1 o1 v2) o2 c)
-               typedef typename synthesize_vovoc_expression0::node_type vovoc_t;
+               typedef typename synthesize_vovoc_expression0::node_type lcl_vovoc_t;
 
-               const vovoc_t* vovoc = static_cast<const vovoc_t*>(branch[1]);
+               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type& v1 = vovoc->t0();
                const Type& v2 = vovoc->t1();
@@ -28712,9 +29572,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 ((v1 o1 c) o2 v2)
-               typedef typename synthesize_vocov_expression0::node_type vocov_t;
+               typedef typename synthesize_vocov_expression0::node_type lcl_vocov_t;
 
-               const vocov_t* vocov = static_cast<const vocov_t*>(branch[1]);
+               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type& v1 = vocov->t0();
                const Type   c = vocov->t1();
@@ -28764,9 +29624,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 ((c o1 v1) o2 v2)
-               typedef typename synthesize_covov_expression0::node_type covov_t;
+               typedef typename synthesize_covov_expression0::node_type lcl_covov_t;
 
-               const covov_t* covov = static_cast<const covov_t*>(branch[1]);
+               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type   c = covov->t0();
                const Type& v1 = covov->t1();
@@ -28816,9 +29676,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // c o0 ((v1 o1 v2) o2 v3)
-               typedef typename synthesize_vovov_expression0::node_type vovov_t;
+               typedef typename synthesize_vovov_expression0::node_type lcl_vovov_t;
 
-               const vovov_t* vovov = static_cast<const vovov_t*>(branch[1]);
+               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[1]);
                const Type   c = static_cast<details::literal_node<Type>*>(branch[0])->value();
                const Type& v0 = vovov->t0();
                const Type& v1 = vovov->t1();
@@ -28869,9 +29729,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // c0 o0 ((v0 o1 c1) o2 v1)
-               typedef typename synthesize_vocov_expression0::node_type vocov_t;
+               typedef typename synthesize_vocov_expression0::node_type lcl_vocov_t;
 
-               const vocov_t* vocov = static_cast<const vocov_t*>(branch[1]);
+               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[1]);
                const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
                const Type& v0 = vocov->t0();
                const Type  c1 = vocov->t1();
@@ -28922,9 +29782,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // v0 o0 ((c0 o1 v1) o2 c1)
-               typedef typename synthesize_covoc_expression0::node_type covoc_t;
+               typedef typename synthesize_covoc_expression0::node_type lcl_covoc_t;
 
-               const covoc_t* covoc = static_cast<const covoc_t*>(branch[1]);
+               const lcl_covoc_t* covoc = static_cast<const lcl_covoc_t*>(branch[1]);
                const Type& v0 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
                const Type  c0 = covoc->t0();
                const Type& v1 = covoc->t1();
@@ -28974,9 +29834,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // c0 o0 ((v0 o1 v1) o2 c1)
-               typedef typename synthesize_vovoc_expression0::node_type vovoc_t;
+               typedef typename synthesize_vovoc_expression0::node_type lcl_vovoc_t;
 
-               const vovoc_t* vovoc = static_cast<const vovoc_t*>(branch[1]);
+               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[1]);
                const Type  c0 = static_cast<details::literal_node<Type>*>(branch[0])->value();
                const Type& v0 = vovoc->t0();
                const Type& v1 = vovoc->t1();
@@ -29044,9 +29904,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 v1) o1 v2) o2 v3
-               typedef typename synthesize_vovov_expression0::node_type vovov_t;
+               typedef typename synthesize_vovov_expression0::node_type lcl_vovov_t;
 
-               const vovov_t* vovov = static_cast<const vovov_t*>(branch[0]);
+               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[0]);
                const Type& v0 = vovov->t0();
                const Type& v1 = vovov->t1();
                const Type& v2 = vovov->t2();
@@ -29096,9 +29956,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 v1) o1 v2) o2 c
-               typedef typename synthesize_vovov_expression0::node_type vovov_t;
+               typedef typename synthesize_vovov_expression0::node_type lcl_vovov_t;
 
-               const vovov_t* vovov = static_cast<const vovov_t*>(branch[0]);
+               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[0]);
                const Type& v0 = vovov->t0();
                const Type& v1 = vovov->t1();
                const Type& v2 = vovov->t2();
@@ -29149,9 +30009,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 v1) o1 c) o2 v2
-               typedef typename synthesize_vovoc_expression0::node_type vovoc_t;
+               typedef typename synthesize_vovoc_expression0::node_type lcl_vovoc_t;
 
-               const vovoc_t* vovoc = static_cast<const vovoc_t*>(branch[0]);
+               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[0]);
                const Type& v0 = vovoc->t0();
                const Type& v1 = vovoc->t1();
                const Type   c = vovoc->t2();
@@ -29201,9 +30061,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 c) o1 v1) o2 v2
-               typedef typename synthesize_vocov_expression0::node_type vocov_t;
+               typedef typename synthesize_vocov_expression0::node_type lcl_vocov_t;
 
-               const vocov_t* vocov = static_cast<const vocov_t*>(branch[0]);
+               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[0]);
                const Type& v0 = vocov->t0();
                const Type   c = vocov->t1();
                const Type& v1 = vocov->t2();
@@ -29253,9 +30113,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((c o0 v0) o1 v1) o2 v2
-               typedef typename synthesize_covov_expression0::node_type covov_t;
+               typedef typename synthesize_covov_expression0::node_type lcl_covov_t;
 
-               const covov_t* covov = static_cast<const covov_t*>(branch[0]);
+               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[0]);
                const Type   c = covov->t0();
                const Type& v0 = covov->t1();
                const Type& v1 = covov->t2();
@@ -29305,9 +30165,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((c0 o0 v0) o1 c1) o2 v1
-               typedef typename synthesize_covoc_expression0::node_type covoc_t;
+               typedef typename synthesize_covoc_expression0::node_type lcl_covoc_t;
 
-               const covoc_t* covoc = static_cast<const covoc_t*>(branch[0]);
+               const lcl_covoc_t* covoc = static_cast<const lcl_covoc_t*>(branch[0]);
                const Type  c0 = covoc->t0();
                const Type& v0 = covoc->t1();
                const Type  c1 = covoc->t2();
@@ -29357,9 +30217,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 c0) o1 v1) o2 c1
-               typedef typename synthesize_vocov_expression0::node_type vocov_t;
+               typedef typename synthesize_vocov_expression0::node_type lcl_vocov_t;
 
-               const vocov_t* vocov = static_cast<const vocov_t*>(branch[0]);
+               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[0]);
                const Type& v0 = vocov->t0();
                const Type  c0 = vocov->t1();
                const Type& v1 = vocov->t2();
@@ -29410,9 +30270,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((c0 o0 v0) o1 v1) o2 c1
-               typedef typename synthesize_covov_expression0::node_type covov_t;
+               typedef typename synthesize_covov_expression0::node_type lcl_covov_t;
 
-               const covov_t* covov = static_cast<const covov_t*>(branch[0]);
+               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[0]);
                const Type  c0 = covov->t0();
                const Type& v0 = covov->t1();
                const Type& v1 = covov->t2();
@@ -29463,9 +30323,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 c0) o1 c1) o2 v1
-               typedef typename synthesize_vococ_expression0::node_type vococ_t;
+               typedef typename synthesize_vococ_expression0::node_type lcl_vococ_t;
 
-               const vococ_t* vococ = static_cast<const vococ_t*>(branch[0]);
+               const lcl_vococ_t* vococ = static_cast<const lcl_vococ_t*>(branch[0]);
                const Type& v0 = vococ->t0();
                const Type  c0 = vococ->t1();
                const Type  c1 = vococ->t2();
@@ -29515,9 +30375,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // (v0 o0 (v1 o1 v2)) o2 v3
-               typedef typename synthesize_vovov_expression1::node_type vovov_t;
+               typedef typename synthesize_vovov_expression1::node_type lcl_vovov_t;
 
-               const vovov_t* vovov = static_cast<const vovov_t*>(branch[0]);
+               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[0]);
                const Type& v0 = vovov->t0();
                const Type& v1 = vovov->t1();
                const Type& v2 = vovov->t2();
@@ -29567,9 +30427,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 (v1 o1 v2)) o2 c)
-               typedef typename synthesize_vovov_expression1::node_type vovov_t;
+               typedef typename synthesize_vovov_expression1::node_type lcl_vovov_t;
 
-               const vovov_t* vovov = static_cast<const vovov_t*>(branch[0]);
+               const lcl_vovov_t* vovov = static_cast<const lcl_vovov_t*>(branch[0]);
                const Type& v0 = vovov->t0();
                const Type& v1 = vovov->t1();
                const Type& v2 = vovov->t2();
@@ -29620,9 +30480,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 (v1 o1 c)) o2 v1)
-               typedef typename synthesize_vovoc_expression1::node_type vovoc_t;
+               typedef typename synthesize_vovoc_expression1::node_type lcl_vovoc_t;
 
-               const vovoc_t* vovoc = static_cast<const vovoc_t*>(branch[0]);
+               const lcl_vovoc_t* vovoc = static_cast<const lcl_vovoc_t*>(branch[0]);
                const Type& v0 = vovoc->t0();
                const Type& v1 = vovoc->t1();
                const Type   c = vovoc->t2();
@@ -29672,9 +30532,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 (c o1 v1)) o2 v2)
-               typedef typename synthesize_vocov_expression1::node_type vocov_t;
+               typedef typename synthesize_vocov_expression1::node_type lcl_vocov_t;
 
-               const vocov_t* vocov = static_cast<const vocov_t*>(branch[0]);
+               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[0]);
                const Type& v0 = vocov->t0();
                const Type   c = vocov->t1();
                const Type& v1 = vocov->t2();
@@ -29723,9 +30583,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((c o0 (v0 o1 v1)) o2 v2)
-               typedef typename synthesize_covov_expression1::node_type covov_t;
+               typedef typename synthesize_covov_expression1::node_type lcl_covov_t;
 
-               const covov_t* covov = static_cast<const covov_t*>(branch[0]);
+               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[0]);
                const Type   c = covov->t0();
                const Type& v0 = covov->t1();
                const Type& v1 = covov->t2();
@@ -29775,9 +30635,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((c0 o0 (v0 o1 c1)) o2 v1)
-               typedef typename synthesize_covoc_expression1::node_type covoc_t;
+               typedef typename synthesize_covoc_expression1::node_type lcl_covoc_t;
 
-               const covoc_t* covoc = static_cast<const covoc_t*>(branch[0]);
+               const lcl_covoc_t* covoc = static_cast<const lcl_covoc_t*>(branch[0]);
                const Type  c0 = covoc->t0();
                const Type& v0 = covoc->t1();
                const Type  c1 = covoc->t2();
@@ -29827,9 +30687,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((v0 o0 (c0 o1 v1)) o2 c1)
-               typedef typename synthesize_vocov_expression1::node_type vocov_t;
+               typedef typename synthesize_vocov_expression1::node_type lcl_vocov_t;
 
-               const vocov_t* vocov = static_cast<const vocov_t*>(branch[0]);
+               const lcl_vocov_t* vocov = static_cast<const lcl_vocov_t*>(branch[0]);
                const Type& v0 = vocov->t0();
                const Type  c0 = vocov->t1();
                const Type& v1 = vocov->t2();
@@ -29880,9 +30740,9 @@
                                                       expression_node_ptr (&branch)[2])
             {
                // ((c0 o0 (v0 o1 v1)) o2 c1)
-               typedef typename synthesize_covov_expression1::node_type covov_t;
+               typedef typename synthesize_covov_expression1::node_type lcl_covov_t;
 
-               const covov_t* covov = static_cast<const covov_t*>(branch[0]);
+               const lcl_covov_t* covov = static_cast<const lcl_covov_t*>(branch[0]);
                const Type  c0 = covov->t0();
                const Type& v0 = covov->t1();
                const Type& v1 = covov->t2();
@@ -30958,6 +31818,7 @@
          register_sf4ext(48) register_sf4ext(49) register_sf4ext(50) register_sf4ext(51)
          register_sf4ext(52) register_sf4ext(53) register_sf4ext(54) register_sf4ext(55)
          register_sf4ext(56) register_sf4ext(57) register_sf4ext(58) register_sf4ext(59)
+         register_sf4ext(60)
          #undef register_sf4ext
       }
 
@@ -31474,6 +32335,9 @@
          disable_has_side_effects(*this);
       }
 
+      virtual ~polynomial()
+      {}
+
       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());
@@ -32704,9 +33568,9 @@
    namespace information
    {
       static const char* library = "Mathematical Expression Toolkit";
-      static const char* version = "2.71828182845904523536028747135"
-                                   "2662497757247093699959574966967";
-      static const char* date    = "20150505";
+      static const char* version = "2.7182818284590452353602874713526"
+                                   "624977572470936999595749669676277";
+      static const char* date    = "20150731";
 
       static inline std::string data()
       {
diff --git a/exprtk_test.cpp b/exprtk_test.cpp
index 93a3d10..e5f7b32 100644
--- a/exprtk_test.cpp
+++ b/exprtk_test.cpp
@@ -32,7 +32,7 @@
 typedef double numeric_type;
 typedef std::pair<std::string,numeric_type> test_t;
 
-static const test_t test_list[] =
+static const test_t global_test_list[] =
                   {
                     // Note: Each of following tests must compile down
                     // to a single literal node.
@@ -1061,7 +1061,7 @@
                     test_t("if (1 > 2) { 1+2; 3;} else if (1 > 2) {1+2; 4;} == null",1.0)
                   };
 
-static const std::size_t test_list_size = sizeof(test_list) / sizeof(test_t);
+static const std::size_t global_test_list_size = sizeof(global_test_list) / sizeof(test_t);
 
 template <typename T>
 inline bool not_equal_impl(const T& t1,
@@ -1165,9 +1165,9 @@
    for (std::size_t r = 0; r < rounds; ++r)
    {
       bool result = true;
-      for (std::size_t i = 0; i < test_list_size; ++i)
+      for (std::size_t i = 0; i < global_test_list_size; ++i)
       {
-         if (!test_expression<T>(test_list[i].first,T(test_list[i].second)))
+         if (!test_expression<T>(global_test_list[i].first,T(global_test_list[i].second)))
          {
             result = false;
          }
@@ -1576,7 +1576,14 @@
                                 test_xy<T>("for(var i := 0; (i < 10) and (i != y); i+=2) { x += i; }; x;" ,T(1),T(20),T(21)),
                                 test_xy<T>("for(var i := 0; (i < 10) and (i != y);) { x += i; i+=2; }; x;",T(1),T(20),T(21)),
                                 test_xy<T>("for(var i := 0; (i < y); i += 1) { if (i <= (y / 2)) x += i; else break; }; x;" ,T(0),T(10),T(15)),
-                                test_xy<T>("for(var i := 0; (i < y); i += 1) { if (i <= (y / 2)) continue; else x += i; }; x;" ,T(0),T(10),T(30))
+                                test_xy<T>("for(var i := 0; (i < y); i += 1) { if (i <= (y / 2)) continue; else x += i; }; x;" ,T(0),T(10),T(30)),
+                                test_xy<T>("var a := 2; (0 * a) == 0",T(0),T(0),T(1)),
+                                test_xy<T>("var a := 2; (0 / a) == 0",T(0),T(0),T(1)),
+                                test_xy<T>("var a := 2; (a * 0) == 0",T(0),T(0),T(1)),
+                                test_xy<T>("var a := 2; (a / 1) == a",T(0),T(0),T(1)),
+                                test_xy<T>("var a := 2; (0 + a) == a",T(0),T(0),T(1)),
+                                test_xy<T>("var a := 2; (a + 0) == a",T(0),T(0),T(1)),
+                                test_xy<T>("var a := 2; (1 * a) == a",T(0),T(0),T(1))
                               };
 
       static const std::size_t test_list_size = sizeof(test_list) / sizeof(test_xy<T>);
@@ -2270,81 +2277,112 @@
                              test_ab<T>("'a\\'\\\\b' == a" ,"a'\\b","",T(1.0)),
                              test_ab<T>("'a\\\\\\'b' == a" ,"a\\'b","",T(1.0)),
                              test_ab<T>("'a\\'\\\\\\\\b' == a" ,"a'\\\\b","",T(1.0)),
-                             test_ab<T>("'a\\0x30\\'\\0x31\\\\\\0x32b' == a" ,"a0'1\\2b","",T(1.0))
+                             test_ab<T>("'a\\0x30\\'\\0x31\\\\\\0x32b' == a" ,"a0'1\\2b","",T(1.0)),
+
+                             test_ab<T>("var x := 3; x > 2 and 'abc' like  '*bc'"   ,"","",T(1.0)),
+                             test_ab<T>("var x := 3; x > 2 and 'abc' ilike '*Bc'"   ,"","",T(1.0)),
+                             test_ab<T>("var x := 3; x > 2 and 'abc' in '123abc123'","","",T(1.0)),
+
+                             test_ab<T>("var x := 3; var s := 'abc'; x > 2 and s like  '*bc'"   ,"","",T(1.0)),
+                             test_ab<T>("var x := 3; var s := 'abc'; x > 2 and s ilike '*Bc'"   ,"","",T(1.0)),
+                             test_ab<T>("var x := 3; var s := 'abc'; x > 2 and s in '123abc123'","","",T(1.0)),
+
+                             test_ab<T>("var x := 3; var s := 'abc'; var t := '*bc'; x > 2 and s like  t"   ,"","",T(1.0)),
+                             test_ab<T>("var x := 3; var s := 'abc'; var t := '*Bc'; x > 2 and s ilike t"   ,"","",T(1.0)),
+                             test_ab<T>("var x := 3; var s := 'abc'; var t := '123abc123'; x > 2 and s in t","","",T(1.0)),
+
+                             test_ab<T>("var x := 3; x > 2 and a like  '*bc'"   ,"abc","",T(1.0)),
+                             test_ab<T>("var x := 3; x > 2 and a ilike '*Bc'"   ,"abc","",T(1.0)),
+                             test_ab<T>("var x := 3; x > 2 and a in '123abc123'","abc","",T(1.0)),
+
+                             test_ab<T>("var x := 3; x > 2 and a like b ","abc","*bc",T(1.0)),
+                             test_ab<T>("var x := 3; x > 2 and a ilike b","abc","*Bc",T(1.0)),
+                             test_ab<T>("var x := 3; x > 2 and a in b   ","abc","123abc123",T(1.0)),
+
+                             test_ab<T>("a[] > 2 and a like  '*bc'"   ,"abc","",T(1.0)),
+                             test_ab<T>("a[] > 2 and a ilike '*Bc'"   ,"abc","",T(1.0)),
+                             test_ab<T>("a[] > 2 and a in '123abc123'","abc","",T(1.0)),
+
+                             test_ab<T>("a[] > 2 and a like b ","abc","*bc",T(1.0)),
+                             test_ab<T>("a[] > 2 and a ilike b","abc","*Bc",T(1.0)),
+                             test_ab<T>("a[] > 2 and a in b   ","abc","123abc123",T(1.0))
                            };
 
    static const std::size_t test_list_size = sizeof(test_list) / sizeof(test_ab<T>);
 
-   const std::size_t rounds = 50;
-   for (std::size_t r = 0; r < rounds; ++r)
    {
-      bool result = true;
+      const std::size_t rounds = 50;
 
-      for (std::size_t i = 0; i < test_list_size; ++i)
+      for (std::size_t r = 0; r < rounds; ++r)
       {
-         test_ab<T>& test = const_cast<test_ab<T>&>(test_list[i]);
+         bool result = true;
 
-         std::string str_a;
-         std::string str_b;
-         std::string str_c;
-
-         T r0 = T(2);
-         T r1 = T(6);
-         T r2 = T(7);
-         T r3 = T(3);
-
-         exprtk::symbol_table<T> symbol_table;
-         symbol_table.add_stringvar("a" ,str_a);
-         symbol_table.add_stringvar("b" ,str_b);
-         symbol_table.add_stringvar("c" ,str_c);
-         symbol_table.add_variable ("r0",   r0);
-         symbol_table.add_variable ("r1",   r1);
-         symbol_table.add_variable ("r2",   r2);
-         symbol_table.add_variable ("r3",   r3);
-
-         exprtk::expression<T> expression;
-         expression.register_symbol_table(symbol_table);
-
+         for (std::size_t i = 0; i < test_list_size; ++i)
          {
-            exprtk::parser<T> parser;
+            test_ab<T>& test = const_cast<test_ab<T>&>(test_list[i]);
 
-            if (!parser.compile(test.expr,expression))
+            std::string str_a;
+            std::string str_b;
+            std::string str_c;
+
+            T r0 = T(2);
+            T r1 = T(6);
+            T r2 = T(7);
+            T r3 = T(3);
+
+            exprtk::symbol_table<T> symbol_table;
+            symbol_table.add_stringvar("a", str_a);
+            symbol_table.add_stringvar("b", str_b);
+            symbol_table.add_stringvar("c", str_c);
+            symbol_table.add_variable("r0", r0);
+            symbol_table.add_variable("r1", r1);
+            symbol_table.add_variable("r2", r2);
+            symbol_table.add_variable("r3", r3);
+
+            exprtk::expression<T> expression;
+            expression.register_symbol_table(symbol_table);
+
             {
-               printf("run_test02() - Error: %s   Expression: %s\n",
-                      parser.error().c_str(),
-                      test.expr.c_str());
+               exprtk::parser<T> parser;
+
+               if (!parser.compile(test.expr, expression))
+               {
+                  printf("run_test02() - Error: %s   Expression: %s\n",
+                     parser.error().c_str(),
+                     test.expr.c_str());
+
+                  result = false;
+                  continue;
+               }
+            }
+
+            str_a = test.a;
+            str_b = test.b;
+            str_c = test.c;
+
+            T expr_result = expression.value();
+
+            if (not_equal(expr_result, test.result))
+            {
+               printf("run_test02() - Computation Error:  Expression: [%s]\tExpected: %19.15f\tResult: %19.15f\t"
+                  "a='%s'\tb='%s'\tc='%s'\n",
+                  test.expr.c_str(),
+                  (double)test.result,
+                  (double)expr_result,
+                  str_a.c_str(),
+                  str_b.c_str(),
+                  str_c.c_str());
 
                result = false;
                continue;
             }
          }
 
-         str_a = test.a;
-         str_b = test.b;
-         str_c = test.c;
-
-         T expr_result = expression.value();
-
-         if (not_equal(expr_result,test.result))
+         if (!result)
          {
-            printf("run_test02() - Computation Error:  Expression: [%s]\tExpected: %19.15f\tResult: %19.15f\t"
-                   "a='%s'\tb='%s'\tc='%s'\n",
-                   test.expr.c_str(),
-                   (double)test.result,
-                   (double)expr_result,
-                   str_a.c_str(),
-                   str_b.c_str(),
-                   str_c.c_str());
-
-            result = false;
-            continue;
+            return false;
          }
       }
-
-      if (!result)
-      {
-         return false;
-      }
    }
 
    {
@@ -2492,6 +2530,117 @@
       expression.value();
    }
 
+   {
+      static const std::string invalid_expr[] =
+                                 {
+                                   "x y",
+                                   "x y z",
+                                   "x y z w",
+                                   "x 1",
+                                   "x 1 2",
+                                   "x 1 2 3",
+                                   "x 'abc'",
+                                   "x 1 'abc'",
+                                   "x 'abc' 1",
+                                   "1 2",
+                                   "1 2 3",
+                                   "1 2 3 4",
+                                   "'abc' 'xyz'",
+                                   "'abc' 1",
+                                   "1 'abc'",
+                                   "x sin(1)",
+                                   "s 'abc'",
+                                   "s x",
+                                   "s y",
+                                   "s 1",
+                                   "s 1 x",
+                                   "s 1 y",
+                                   "s x 1",
+                                   "s y 1",
+                                   "x s ",
+                                   "y s ",
+                                   "1 s ",
+                                   "1 s x",
+                                   "1 s y",
+                                   "x s 1",
+                                   "y s 1",
+                                   "v 'abc'",
+                                   "v x  ",
+                                   "v y  ",
+                                   "v s  ",
+                                   "v 1  ",
+                                   "v 1 x",
+                                   "v 1 y",
+                                   "v 1 s",
+                                   "v x 1",
+                                   "v y 1",
+                                   "v s 1",
+                                   "x v  ",
+                                   "y v  ",
+                                   "1 v  ",
+                                   "1 v x",
+                                   "1 v y",
+                                   "x v 1",
+                                   "y v 1"
+                                 };
+
+      const std::size_t invalid_expr_size = sizeof(invalid_expr) / sizeof(std::string);
+
+      {
+         for (std::size_t i = 0; i < invalid_expr_size; ++i)
+         {
+            exprtk::symbol_table<T> symbol_table;
+
+            exprtk::expression<T> expression;
+
+            T x = T(0);
+            std::string s;
+            std::vector<T> v(10, T(1.234));
+
+            symbol_table.add_variable ("x",x);
+            symbol_table.add_stringvar("s",s);
+            symbol_table.add_vector   ("v",v);
+
+            exprtk::parser<T> parser;
+
+            if (parser.compile(invalid_expr[i],expression))
+            {
+               printf("run_test03() - Error: [1] Invalid expression compiled successfuly.   Expression: %s\n",
+                      invalid_expr[i].c_str());
+
+               return false;
+            }
+         }
+      }
+
+      {
+         T x = T(0);
+         std::string s;
+         std::vector<T> v(10, T(1.234));
+
+         exprtk::symbol_table<T> symbol_table;
+
+         symbol_table.add_variable ("x",x);
+         symbol_table.add_stringvar("s",s);
+         symbol_table.add_vector   ("v",v);
+
+         exprtk::parser<T> parser;
+
+         for (std::size_t i = 0; i < invalid_expr_size; ++i)
+         {
+            exprtk::expression<T> expression;
+
+            if (parser.compile(invalid_expr[i],expression))
+            {
+               printf("run_test03() - Error: [2] Invalid expression compiled successfuly.   Expression: %s\n",
+                      invalid_expr[i].c_str());
+
+               return false;
+            }
+         }
+      }
+   }
+
    return true;
 }
 
@@ -2977,95 +3126,149 @@
    }
 };
 
+double foo1(double v0) { return v0; }
+double foo2(double v0, double v1) { return v0 + v1; }
+double foo3(double v0, double v1, double v2) { return v0 + v1 + v2; }
+double foo4(double v0, double v1, double v2, double v3) { return v0 + v1 + v2 + v3; }
+double foo5(double v0, double v1, double v2, double v3, double v4) { return v0 + v1 + v2 + v3 + v4; }
+
 template <typename T>
 inline bool run_test09()
 {
-   static const std::size_t rounds = 1000;
-   for (std::size_t i = 0; i < rounds; ++i)
    {
-      typedef exprtk::expression<T> expression_t;
-      std::string expression_string = "myfunc0(sin(x * pi),y / 2) + myfunc1(sin(x * pi),y / 2)+"
-                                      "myfunc2(sin(x * pi),y / 2) + myfunc3(sin(x * pi),y / 2)+"
-                                      "myfunc4(sin(x * pi),y / 2) + myfunc5(sin(x * pi),y / 2)+"
-                                      "myfunc6(sin(x * pi),y / 2) + myfunc7(sin(x * pi),y / 2)+"
-                                      "myfunc8(sin(x * pi),y / 2) + myfunc9(sin(x * pi),y / 2)+"
-                                      "myfunc0(sin(x * pi),y / 2) + myfunc1(sin(x * pi),y / 2)+"
-                                      "myfunc2(sin(x * pi),y / 2) + myfunc3(sin(x * pi),y / 2)+"
-                                      "myfunc4(sin(x * pi),y / 2) + myfunc5(sin(x * pi),y / 2)+"
-                                      "myfunc6(sin(x * pi),y / 2) + myfunc7(sin(x * pi),y / 2)+"
-                                      "myfunc8(sin(x * pi),y / 2) + myfunc9(sin(x * pi),y / 2)+"
-                                      "myfunc0(sin(x * pi),y / 2) + myfunc1(sin(x * pi),y / 2)+"
-                                      "myfunc2(sin(x * pi),y / 2) + myfunc3(sin(x * pi),y / 2)+"
-                                      "myfunc4(sin(x * pi),y / 2) + myfunc5(sin(x * pi),y / 2)+"
-                                      "myfunc6(sin(x * pi),y / 2) + myfunc7(sin(x * pi),y / 2)+"
-                                      "myfunc8(sin(x * pi),y / 2) + myfunc9(sin(x * pi),y / 2)+"
-                                      "myfunc0(sin(x * pi),y / 2) + myfunc1(sin(x * pi),y / 2)+"
-                                      "myfunc2(sin(x * pi),y / 2) + myfunc3(sin(x * pi),y / 2)+"
-                                      "myfunc4(sin(x * pi),y / 2) + myfunc5(sin(x * pi),y / 2)+"
-                                      "myfunc6(sin(x * pi),y / 2) + myfunc7(sin(x * pi),y / 2)+"
-                                      "myfunc8(sin(x * pi),y / 2) + myfunc9(sin(x * pi),y / 2)";
-
-      T x = T(1) + (i / T(10000));
-      T y = T(2) + (i / T(10000));
-      myfunc<T> mf;
-
-      exprtk::symbol_table<T> symbol_table;
-      symbol_table.add_variable("x",x);
-      symbol_table.add_variable("y",y);
-      symbol_table.add_function("myfunc0",mf);
-      symbol_table.add_function("myfunc1",mf);
-      symbol_table.add_function("myfunc2",mf);
-      symbol_table.add_function("myfunc3",mf);
-      symbol_table.add_function("myfunc4",mf);
-      symbol_table.add_function("myfunc5",mf);
-      symbol_table.add_function("myfunc6",mf);
-      symbol_table.add_function("myfunc7",mf);
-      symbol_table.add_function("myfunc8",mf);
-      symbol_table.add_function("myfunc9",mf);
-      symbol_table.add_constants();
-
-      expression_t expression;
-      expression.register_symbol_table(symbol_table);
-
+      static const std::size_t rounds = 1000;
+      for (std::size_t i = 0; i < rounds; ++i)
       {
-         exprtk::parser<T> parser;
+         typedef exprtk::expression<T> expression_t;
+         std::string expression_string = "myfunc0(sin(x * pi),y / 2) + myfunc1(sin(x * pi),y / 2)+"
+                                         "myfunc2(sin(x * pi),y / 2) + myfunc3(sin(x * pi),y / 2)+"
+                                         "myfunc4(sin(x * pi),y / 2) + myfunc5(sin(x * pi),y / 2)+"
+                                         "myfunc6(sin(x * pi),y / 2) + myfunc7(sin(x * pi),y / 2)+"
+                                         "myfunc8(sin(x * pi),y / 2) + myfunc9(sin(x * pi),y / 2)+"
+                                         "myfunc0(sin(x * pi),y / 2) + myfunc1(sin(x * pi),y / 2)+"
+                                         "myfunc2(sin(x * pi),y / 2) + myfunc3(sin(x * pi),y / 2)+"
+                                         "myfunc4(sin(x * pi),y / 2) + myfunc5(sin(x * pi),y / 2)+"
+                                         "myfunc6(sin(x * pi),y / 2) + myfunc7(sin(x * pi),y / 2)+"
+                                         "myfunc8(sin(x * pi),y / 2) + myfunc9(sin(x * pi),y / 2)+"
+                                         "myfunc0(sin(x * pi),y / 2) + myfunc1(sin(x * pi),y / 2)+"
+                                         "myfunc2(sin(x * pi),y / 2) + myfunc3(sin(x * pi),y / 2)+"
+                                         "myfunc4(sin(x * pi),y / 2) + myfunc5(sin(x * pi),y / 2)+"
+                                         "myfunc6(sin(x * pi),y / 2) + myfunc7(sin(x * pi),y / 2)+"
+                                         "myfunc8(sin(x * pi),y / 2) + myfunc9(sin(x * pi),y / 2)+"
+                                         "myfunc0(sin(x * pi),y / 2) + myfunc1(sin(x * pi),y / 2)+"
+                                         "myfunc2(sin(x * pi),y / 2) + myfunc3(sin(x * pi),y / 2)+"
+                                         "myfunc4(sin(x * pi),y / 2) + myfunc5(sin(x * pi),y / 2)+"
+                                         "myfunc6(sin(x * pi),y / 2) + myfunc7(sin(x * pi),y / 2)+"
+                                         "myfunc8(sin(x * pi),y / 2) + myfunc9(sin(x * pi),y / 2)";
 
-         if (!parser.compile(expression_string,expression))
+         T x = T(1) + (i / T(10000));
+         T y = T(2) + (i / T(10000));
+         myfunc<T> mf;
+
+         exprtk::symbol_table<T> symbol_table;
+         symbol_table.add_variable("x",x);
+         symbol_table.add_variable("y",y);
+         symbol_table.add_function("myfunc0",mf);
+         symbol_table.add_function("myfunc1",mf);
+         symbol_table.add_function("myfunc2",mf);
+         symbol_table.add_function("myfunc3",mf);
+         symbol_table.add_function("myfunc4",mf);
+         symbol_table.add_function("myfunc5",mf);
+         symbol_table.add_function("myfunc6",mf);
+         symbol_table.add_function("myfunc7",mf);
+         symbol_table.add_function("myfunc8",mf);
+         symbol_table.add_function("myfunc9",mf);
+         symbol_table.add_constants();
+
+         expression_t expression;
+         expression.register_symbol_table(symbol_table);
+
          {
-            printf("run_test09() - Error: %s   Expression: %s\n",
-                   parser.error().c_str(),
-                   expression_string.c_str());
+            exprtk::parser<T> parser;
+
+            if (!parser.compile(expression_string,expression))
+            {
+               printf("run_test09() - Error: %s   Expression: %s\n",
+                      parser.error().c_str(),
+                      expression_string.c_str());
+
+               return false;
+            }
+         }
+
+         const T pi = T(3.141592653589793238462);
+
+         T result = expression.value();
+
+         T expected = T(4) *
+                      (
+                         mf(sin(x*pi),y / T(2)) +
+                         mf(sin(x*pi),y / T(2)) +
+                         mf(sin(x*pi),y / T(2)) +
+                         mf(sin(x*pi),y / T(2)) +
+                         mf(sin(x*pi),y / T(2)) +
+                         mf(sin(x*pi),y / T(2)) +
+                         mf(sin(x*pi),y / T(2)) +
+                         mf(sin(x*pi),y / T(2)) +
+                         mf(sin(x*pi),y / T(2)) +
+                         mf(sin(x*pi),y / T(2))
+                      );
+
+         if (not_equal(result,expected,T(0.0000001)))
+         {
+            printf("run_test09() - Error Expected: %19.15f\tResult: %19.15f\n",
+                   (double)expected,
+                   (double)result);
 
             return false;
          }
       }
+   }
 
-      const T pi = T(3.141592653589793238462);
+   {
+      typedef exprtk::expression<T>   expression_t;
+      typedef exprtk::symbol_table<T> symbol_table_t;
 
-      T result = expression.value();
+      bool result = true;
 
-      T expected = T(4) *
-                   (
-                      mf(sin(x*pi),y / T(2)) +
-                      mf(sin(x*pi),y / T(2)) +
-                      mf(sin(x*pi),y / T(2)) +
-                      mf(sin(x*pi),y / T(2)) +
-                      mf(sin(x*pi),y / T(2)) +
-                      mf(sin(x*pi),y / T(2)) +
-                      mf(sin(x*pi),y / T(2)) +
-                      mf(sin(x*pi),y / T(2)) +
-                      mf(sin(x*pi),y / T(2)) +
-                      mf(sin(x*pi),y / T(2))
-                   );
+      const std::string expression_list[] =
+                           {
+                             "foo1(1)         == 1",
+                             "foo2(1,2)       == (1 + 2)",
+                             "foo3(1,2,3)     == (1 + 2 + 3)",
+                             "foo4(1,2,3,4)   == (1 + 2 + 3 + 4)",
+                             "foo5(1,2,3,4,5) == (1 + 2 + 3 + 4 + 5)"
+                           };
 
-      if (not_equal(result,expected,T(0.0000001)))
+      const std::size_t expression_list_size = sizeof(expression_list) / sizeof(std::string);
+
+      symbol_table_t symbol_table;
+
+      symbol_table.add_function("foo1",foo1);
+      symbol_table.add_function("foo2",foo2);
+      symbol_table.add_function("foo3",foo3);
+      symbol_table.add_function("foo4",foo4);
+      symbol_table.add_function("foo5",foo5);
+
+      for (std::size_t i = 0; i < expression_list_size; ++i)
       {
-         printf("run_test09() - Error Expected: %19.15f\tResult: %19.15f\n",
-                (double)expected,
-                (double)result);
+         expression_t expression;
+         expression.register_symbol_table(symbol_table);
 
-         return false;
+         exprtk::parser<T> parser;
+
+         if (!parser.compile(expression_list[i],expression))
+         {
+            printf("run_test09() - Error: %s   Expression: %s\n",
+                   parser.error().c_str(),
+                   expression_list[i].c_str());
+
+            result = false;
+         }
       }
+
+      if (!result)
+         return false;
    }
 
    return true;
@@ -3081,12 +3284,10 @@
    T xx = T(3.3);
    T yy = T(4.4);
 
-   std::string i  = "A String";
-   std::string j  = "Another String";
-   std::string ii = "A String";
-   std::string jj = "Another String";
-
-   exprtk::symbol_table<T> symbol_table;
+   std::string i_s  = "A String";
+   std::string j_s  = "Another String";
+   std::string ii_s = "A String";
+   std::string jj_s = "Another String";
 
    struct test
    {
@@ -3111,361 +3312,365 @@
       }
    };
 
-   static const std::size_t rounds = 10;
-
-   for (std::size_t r = 0; r < rounds; ++r)
    {
-      symbol_table.add_variable("x",  x);
-      symbol_table.add_variable("y",  y);
-      symbol_table.add_variable("xx",xx);
-      symbol_table.add_variable("yy",yy);
+      static const std::size_t rounds = 10;
 
-      if (!symbol_table.symbol_exists("x"))
-      {
-         printf("run_test10() - Symbol 'x' does not exist!\n");
-         return false;
-      }
-      else if (!symbol_table.symbol_exists("y"))
-      {
-         printf("run_test10() - Symbol 'y' does not exist!\n");
-         return false;
-      }
-      else if (!symbol_table.symbol_exists("xx"))
-      {
-         printf("run_test10() - Symbol 'xx' does not exist!\n");
-         return false;
-      }
-      else if (!symbol_table.symbol_exists("yy"))
-      {
-         printf("run_test10() - Symbol 'yy' does not exist!\n");
-         return false;
-      }
-      else if (!test::variable(symbol_table,"x",x))
-      {
-         printf("run_test10() - Symbol 'x' value failure!\n");
-         return false;
-      }
-      else if (!test::variable(symbol_table,"y",y))
-      {
-         printf("run_test10() - Symbol 'y' value failure!\n");
-         return false;
-      }
-      else if (!test::variable(symbol_table,"xx",xx))
-      {
-         printf("run_test10() - Symbol 'xx' value failure!\n");
-         return false;
-      }
-      else if (!test::variable(symbol_table,"yy",yy))
-      {
-         printf("run_test10() - Symbol 'yy' value failure!\n");
-         return false;
-      }
+      exprtk::symbol_table<T> symbol_table;
 
-      if (!symbol_table.remove_variable("x"))
+      for (std::size_t r = 0; r < rounds; ++r)
       {
-         printf("run_test10() - Failed to remove symbol 'x'!\n");
-         return false;
-      }
-      else if (!symbol_table.remove_variable("y"))
-      {
-         printf("run_test10() - Failed to remove symbol 'y'!\n");
-         return false;
-      }
-      else if (!symbol_table.remove_variable("xx"))
-      {
-         printf("run_test10() - Failed to remove symbol 'xx'!\n");
-         return false;
-      }
-      else if (!symbol_table.remove_variable("yy"))
-      {
-         printf("run_test10() - Failed to remove symbol 'yy'!\n");
-         return false;
-      }
-   }
+         symbol_table.add_variable("x", x);
+         symbol_table.add_variable("y", y);
+         symbol_table.add_variable("xx", xx);
+         symbol_table.add_variable("yy", yy);
 
-   for (std::size_t r = 0; r < rounds; ++r)
-   {
-      myfunc<T> mf;
-
-      symbol_table.add_function("f",mf);
-      symbol_table.add_function("f1",mf);
-
-      if (!symbol_table.symbol_exists("f"))
-      {
-         printf("run_test10() - function 'f' does not exist!\n");
-         return false;
-      }
-      else if (!symbol_table.symbol_exists("f1"))
-      {
-         printf("run_test10() - function 'f1' does not exist!\n");
-         return false;
-      }
-
-      if (!symbol_table.remove_function("f"))
-      {
-         printf("run_test10() - Failed to remove function 'f'!\n");
-         return false;
-      }
-      else if (!symbol_table.remove_function("f1"))
-      {
-         printf("run_test10() - Failed to remove function 'f1'!\n");
-         return false;
-      }
-   }
-
-   for (std::size_t r = 0; r < rounds; ++r)
-   {
-      symbol_table.add_stringvar("i",i);
-      symbol_table.add_stringvar("j",j);
-
-      symbol_table.add_stringvar("ii",ii);
-      symbol_table.add_stringvar("jj",jj);
-
-      if (!symbol_table.symbol_exists("i"))
-      {
-         printf("run_test10() - String 'i' does not exist!\n");
-         return false;
-      }
-      else if (!symbol_table.symbol_exists("j"))
-      {
-         printf("run_test10() - String 'j' does not exist!\n");
-         return false;
-      }
-      else if (!symbol_table.symbol_exists("ii"))
-      {
-         printf("run_test10() - String 'ii' does not exist!\n");
-         return false;
-      }
-      else if (!symbol_table.symbol_exists("jj"))
-      {
-         printf("run_test10() - String 'jj' does not exist!\n");
-         return false;
-      }
-      else if (!test::string(symbol_table,"i",i))
-      {
-         printf("run_test10() - String 'i' value failure!\n");
-         return false;
-      }
-      else if (!test::string(symbol_table,"j",j))
-      {
-         printf("run_test10() - String 'j' value failure!\n");
-         return false;
-      }
-      else if (!test::string(symbol_table,"ii",ii))
-      {
-         printf("run_test10() - String 'ii' value failure!\n");
-         return false;
-      }
-      else if (!test::string(symbol_table,"jj",jj))
-      {
-         printf("run_test10() - String 'jj' value failure!\n");
-         return false;
-      }
-      else if (!symbol_table.remove_stringvar("i"))
-      {
-         printf("run_test10() - Failed to remove String 'i'!\n");
-         return false;
-      }
-      else if (!symbol_table.remove_stringvar("j"))
-      {
-         printf("run_test10() - Failed to remove String 'j'!\n");
-         return false;
-      }
-      else if (!symbol_table.remove_stringvar("ii"))
-      {
-         printf("run_test10() - Failed to remove String 'ii'!\n");
-         return false;
-      }
-      else if (!symbol_table.remove_stringvar("jj"))
-      {
-         printf("run_test10() - Failed to remove String 'jj'!\n");
-         return false;
-      }
-   }
-
-   for (std::size_t r = 0; r < rounds; ++r)
-   {
-      symbol_table.add_variable("x",  x);
-      symbol_table.add_variable("y",  y);
-      symbol_table.add_variable("xx",xx);
-      symbol_table.add_variable("yy",yy);
-
-      std::vector<std::string> expected_var_list;
-
-      expected_var_list.push_back( "x");
-      expected_var_list.push_back( "y");
-      expected_var_list.push_back("xx");
-      expected_var_list.push_back("yy");
-
-      std::deque<std::pair<std::string,T> > variable_list;
-
-      symbol_table.get_variable_list(variable_list);
-
-      if (variable_list.size() != expected_var_list.size())
-      {
-         printf("run_test10() - Failed to get variable list (1)\n");
-         return false;
-      }
-
-      std::size_t found_count = 0;
-
-      for (std::size_t i = 0; i < variable_list.size(); ++i)
-      {
-         for (std::size_t j = 0; j < expected_var_list.size(); ++j)
+         if (!symbol_table.symbol_exists("x"))
          {
-            if (variable_list[i].first == expected_var_list[j])
-            {
-               ++found_count;
-               break;
-            }
+            printf("run_test10() - Symbol 'x' does not exist!\n");
+            return false;
+         }
+         else if (!symbol_table.symbol_exists("y"))
+         {
+            printf("run_test10() - Symbol 'y' does not exist!\n");
+            return false;
+         }
+         else if (!symbol_table.symbol_exists("xx"))
+         {
+            printf("run_test10() - Symbol 'xx' does not exist!\n");
+            return false;
+         }
+         else if (!symbol_table.symbol_exists("yy"))
+         {
+            printf("run_test10() - Symbol 'yy' does not exist!\n");
+            return false;
+         }
+         else if (!test::variable(symbol_table, "x", x))
+         {
+            printf("run_test10() - Symbol 'x' value failure!\n");
+            return false;
+         }
+         else if (!test::variable(symbol_table, "y", y))
+         {
+            printf("run_test10() - Symbol 'y' value failure!\n");
+            return false;
+         }
+         else if (!test::variable(symbol_table, "xx", xx))
+         {
+            printf("run_test10() - Symbol 'xx' value failure!\n");
+            return false;
+         }
+         else if (!test::variable(symbol_table, "yy", yy))
+         {
+            printf("run_test10() - Symbol 'yy' value failure!\n");
+            return false;
+         }
+
+         if (!symbol_table.remove_variable("x"))
+         {
+            printf("run_test10() - Failed to remove symbol 'x'!\n");
+            return false;
+         }
+         else if (!symbol_table.remove_variable("y"))
+         {
+            printf("run_test10() - Failed to remove symbol 'y'!\n");
+            return false;
+         }
+         else if (!symbol_table.remove_variable("xx"))
+         {
+            printf("run_test10() - Failed to remove symbol 'xx'!\n");
+            return false;
+         }
+         else if (!symbol_table.remove_variable("yy"))
+         {
+            printf("run_test10() - Failed to remove symbol 'yy'!\n");
+            return false;
          }
       }
 
-      if (found_count != expected_var_list.size())
+      for (std::size_t r = 0; r < rounds; ++r)
       {
-         printf("run_test10() - Failed to get variable list (2)\n");
-         return false;
-      }
-   }
+         myfunc<T> mf;
 
-   for (std::size_t r = 0; r < rounds; ++r)
-   {
-      symbol_table.add_variable("x",  x);
-      symbol_table.add_variable("y",  y);
-      symbol_table.add_variable("xx",xx);
-      symbol_table.add_variable("yy",yy);
+         symbol_table.add_function("f", mf);
+         symbol_table.add_function("f1", mf);
 
-      std::vector<std::string> expected_var_list;
-
-      expected_var_list.push_back( "x");
-      expected_var_list.push_back( "y");
-      expected_var_list.push_back("xx");
-      expected_var_list.push_back("yy");
-
-      std::deque<std::string> variable_list;
-
-      symbol_table.get_variable_list(variable_list);
-
-      if (variable_list.size() != expected_var_list.size())
-      {
-         printf("run_test10() - Failed to get variable list (3)\n");
-         return false;
-      }
-
-      std::size_t found_count = 0;
-
-      for (std::size_t i = 0; i < variable_list.size(); ++i)
-      {
-         for (std::size_t j = 0; j < expected_var_list.size(); ++j)
+         if (!symbol_table.symbol_exists("f"))
          {
-            if (variable_list[i] == expected_var_list[j])
-            {
-               ++found_count;
-               break;
-            }
+            printf("run_test10() - function 'f' does not exist!\n");
+            return false;
+         }
+         else if (!symbol_table.symbol_exists("f1"))
+         {
+            printf("run_test10() - function 'f1' does not exist!\n");
+            return false;
+         }
+
+         if (!symbol_table.remove_function("f"))
+         {
+            printf("run_test10() - Failed to remove function 'f'!\n");
+            return false;
+         }
+         else if (!symbol_table.remove_function("f1"))
+         {
+            printf("run_test10() - Failed to remove function 'f1'!\n");
+            return false;
          }
       }
 
-      if (found_count != expected_var_list.size())
+      for (std::size_t r = 0; r < rounds; ++r)
       {
-         printf("run_test10() - Failed to get variable list (4)\n");
-         return false;
-      }
-   }
+         symbol_table.add_stringvar("i", i_s);
+         symbol_table.add_stringvar("j", j_s);
 
-   for (std::size_t r = 0; r < rounds; ++r)
-   {
-      symbol_table.add_stringvar( "i", i);
-      symbol_table.add_stringvar( "j", j);
-      symbol_table.add_stringvar("ii",ii);
-      symbol_table.add_stringvar("jj",jj);
+         symbol_table.add_stringvar("ii", ii_s);
+         symbol_table.add_stringvar("jj", jj_s);
 
-      std::vector<std::string> expected_var_list;
-
-      expected_var_list.push_back( "i");
-      expected_var_list.push_back( "j");
-      expected_var_list.push_back("ii");
-      expected_var_list.push_back("jj");
-
-      std::deque<std::pair<std::string,std::string> > stringvar_list;
-
-      symbol_table.get_stringvar_list(stringvar_list);
-
-      if (stringvar_list.size() != expected_var_list.size())
-      {
-         printf("run_test10() - Failed to get stringvar list (1)\n");
-         return false;
-      }
-
-      std::size_t found_count = 0;
-
-      for (std::size_t i = 0; i < stringvar_list.size(); ++i)
-      {
-         for (std::size_t j = 0; j < expected_var_list.size(); ++j)
+         if (!symbol_table.symbol_exists("i"))
          {
-            if (stringvar_list[i].first == expected_var_list[j])
-            {
-               ++found_count;
-               break;
-            }
+            printf("run_test10() - String 'i' does not exist!\n");
+            return false;
+         }
+         else if (!symbol_table.symbol_exists("j"))
+         {
+            printf("run_test10() - String 'j' does not exist!\n");
+            return false;
+         }
+         else if (!symbol_table.symbol_exists("ii"))
+         {
+            printf("run_test10() - String 'ii' does not exist!\n");
+            return false;
+         }
+         else if (!symbol_table.symbol_exists("jj"))
+         {
+            printf("run_test10() - String 'jj' does not exist!\n");
+            return false;
+         }
+         else if (!test::string(symbol_table, "i", i_s))
+         {
+            printf("run_test10() - String 'i' value failure!\n");
+            return false;
+         }
+         else if (!test::string(symbol_table, "j", j_s))
+         {
+            printf("run_test10() - String 'j' value failure!\n");
+            return false;
+         }
+         else if (!test::string(symbol_table, "ii", ii_s))
+         {
+            printf("run_test10() - String 'ii' value failure!\n");
+            return false;
+         }
+         else if (!test::string(symbol_table, "jj", jj_s))
+         {
+            printf("run_test10() - String 'jj' value failure!\n");
+            return false;
+         }
+         else if (!symbol_table.remove_stringvar("i"))
+         {
+            printf("run_test10() - Failed to remove String 'i'!\n");
+            return false;
+         }
+         else if (!symbol_table.remove_stringvar("j"))
+         {
+            printf("run_test10() - Failed to remove String 'j'!\n");
+            return false;
+         }
+         else if (!symbol_table.remove_stringvar("ii"))
+         {
+            printf("run_test10() - Failed to remove String 'ii'!\n");
+            return false;
+         }
+         else if (!symbol_table.remove_stringvar("jj"))
+         {
+            printf("run_test10() - Failed to remove String 'jj'!\n");
+            return false;
          }
       }
 
-      if (found_count != expected_var_list.size())
+      for (std::size_t r = 0; r < rounds; ++r)
       {
-         printf("run_test10() - Failed to get stringvar list (2)\n");
-         return false;
-      }
-   }
+         symbol_table.add_variable("x", x);
+         symbol_table.add_variable("y", y);
+         symbol_table.add_variable("xx", xx);
+         symbol_table.add_variable("yy", yy);
 
-   for (std::size_t r = 0; r < rounds; ++r)
-   {
-      symbol_table.add_stringvar( "i", i);
-      symbol_table.add_stringvar( "j", j);
-      symbol_table.add_stringvar("ii",ii);
-      symbol_table.add_stringvar("jj",jj);
+         std::vector<std::string> expected_var_list;
 
-      std::vector<std::string> expected_var_list;
+         expected_var_list.push_back("x");
+         expected_var_list.push_back("y");
+         expected_var_list.push_back("xx");
+         expected_var_list.push_back("yy");
 
-      expected_var_list.push_back( "i");
-      expected_var_list.push_back( "j");
-      expected_var_list.push_back("ii");
-      expected_var_list.push_back("jj");
+         std::deque<std::pair<std::string, T> > variable_list;
 
-      std::deque<std::string> stringvar_list;
+         symbol_table.get_variable_list(variable_list);
 
-      symbol_table.get_stringvar_list(stringvar_list);
-
-      if (stringvar_list.size() != expected_var_list.size())
-      {
-         printf("run_test10() - Failed to get stringvar list (3.0)\n");
-         return false;
-      }
-
-      if (symbol_table.stringvar_count() != expected_var_list.size())
-      {
-         printf("run_test10() - Failed to get stringvar list (3.1)\n");
-         return false;
-      }
-
-      std::size_t found_count = 0;
-
-      for (std::size_t i = 0; i < stringvar_list.size(); ++i)
-      {
-         for (std::size_t j = 0; j < expected_var_list.size(); ++j)
+         if (variable_list.size() != expected_var_list.size())
          {
-            if (stringvar_list[i] == expected_var_list[j])
+            printf("run_test10() - Failed to get variable list (1)\n");
+            return false;
+         }
+
+         std::size_t found_count = 0;
+
+         for (std::size_t i = 0; i < variable_list.size(); ++i)
+         {
+            for (std::size_t j = 0; j < expected_var_list.size(); ++j)
             {
-               ++found_count;
-               break;
+               if (variable_list[i].first == expected_var_list[j])
+               {
+                  ++found_count;
+                  break;
+               }
             }
          }
+
+         if (found_count != expected_var_list.size())
+         {
+            printf("run_test10() - Failed to get variable list (2)\n");
+            return false;
+         }
       }
 
-      if (found_count != expected_var_list.size())
+      for (std::size_t r = 0; r < rounds; ++r)
       {
-         printf("run_test10() - Failed to get stringvar list (4)\n");
-         return false;
+         symbol_table.add_variable("x", x);
+         symbol_table.add_variable("y", y);
+         symbol_table.add_variable("xx", xx);
+         symbol_table.add_variable("yy", yy);
+
+         std::vector<std::string> expected_var_list;
+
+         expected_var_list.push_back("x");
+         expected_var_list.push_back("y");
+         expected_var_list.push_back("xx");
+         expected_var_list.push_back("yy");
+
+         std::deque<std::string> variable_list;
+
+         symbol_table.get_variable_list(variable_list);
+
+         if (variable_list.size() != expected_var_list.size())
+         {
+            printf("run_test10() - Failed to get variable list (3)\n");
+            return false;
+         }
+
+         std::size_t found_count = 0;
+
+         for (std::size_t i = 0; i < variable_list.size(); ++i)
+         {
+            for (std::size_t j = 0; j < expected_var_list.size(); ++j)
+            {
+               if (variable_list[i] == expected_var_list[j])
+               {
+                  ++found_count;
+                  break;
+               }
+            }
+         }
+
+         if (found_count != expected_var_list.size())
+         {
+            printf("run_test10() - Failed to get variable list (4)\n");
+            return false;
+         }
+      }
+
+      for (std::size_t r = 0; r < rounds; ++r)
+      {
+         symbol_table.add_stringvar("i", i_s);
+         symbol_table.add_stringvar("j", j_s);
+         symbol_table.add_stringvar("ii", ii_s);
+         symbol_table.add_stringvar("jj", jj_s);
+
+         std::vector<std::string> expected_var_list;
+
+         expected_var_list.push_back("i");
+         expected_var_list.push_back("j");
+         expected_var_list.push_back("ii");
+         expected_var_list.push_back("jj");
+
+         std::deque<std::pair<std::string, std::string> > stringvar_list;
+
+         symbol_table.get_stringvar_list(stringvar_list);
+
+         if (stringvar_list.size() != expected_var_list.size())
+         {
+            printf("run_test10() - Failed to get stringvar list (1)\n");
+            return false;
+         }
+
+         std::size_t found_count = 0;
+
+         for (std::size_t i = 0; i < stringvar_list.size(); ++i)
+         {
+            for (std::size_t j = 0; j < expected_var_list.size(); ++j)
+            {
+               if (stringvar_list[i].first == expected_var_list[j])
+               {
+                  ++found_count;
+                  break;
+               }
+            }
+         }
+
+         if (found_count != expected_var_list.size())
+         {
+            printf("run_test10() - Failed to get stringvar list (2)\n");
+            return false;
+         }
+      }
+
+      for (std::size_t r = 0; r < rounds; ++r)
+      {
+         symbol_table.add_stringvar("i", i_s);
+         symbol_table.add_stringvar("j", j_s);
+         symbol_table.add_stringvar("ii", ii_s);
+         symbol_table.add_stringvar("jj", jj_s);
+
+         std::vector<std::string> expected_var_list;
+
+         expected_var_list.push_back("i");
+         expected_var_list.push_back("j");
+         expected_var_list.push_back("ii");
+         expected_var_list.push_back("jj");
+
+         std::deque<std::string> stringvar_list;
+
+         symbol_table.get_stringvar_list(stringvar_list);
+
+         if (stringvar_list.size() != expected_var_list.size())
+         {
+            printf("run_test10() - Failed to get stringvar list (3.0)\n");
+            return false;
+         }
+
+         if (symbol_table.stringvar_count() != expected_var_list.size())
+         {
+            printf("run_test10() - Failed to get stringvar list (3.1)\n");
+            return false;
+         }
+
+         std::size_t found_count = 0;
+
+         for (std::size_t i = 0; i < stringvar_list.size(); ++i)
+         {
+            for (std::size_t j = 0; j < expected_var_list.size(); ++j)
+            {
+               if (stringvar_list[i] == expected_var_list[j])
+               {
+                  ++found_count;
+                  break;
+               }
+            }
+         }
+
+         if (found_count != expected_var_list.size())
+         {
+            printf("run_test10() - Failed to get stringvar list (4)\n");
+            return false;
+         }
       }
    }
 
@@ -3977,6 +4182,9 @@
         "2 == for (var i := 0; i < 10; i += 1) { if (i > 2) { continue; return [i * 8];"
         "i += 1; i += 2; i += 3; } else i; }",
 
+        "var x[10] := [-1]; var y[10] := [-1]; for (var i := 0; i < 10; i += 1) { x[i] := i; "
+        "y[i] := 2 * x[i]; }; (sum(x) == 45) and (sum(y) == (2 * sum(x)));"
+
         "7 == (for (var i := 0; i < 10; i += 1) { ~{break[7]; continue; i += i} })",
         "0 == (for (var i := 0; i < 10; i += 1) { ~{break[i]; continue; i += i} })",
         "0 == (for (var i := 0; i < 10; i += 1) { ~{continue; break[7]; i += i} })",
@@ -4932,6 +5140,8 @@
    va_func()
    {
       exprtk::enable_zero_parameters(*this);
+      exprtk::set_min_num_args(*this,  0);
+      exprtk::set_max_num_args(*this, 20);
    }
 
    inline T operator()(const std::vector<T>& arglist)
@@ -5084,12 +5294,13 @@
 template <typename T>
 struct rem_space_and_uppercase : public exprtk::igeneric_function<T>
 {
-   typedef typename exprtk::igeneric_function<T>::generic_type generic_type;
-   typedef typename exprtk::igeneric_function<T>::parameter_list_t parameter_list_t;
-   typedef typename generic_type::string_view string_t;
+   typedef typename exprtk::igeneric_function<T> igenfunc_t;
+   typedef typename igenfunc_t::generic_type     generic_type;
+   typedef typename igenfunc_t::parameter_list_t parameter_list_t;
+   typedef typename generic_type::string_view    string_t;
 
    rem_space_and_uppercase()
-   : exprtk::igeneric_function<T>("S")
+   : igenfunc_t("S",igenfunc_t::e_rtrn_string)
    {}
 
    inline T operator()(std::string& result, parameter_list_t params)
@@ -5104,7 +5315,7 @@
       for (std::size_t i = 0; i < string.size(); ++i)
       {
          if (' ' != (c = string[i]))
-            result += std::toupper(c);
+            result += static_cast<char>(std::toupper(c));
       }
 
       return T(0);
@@ -5613,7 +5824,7 @@
       symbol_table.add_stringvar("s3", s3);
       symbol_table.add_stringvar("s4", s4);
 
-      symbol_table.add_function("remspc_uc",rsauc,symbol_table_t::e_ft_strfunc);
+      symbol_table.add_function("remspc_uc",rsauc);
 
       std::string program = " s0 := 'How now ';                                   "
                             " s1 := 'brown cow?';                                 "
diff --git a/readme.txt b/readme.txt
index a3f3ecd..ce2c8d1 100644
--- a/readme.txt
+++ b/readme.txt
@@ -610,9 +610,9 @@
 ExprTk supports three fundamental types which can be used freely in
 expressions. The types are as follows:
 
-   1. Scalar
-   2. Vector
-   3. String
+   (1) Scalar
+   (2) Vector
+   (3) String
 
 
 (1) Scalar Type
@@ -706,7 +706,7 @@
    expression.value(); // 3.7 * -9 + 3
 
    // 'x * -9 + 3' for x in range of [0,100) in steps of 0.0001
-   for (x = 0; x < 100; x += 0.0001)
+   for (x = 0.0; x < 100.0; x += 0.0001)
    {
       expression.value(); // x * -9 + 3
    }
@@ -860,7 +860,10 @@
    (i) '*' '='  --->  '*='  (multiplication assignment)
    (j) '/' '='  --->  '/='  (division assignment)
    (k) '%' '='  --->  '%='  (modulo assignment)
-   (l) '<=' '>' --->  '<=>' (swap)
+   (l) '+' '-'  --->  '-'   (subtraction)
+   (m) '-' '+'  --->  '-'   (subtraction)
+   (n) '-' '-'  --->  '+'   (addition)
+   (o) '<=' '>' --->  '<=>' (swap)
 
 
 An example of the transformation that takes place is as follows:
@@ -926,7 +929,7 @@
 attempt at computing the average  between x and y will  be transformed
 as follows:
 
-   (x * 0.5) + (y * 0.5) ---> 0.5 * (x + y)
+   (0.5 * x) + (y * 0.5) ---> 0.5 * (x + y)
 
 There  may be  situations where  the above  transformation will  cause
 numerical overflows and  that the original  form of the  expression is
@@ -1216,11 +1219,15 @@
 
 There are five types of function interface:
 
-   (1) ifunction
-   (2) ivararg_function
-   (3) igeneric_function
-   (4) igeneric_function II
-   (5) function_compositor
+   +---+----------------------+-------------+
+   | # |         Name         | Return Type |
+   +---+----------------------+-------------+
+   | 1 | ifunction            | Scalar      |
+   | 2 | ivararg_function     | Scalar      |
+   | 3 | igeneric_function    | Scalar      |
+   | 4 | igeneric_function II | String      |
+   | 5 | function_compositor  | Scalar      |
+   +---+----------------------+-------------+
 
 
 (1) ifunction
@@ -1446,17 +1453,21 @@
       typedef typename generic_t::string_view string_t;
 
       toupper()
-      : exprtk::igeneric_function<T>("S")
+      : exprtk::igeneric_function<T>("S",igenfunct_t::e_rtrn_string)
       {}
 
       inline T operator()(std::string& result,
                           parameter_list_t parameters)
       {
          result.clear();
+
+         string_t string(params[0]);
+
          for (std::size_t i = 0; i < string.size(); ++i)
          {
             result += std::toupper(string[i]);
          }
+
          return T(0);
       }
    };
@@ -1464,27 +1475,27 @@
 
 In the example above the  generic function 'toupper' expects only  one
 input parameter  of type  string, as  noted by  the parameter sequence
-string passed during the constructor. When executed, the function will
-return as a result a copy  of the input string converted to  uppercase
-form. An example expression  using the toupper function  registered as
-the symbol 'toupper' is as follows:
+string passed during the  constructor. Furthermore a second  parameter
+is passed to the constructor indicating that it should be treated as a
+string returning function -  by default it is  assumed to be a  scalar
+returning function.
+
+When executed,  the function  will return  as a  result a  copy of the
+input string converted to uppercase form. An example expression  using
+the toupper function registered as the symbol 'toupper' is as follows:
 
    "'ABCDEF' == toupper('aBc') + toupper('DeF')"
 
 
 Note: When adding a string type returning generic function to a symbol
-table,  the  'add_function'  is   invoked  with  an  extra   parameter
-(e_ft_strfunc) that denotes the function should be treated as a string
-returning function type. The  following example demonstrates how  this
-is done:
+table the  'add_function' is invoked.  The example  below demonstrates
+how this can be done:
 
    toupper<T> tu;
 
    exprtk::symbol_table<T> symbol_table;
 
-   symbol_table.add_function("toupper",
-                             tu,
-                             symbol_table_t::e_ft_strfunc);
+   symbol_table.add_function("toupper",tu);
 
 
 Note: Two further  refinements to the  type checking facility  are the
@@ -1689,7 +1700,7 @@
    {
       foo() : exprtk::ifunction<T>(3)
       {
-         disable_has_side_effects(*this);
+          exprtk::disable_has_side_effects(*this);
       }
 
       T operator()(const T& v1, const T& v2, const T& v3)
@@ -1757,6 +1768,14 @@
 completed, the  caller can  then obtain  a list  of symbols  and their
 associated types from the DEC.
 
+The kinds of  questions one can  ask regarding the  dependent entities
+within an expression are as follows:
+
+  * What user defined or local variables, vectors or strings are used?
+  * What functions or custom user functions are used?
+  * Which variables, vectors or strings have values assigned to them?
+
+
 The following example demonstrates usage of the DEC in determining the
 dependents of the given expression:
 
@@ -1766,9 +1785,15 @@
    std::string expression_string =
                   "z := abs(x + sin(2 * pi / y))";
 
+   T x,y,z;
+
    parser_t parser;
    symbol_table_t symbol_table;
 
+   symbol_table.add_variable("x",x);
+   symbol_table.add_variable("y",y);
+   symbol_table.add_variable("z",z);
+
    expression_t expression;
    expression.register_symbol_table(symbol_table);
 
@@ -1799,7 +1824,7 @@
    }
 
 
-Note: The  'symbol_t' type  is a  pair comprising  of the  symbol name
+Note: The 'symbol_t' type is a std::pair comprising of the symbol name
 (std::string) and the associated type of the symbol as denoted by  the
 cases in the switch statement.
 
@@ -1866,6 +1891,9 @@
    (1) Base Functions
    (2) Control Flow Structures
    (3) Logical Operators
+   (4) Arithmetic Operators
+   (5) Inequality Operators
+   (6) Assignment Operators
 
 
 (1) Base Functions
@@ -1967,13 +1995,13 @@
        " }                                ";
 
     parser.settings()
-      .disable_all_control_structures(settings_t::e_ctrl_for_loop);
+      .disable_control_structure(settings_t::e_ctrl_for_loop);
 
     parser
       .compile(program,expression); // failure
 
     parser.settings()
-      .enable_all_control_structures(settings_t::e_ctrl_for_loop);
+      .enable_control_structure(settings_t::e_ctrl_for_loop);
 
     parser
       .compile(program,expression); // success
@@ -2009,18 +2037,158 @@
     expression_t expression;
 
     parser.settings()
-      .disable_base_function(settings_t::e_logic_and);
+      .disable_logic_operation(settings_t::e_logic_and);
 
     parser
       .compile("1 or not(0 and 1)",expression); // failure
 
     parser.settings()
-      .enable_base_function(settings_t::e_logic_and);
+      .enable_logic_operation(settings_t::e_logic_and);
 
     parser
       .compile("1 or not(0 and 1)",expression); // success
 
 
+(4) Arithmetic Operators
+The list of available arithmetic operators is as follows:
+
+   +, -, *, /, %, ^
+
+
+The  above  mentioned  arithmetic  operators  can  be  either  enabled or
+disabled 'all' at once, as is demonstrated below:
+
+    parser_t parser;
+    expression_t expression;
+
+    parser.settings().disable_all_arithmetic_ops();
+
+    parser
+      .compile("1 + 2 / 3",expression); // compilation failure
+
+    parser.settings().enable_all_arithmetic_ops();
+
+    parser
+      .compile("1 + 2 / 3",expression); // compilation success
+
+
+One can also enable or disable specific arithmetic operators. The  following
+example demonstrates the disabling of  the addition '+' arithmetic operator:
+
+    parser_t parser;
+    expression_t expression;
+
+    parser.settings()
+      .disable_arithmetic_operation(settings_t::e_arith_add);
+
+    parser
+      .compile("1 + 2 / 3",expression); // failure
+
+    parser.settings()
+      .enable_arithmetic_operation(settings_t::e_arith_add);
+
+    parser
+      .compile("1 + 2 / 3",expression); // success
+
+
+(5) Inequality Operators
+The list of available inequality operators is as follows:
+
+   <, <=, >, >=, ==, =, != <>
+
+
+The  above  mentioned  inequality  operators  can  be  either  enabled or
+disabled 'all' at once, as is demonstrated below:
+
+    parser_t parser;
+    expression_t expression;
+
+    parser.settings().disable_all_inequality_ops();
+
+    parser
+      .compile("1 < 3",expression); // compilation failure
+
+    parser.settings().enable_all_inequality_ops();
+
+    parser
+      .compile("1 < 3",expression); // compilation success
+
+
+One can also enable or disable specific inequality operators. The  following
+example demonstrates the disabling of the less-than '<' inequality operator:
+
+    parser_t parser;
+    expression_t expression;
+
+    parser.settings()
+      .disable_inequality_operation(settings_t::e_ineq_lt);
+
+    parser
+      .compile("1 < 3",expression); // failure
+
+    parser.settings()
+      .enable_inequality_operation(settings_t::e_ineq_lt);
+
+    parser
+      .compile("1 < 3",expression); // success
+
+
+(6) Assignment Operators
+The list of available assignment operators is as follows:
+
+   :=, +=, -=, *=, /=, %=
+
+
+The  above  mentioned  assignment  operators  can  be  either  enabled or
+disabled 'all' at once, as is demonstrated below:
+
+    parser_t parser;
+    expression_t expression;
+    symbol_table_t symbol_table;
+
+    T x = T(0);
+
+    symbol_table.add_variable("x",x);
+
+    expression.register_symbol_table(symbol_table);
+
+    parser.settings().disable_all_assignment_ops();
+
+    parser
+      .compile("x := 3",expression); // compilation failure
+
+    parser.settings().enable_all_assignment_ops();
+
+    parser
+      .compile("x := 3",expression); // compilation success
+
+
+One can also enable or disable specific assignment operators. The  following
+example demonstrates the disabling of the '+=' addition assignment operator:
+
+    parser_t parser;
+    expression_t expression;
+    symbol_table_t symbol_table;
+
+    T x = T(0);
+
+    symbol_table.add_variable("x",x);
+
+    expression.register_symbol_table(symbol_table);
+
+    parser.settings()
+      .disable_assignment_operation(settings_t::e_assign_addass);
+
+    parser
+      .compile("x += 3",expression); // failure
+
+    parser.settings()
+      .enable_assignment_operation(settings_t::e_assign_addass);
+
+    parser
+      .compile("x += 3",expression); // success
+
+
 Note: In the event of a base function being disabled, one can redefine
 the  base  function  using  the  standard  custom  function definition
 process. In the  following example the 'sin' function is disabled then
@@ -2161,7 +2329,7 @@
    if (!parser.compile(expression_string,expression))
    {
       printf("Error: %s\n", parser.error().c_str());
-      return 1;
+      return false;
    }
 
 
@@ -2189,7 +2357,7 @@
                 error.diagnostic.c_str());
       }
 
-      return 1;
+      return false;
    }
 
 
@@ -2214,7 +2382,7 @@
                 error.column_no);
       }
 
-      return 1;
+      return false;
    }
 
 
@@ -2530,7 +2698,15 @@
 When building ExprTk there are a number of defines that will enable or
 disable certain features and  capabilities. The defines can  either be
 part of a compiler command line switch or scoped around the include to
-the ExprTk header.
+the ExprTk header. The defines are as follows:
+
+   (1) exprtk_enable_debugging
+   (2) exprtk_disable_comments
+   (3) exprtk_disable_break_continue
+   (4) exprtk_disable_sc_andor
+   (5) exprtk_disable_enhanced_features
+   (6) exprtk_disable_string_capabilities
+
 
 (1) exprtk_enable_debugging
 This define will enable printing of debug information to stdout during