@@ -1,8 +1,8 @@

 Package: OncoSimulR

 Type: Package

 Title: Forward Genetic Simulation of Cancer Progression with Epistasis 

-Version: 4.1.3

-Date: 2023-02-20

+Version: 4.1.4

+Date: 2023-03-08

 Authors@R: c(

 	      person("Ramon", "Diaz-Uriarte", role = c("aut", "cre"),	

  	   		     email = "rdiaz02@gmail.com"),

@@ -1,3 +1,8 @@

+Changes in version 4.1.4 (2023-03-08):

+	- Updated exprTk (thanks to pull request from Arash

+	  Partow).

+

+

 Changes in version 4.1.3 (2023-02-20):

 	- no need to specify CXX_STD = CXX14 (the default since

 	  R-4.1.0).

@@ -323,7 +323,7 @@ double Algo2_st(const spParamsP& spP,

   //   pb = pB_f_st(pe, spP);

   // }

-  double rnb; // holder for neg. bino. So we can check.

+  double rnb = -99.9999; // holder for neg. bino. So we can check.

   double retval; //So we can check

   if( (1.0 - pe/pm) > 1.0) {

@@ -2,7 +2,7 @@

  ******************************************************************

  *           C++ Mathematical Expression Toolkit Library          *

  *                                                                *

- * Author: Arash Partow (1999-2022)                               *

+ * Author: Arash Partow (1999-2023)                               *

  * URL: https://www.partow.net/programming/exprtk/index.html      *

  *                                                                *

  * Copyright notice:                                              *

@@ -38,7 +38,6 @@

 #include <cassert>

 #include <cctype>

 #include <cmath>

-#include <complex>

 #include <cstdio>

 #include <cstdlib>

 #include <cstring>

@@ -298,7 +297,6 @@ namespace exprtk

          std::reverse(result.begin(), result.end());

-

          return result;

       }

@@ -401,7 +399,7 @@ namespace exprtk

       {

       public:

-         build_string(const std::size_t& initial_size = 64)

+         explicit build_string(const std::size_t& initial_size = 64)

          {

             data_.reserve(initial_size);

          }

@@ -605,6 +603,8 @@ namespace exprtk

                              const typename std::iterator_traits<Iterator>::value_type& zero_or_more,

                              const typename std::iterator_traits<Iterator>::value_type& exactly_one )

       {

+         typedef typename std::iterator_traits<Iterator>::value_type type;

+

          const Iterator null_itr(0);

          Iterator p_itr  = pattern_begin;

@@ -614,39 +614,45 @@ namespace exprtk

          for ( ; ; )

          {

-            const bool pvalid = p_itr != pattern_end;

-            const bool dvalid = d_itr != data_end;

-

-            if (!pvalid && !dvalid)

-               break;

-

-            if (pvalid)

+            if (p_itr != pattern_end)

             {

-               const typename std::iterator_traits<Iterator>::value_type c = *(p_itr);

+               const type c = *(p_itr);

-               if (zero_or_more == c)

+               if ((data_end != d_itr) && (Compare::cmp(c,*(d_itr)) || (exactly_one == c)))

                {

-                  np_itr = p_itr;

-                  nd_itr = d_itr + 1;

+                  ++d_itr;

                   ++p_itr;

                   continue;

                }

-               else if (dvalid && ((exactly_one == c) || Compare::cmp(c,*(d_itr))))

+               else if (zero_or_more == c)

                {

-                  ++p_itr;

-                  ++d_itr;

+                  while ((pattern_end != p_itr) && (zero_or_more == *(p_itr)))

+                  {

+                     ++p_itr;

+                  }

+

+                  const type d = *(p_itr);

+

+                  while ((data_end != d_itr) && !(Compare::cmp(d,*(d_itr)) || (exactly_one == d)))

+                  {

+                     ++d_itr;

+                  }

+

+                  // set backtrack iterators

+                  np_itr = p_itr - 1;

+                  nd_itr = d_itr + 1;

+

                   continue;

                }

             }

+            else if (data_end == d_itr)

+               return true;

-            if ((null_itr != nd_itr) && (nd_itr <= data_end))

-            {

-               p_itr = np_itr;

-               d_itr = nd_itr;

-               continue;

-            }

+            if ((data_end == d_itr) || (null_itr == nd_itr))

+                return false;

-            return false;

+            p_itr = np_itr;

+            d_itr = nd_itr;

          }

          return true;

@@ -774,7 +780,6 @@ namespace exprtk

          {

             struct unknown_type_tag { unknown_type_tag() {} };

             struct real_type_tag    { real_type_tag   () {} };

-            struct complex_type_tag { complex_type_tag() {} };

             struct int_type_tag     { int_type_tag    () {} };

             template <typename T>

@@ -788,10 +793,6 @@ namespace exprtk

             template <> struct number_type<T>                    \

             { typedef real_type_tag type; number_type() {} };    \

-            #define exprtk_register_complex_type_tag(T)          \

-            template <> struct number_type<std::complex<T> >     \

-            { typedef complex_type_tag type; number_type() {} }; \

-

             #define exprtk_register_int_type_tag(T)              \

             template <> struct number_type<T>                    \

             { typedef int_type_tag type; number_type() {} };     \

@@ -800,10 +801,6 @@ namespace exprtk

             exprtk_register_real_type_tag(long double)

             exprtk_register_real_type_tag(float      )

-            exprtk_register_complex_type_tag(double     )

-            exprtk_register_complex_type_tag(long double)

-            exprtk_register_complex_type_tag(float      )

-

             exprtk_register_int_type_tag(short         )

             exprtk_register_int_type_tag(int           )

             exprtk_register_int_type_tag(_int64_t      )

@@ -985,8 +982,8 @@ namespace exprtk

                   else

                      return (T(-0.5) * v + T(1)) * v;

                }

-               else

-                  return std::numeric_limits<T>::quiet_NaN();

+

+               return std::numeric_limits<T>::quiet_NaN();

             }

             template <typename T>

@@ -996,8 +993,8 @@ namespace exprtk

                {

                   return std::log(T(1) + v);

                }

-               else

-                  return std::numeric_limits<T>::quiet_NaN();

+

+               return std::numeric_limits<T>::quiet_NaN();

             }

             template <typename T>

@@ -2063,6 +2060,11 @@ namespace exprtk

          details::_uint64_t iteration_count;

       };

+      virtual bool check()

+      {

+         return true;

+      }

+

       virtual void handle_runtime_violation(const violation_context&)

       {

          throw std::runtime_error("ExprTk Loop run-time violation.");

@@ -3318,7 +3320,7 @@ namespace exprtk

                ignore_set_.insert(symbol);

             }

-            inline int insert(const lexer::token& t0, const lexer::token& t1, lexer::token& new_token)

+            inline int insert(const lexer::token& t0, const lexer::token& t1, lexer::token& new_token) exprtk_override

             {

                bool match         = false;

                new_token.type     = lexer::token::e_mul;

@@ -3365,7 +3367,7 @@ namespace exprtk

             std::set<std::string,details::ilesscompare> ignore_set_;

          };

-         class operator_joiner : public token_joiner

+         class operator_joiner exprtk_final : public token_joiner

          {

          public:

@@ -3373,7 +3375,7 @@ namespace exprtk

             : token_joiner(stride)

             {}

-            inline bool join(const lexer::token& t0, const lexer::token& t1, lexer::token& t)

+            inline bool join(const lexer::token& t0, const lexer::token& t1, lexer::token& t) exprtk_override

             {

                // ': =' --> ':='

                if ((t0.type == lexer::token::e_colon) && (t1.type == lexer::token::e_eq))

@@ -3521,7 +3523,7 @@ namespace exprtk

             inline bool join(const lexer::token& t0,

                              const lexer::token& t1,

                              const lexer::token& t2,

-                             lexer::token& t)

+                             lexer::token& t) exprtk_override

             {

                // '[ * ]' --> '[*]'

                if (

@@ -3541,7 +3543,7 @@ namespace exprtk

             }

          };

-         class bracket_checker : public lexer::token_scanner

+         class bracket_checker exprtk_final : public lexer::token_scanner

          {

          public:

@@ -3626,7 +3628,8 @@ namespace exprtk

             lexer::token error_token_;

          };

-         class numeric_checker : public lexer::token_scanner

+         template <typename T>

+         class numeric_checker exprtk_final : public lexer::token_scanner

          {

          public:

@@ -3652,7 +3655,7 @@ namespace exprtk

             {

                if (token::e_number == t.type)

                {

-                  double v;

+                  T v;

                   if (!exprtk::details::string_to_real(t.value,v))

                   {

@@ -3689,7 +3692,7 @@ namespace exprtk

             std::vector<std::size_t> error_list_;

          };

-         class symbol_replacer : public lexer::token_modifier

+         class symbol_replacer exprtk_final : public lexer::token_modifier

          {

          private:

@@ -3756,7 +3759,7 @@ namespace exprtk

             replace_map_t replace_map_;

          };

-         class sequence_validator : public lexer::token_scanner

+         class sequence_validator exprtk_final : public lexer::token_scanner

          {

          private:

@@ -3928,7 +3931,7 @@ namespace exprtk

             std::vector<std::pair<lexer::token,lexer::token> > error_list_;

          };

-         class sequence_validator_3tokens : public lexer::token_scanner

+         class sequence_validator_3tokens exprtk_final : public lexer::token_scanner

          {

          private:

@@ -4762,12 +4765,12 @@ namespace exprtk

       inline void dump_ptr(const std::string& s, const void* ptr, const std::size_t size = 0)

       {

          if (size)

-            exprtk_debug(("%s - addr: %p\n",s.c_str(),ptr));

-         else

             exprtk_debug(("%s - addr: %p size: %d\n",

                           s.c_str(),

                           ptr,

                           static_cast<unsigned int>(size)));

+         else

+            exprtk_debug(("%s - addr: %p\n",s.c_str(),ptr));

       }

       #else

       inline void dump_ptr(const std::string&, const void*) {}

@@ -4811,7 +4814,7 @@ namespace exprtk

             {

                if (data && destruct && (0 == ref_count))

                {

-                  dump_ptr("~control_block() data",data);

+                  dump_ptr("~vec_data_store::control_block() data",data);

                   delete[] data;

                   data = reinterpret_cast<data_t>(0);

                }

@@ -5224,12 +5227,6 @@ namespace exprtk

          return std::not_equal_to<float>()(0.0f,v);

       }

-      template <typename T>

-      inline bool is_true(const std::complex<T>& v)

-      {

-         return std::not_equal_to<std::complex<T> >()(std::complex<T>(0),v);

-      }

-

       template <typename T>

       inline bool is_true(const expression_node<T>* node)

       {

@@ -5342,7 +5339,11 @@ namespace exprtk

       template <typename T>

       inline bool is_constant_node(const expression_node<T>* node)

       {

-         return node && (details::expression_node<T>::e_constant == node->type());

+         return node &&

+         (

+           details::expression_node<T>::e_constant    == node->type() ||

+           details::expression_node<T>::e_stringconst == node->type()

+         );

       }

       template <typename T>

@@ -5395,7 +5396,7 @@ namespace exprtk

       }

       template <typename T>

-      inline bool branch_deletable(expression_node<T>* node)

+      inline bool branch_deletable(const expression_node<T>* node)

       {

          return (0 != node)             &&

                 !is_variable_node(node) &&

@@ -5403,7 +5404,7 @@ namespace exprtk

       }

       template <std::size_t N, typename T>

-      inline bool all_nodes_valid(expression_node<T>* (&b)[N])

+      inline bool all_nodes_valid(expression_node<T>* const (&b)[N])

       {

          for (std::size_t i = 0; i < N; ++i)

          {

@@ -5427,7 +5428,7 @@ namespace exprtk

       }

       template <std::size_t N, typename T>

-      inline bool all_nodes_variables(expression_node<T>* (&b)[N])

+      inline bool all_nodes_variables(expression_node<T>* const (&b)[N])

       {

          for (std::size_t i = 0; i < N; ++i)

          {

@@ -5443,7 +5444,7 @@ namespace exprtk

       template <typename T,

                 typename Allocator,

                 template <typename, typename> class Sequence>

-      inline bool all_nodes_variables(Sequence<expression_node<T>*,Allocator>& b)

+      inline bool all_nodes_variables(const Sequence<expression_node<T>*,Allocator>& b)

       {

          for (std::size_t i = 0; i < b.size(); ++i)

          {

@@ -5829,7 +5830,7 @@ namespace exprtk

             virtual std::size_t vector_size()              const = 0;

          };

-         class array_vector_impl : public vector_holder_base

+         class array_vector_impl exprtk_final : public vector_holder_base

          {

          public:

@@ -5840,7 +5841,7 @@ namespace exprtk

          protected:

-            value_ptr value_at(const std::size_t& index) const

+            value_ptr value_at(const std::size_t& index) const exprtk_override

             {

                if (index < size_)

                   return const_cast<const_value_ptr>(vec_ + index);

@@ -5848,7 +5849,7 @@ namespace exprtk

                   return const_value_ptr(0);

             }

-            std::size_t vector_size() const

+            std::size_t vector_size() const exprtk_override

             {

                return size_;

             }

@@ -5864,24 +5865,24 @@ namespace exprtk

          template <typename Allocator,

                    template <typename, typename> class Sequence>

-         class sequence_vector_impl : public vector_holder_base

+         class sequence_vector_impl exprtk_final : public vector_holder_base

          {

          public:

             typedef Sequence<Type,Allocator> sequence_t;

-            sequence_vector_impl(sequence_t& seq)

+            explicit sequence_vector_impl(sequence_t& seq)

             : sequence_(seq)

             {}

          protected:

-            value_ptr value_at(const std::size_t& index) const

+            value_ptr value_at(const std::size_t& index) const exprtk_override

             {

                return (index < sequence_.size()) ? (&sequence_[index]) : const_value_ptr(0);

             }

-            std::size_t vector_size() const

+            std::size_t vector_size() const exprtk_override

             {

                return sequence_.size();

             }

@@ -5894,7 +5895,7 @@ namespace exprtk

             sequence_t& sequence_;

          };

-         class vector_view_impl : public vector_holder_base

+         class vector_view_impl exprtk_final : public vector_holder_base

          {

          public:

@@ -5904,24 +5905,24 @@ namespace exprtk

             : vec_view_(vec_view)

             {}

-            void set_ref(value_ptr* ref)

+            void set_ref(value_ptr* ref) exprtk_override

             {

                vec_view_.set_ref(ref);

             }

-            virtual inline bool rebaseable() const

+            bool rebaseable() const exprtk_override

             {

                return true;

             }

          protected:

-            value_ptr value_at(const std::size_t& index) const

+            value_ptr value_at(const std::size_t& index) const exprtk_override

             {

                return (index < vec_view_.size()) ? (&vec_view_[index]) : const_value_ptr(0);

             }

-            std::size_t vector_size() const

+            std::size_t vector_size() const exprtk_override

             {

                return vec_view_.size();

             }

@@ -5942,16 +5943,16 @@ namespace exprtk

          : vector_holder_base_(new(buffer)array_vector_impl(vec,vec_size))

          {}

-         vector_holder(const vds_t& vds)

+         explicit vector_holder(const vds_t& vds)

          : vector_holder_base_(new(buffer)array_vector_impl(vds.data(),vds.size()))

          {}

          template <typename Allocator>

-         vector_holder(std::vector<Type,Allocator>& vec)

+         explicit vector_holder(std::vector<Type,Allocator>& vec)

          : vector_holder_base_(new(buffer)sequence_vector_impl<Allocator,std::vector>(vec))

          {}

-         vector_holder(exprtk::vector_view<Type>& vec)

+         explicit vector_holder(exprtk::vector_view<Type>& vec)

          : vector_holder_base_(new(buffer)vector_view_impl(vec))

          {}

@@ -6069,9 +6070,9 @@ namespace exprtk

             const bool result = details::numeric::is_nan(v);

             if (result)

-               return (equality_) ? T(1) : T(0);

+               return equality_ ? T(1) : T(0);

             else

-               return (equality_) ? T(0) : T(1);

+               return equality_ ? T(0) : T(1);

          }

          inline typename expression_node<T>::node_type type() const exprtk_override

@@ -6255,9 +6256,7 @@ namespace exprtk

          inline T value() const exprtk_override

          {

             assert(branch_.first);

-

             const T arg = branch_.first->value();

-

             return numeric::process<T>(operation_,arg);

          }

@@ -6286,12 +6285,12 @@ namespace exprtk

             expression_node<T>::ndb_t::collect(branch_, node_delete_list);

          }

-         std::size_t node_depth() const exprtk_override exprtk_final

+         std::size_t node_depth() const exprtk_final

          {

             return expression_node<T>::ndb_t::compute_node_depth(branch_);

          }

-      protected:

+      private:

          operator_type operation_;

          branch_t branch_;

@@ -6321,7 +6320,7 @@ namespace exprtk

             const T arg0 = branch_[0].first->value();

             const T arg1 = branch_[1].first->value();

-            return numeric::process<T>(operation_,arg0,arg1);

+            return numeric::process<T>(operation_, arg0, arg1);

          }

          inline typename expression_node<T>::node_type type() const exprtk_override

@@ -6349,12 +6348,12 @@ namespace exprtk

             expression_node<T>::ndb_t::template collect(branch_, node_delete_list);

          }

-         std::size_t node_depth() const exprtk_override exprtk_final

+         std::size_t node_depth() const exprtk_final

          {

             return expression_node<T>::ndb_t::template compute_node_depth<2>(branch_);

          }

-      protected:

+      private:

          operator_type operation_;

          branch_t branch_[2];

@@ -6733,7 +6732,7 @@ namespace exprtk

          {

             if (

                  (0 == loop_runtime_check_) ||

-                 (++iteration_count_ <= max_loop_iterations_)

+                 ((++iteration_count_ <= max_loop_iterations_) && loop_runtime_check_->check())

                )

             {

                return true;

@@ -7408,8 +7407,8 @@ namespace exprtk

                return arg_list_[upper_bound].first->value();

             }

-            else

-               return std::numeric_limits<T>::quiet_NaN();

+

+            return std::numeric_limits<T>::quiet_NaN();

          }

          inline typename expression_node<T>::node_type type() const exprtk_override exprtk_final

@@ -8169,6 +8168,8 @@ namespace exprtk

          typedef vector_node    <T>* vector_node_ptr;

          typedef vec_data_store <T>  vds_t;

+         using binary_node<T>::branch;

+

          swap_vecvec_node(expression_ptr branch0,

                           expression_ptr branch1)

          : binary_node<T>(details::e_swap, branch0, branch1)

@@ -8177,22 +8178,22 @@ namespace exprtk

          , vec_size_     (0)

          , initialised_  (false)

          {

-            if (is_ivector_node(binary_node<T>::branch_[0].first))

+            if (is_ivector_node(branch(0)))

             {

                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);

-               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[0].first)))

+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(branch(0))))

                {

                   vec0_node_ptr_ = vi->vec();

                   vds()          = vi->vds();

                }

             }

-            if (is_ivector_node(binary_node<T>::branch_[1].first))

+            if (is_ivector_node(branch(1)))

             {

                vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);

-               if (0 != (vi = dynamic_cast<vector_interface<T>*>(binary_node<T>::branch_[1].first)))

+               if (0 != (vi = dynamic_cast<vector_interface<T>*>(branch(1))))

                {

                   vec1_node_ptr_ = vi->vec();

                }

@@ -8213,11 +8214,11 @@ namespace exprtk

          {

             if (initialised_)

             {

-               assert(binary_node<T>::branch_[0].first);

-               assert(binary_node<T>::branch_[1].first);

+               assert(branch(0));

+               assert(branch(1));

-               binary_node<T>::branch_[0].first->value();

-               binary_node<T>::branch_[1].first->value();

+               binary_node<T>::branch(0)->value();

+               binary_node<T>::branch(1)->value();

                T* vec0 = vec0_node_ptr_->vds().data();

                T* vec1 = vec1_node_ptr_->vds().data();

@@ -8229,8 +8230,8 @@ namespace exprtk

                return vec1_node_ptr_->value();

             }

-            else

-               return std::numeric_limits<T>::quiet_NaN();

+

+            return std::numeric_limits<T>::quiet_NaN();

          }

          vector_node_ptr vec() const exprtk_override

@@ -8678,6 +8679,8 @@ namespace exprtk

          typedef expression_node <T>* expression_ptr;

          typedef string_base_node<T>* str_base_ptr;

+         using binary_node<T>::branch;

+

          string_concat_node(const operator_type& opr,

                             expression_ptr branch0,

                             expression_ptr branch1)

@@ -8694,27 +8697,27 @@ namespace exprtk

             range_.cache.first  = range_.n0_c.second;

             range_.cache.second = range_.n1_c.second;

-            if (is_generally_string_node(binary_node<T>::branch_[0].first))

+            if (is_generally_string_node(branch(0)))

             {

-               str0_base_ptr_ = dynamic_cast<str_base_ptr>(binary_node<T>::branch_[0].first);

+               str0_base_ptr_ = dynamic_cast<str_base_ptr>(branch(0));

                if (0 == str0_base_ptr_)

                   return;

-               str0_range_ptr_ = dynamic_cast<irange_ptr>(binary_node<T>::branch_[0].first);

+               str0_range_ptr_ = dynamic_cast<irange_ptr>(branch(0));

                if (0 == str0_range_ptr_)

                   return;

             }

-            if (is_generally_string_node(binary_node<T>::branch_[1].first))

+            if (is_generally_string_node(branch(1)))

             {

-               str1_base_ptr_ = dynamic_cast<str_base_ptr>(binary_node<T>::branch_[1].first);

+               str1_base_ptr_ = dynamic_cast<str_base_ptr>(branch(1));

                if (0 == str1_base_ptr_)

                   return;

-               str1_range_ptr_ = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first);

+               str1_range_ptr_ = dynamic_cast<irange_ptr>(branch(1));

                if (0 == str1_range_ptr_)

                   return;

@@ -8732,11 +8735,11 @@ namespace exprtk

          {

             if (initialised_)

             {

-               assert(binary_node<T>::branch_[0].first);

-               assert(binary_node<T>::branch_[1].first);

+               assert(branch(0));

+               assert(branch(1));

-               binary_node<T>::branch_[0].first->value();

-               binary_node<T>::branch_[1].first->value();

+               branch(0)->value();

+               branch(1)->value();

                std::size_t str0_r0 = 0;

                std::size_t str0_r1 = 0;

@@ -8823,20 +8826,22 @@ namespace exprtk

          typedef stringvar_node  <T>* strvar_node_ptr;

          typedef string_base_node<T>* str_base_ptr;

+         using binary_node<T>::branch;

+

          swap_string_node(expression_ptr branch0, expression_ptr branch1)

          : binary_node<T>(details::e_swap, branch0, branch1),

            initialised_(false),

            str0_node_ptr_(0),

            str1_node_ptr_(0)

          {

-            if (is_string_node(binary_node<T>::branch_[0].first))

+            if (is_string_node(branch(0)))

             {

-               str0_node_ptr_ = static_cast<strvar_node_ptr>(binary_node<T>::branch_[0].first);

+               str0_node_ptr_ = static_cast<strvar_node_ptr>(branch(0));

             }

-            if (is_string_node(binary_node<T>::branch_[1].first))

+            if (is_string_node(branch(1)))

             {

-               str1_node_ptr_ = static_cast<strvar_node_ptr>(binary_node<T>::branch_[1].first);

+               str1_node_ptr_ = static_cast<strvar_node_ptr>(branch(1));

             }

             initialised_ = (str0_node_ptr_ && str1_node_ptr_);

@@ -8848,11 +8853,11 @@ namespace exprtk

          {

             if (initialised_)

             {

-               assert(binary_node<T>::branch_[0].first);

-               assert(binary_node<T>::branch_[1].first);

+               assert(branch(0));

+               assert(branch(1));

-               binary_node<T>::branch_[0].first->value();

-               binary_node<T>::branch_[1].first->value();

+               branch(0)->value();

+               branch(1)->value();

                std::swap(str0_node_ptr_->ref(), str1_node_ptr_->ref());

             }

@@ -8909,6 +8914,8 @@ namespace exprtk

          typedef expression_node <T>* expression_ptr;

          typedef string_base_node<T>* str_base_ptr;

+         using binary_node<T>::branch;

+

          swap_genstrings_node(expression_ptr branch0,

                               expression_ptr branch1)

          : binary_node<T>(details::e_default, branch0, branch1)

@@ -8918,14 +8925,14 @@ namespace exprtk

          , str1_range_ptr_(0)

          , initialised_(false)

          {

-            if (is_generally_string_node(binary_node<T>::branch_[0].first))

+            if (is_generally_string_node(branch(0)))

             {

-               str0_base_ptr_ = dynamic_cast<str_base_ptr>(binary_node<T>::branch_[0].first);

+               str0_base_ptr_ = dynamic_cast<str_base_ptr>(branch(0));

                if (0 == str0_base_ptr_)

                   return;

-               irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[0].first);

+               irange_ptr range = dynamic_cast<irange_ptr>(branch(0));

                if (0 == range)

                   return;

@@ -8933,14 +8940,14 @@ namespace exprtk

                str0_range_ptr_ = &(range->range_ref());

             }

-            if (is_generally_string_node(binary_node<T>::branch_[1].first))

+            if (is_generally_string_node(branch(1)))

             {

-               str1_base_ptr_ = dynamic_cast<str_base_ptr>(binary_node<T>::branch_[1].first);

+               str1_base_ptr_ = dynamic_cast<str_base_ptr>(branch(1));

                if (0 == str1_base_ptr_)

                   return;

-               irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first);

+               irange_ptr range = dynamic_cast<irange_ptr>(branch(1));

                if (0 == range)

                   return;

@@ -8960,11 +8967,11 @@ namespace exprtk

          {

             if (initialised_)

             {

-               assert(binary_node<T>::branch_[0].first);

-               assert(binary_node<T>::branch_[1].first);

+               assert(branch(0));

+               assert(branch(1));

-               binary_node<T>::branch_[0].first->value();

-               binary_node<T>::branch_[1].first->value();

+               branch(0)->value();

+               branch(1)->value();

                std::size_t str0_r0 = 0;

                std::size_t str0_r1 = 0;

@@ -9174,6 +9181,8 @@ namespace exprtk

          typedef stringvar_node  <T>* strvar_node_ptr;

          typedef string_base_node<T>* str_base_ptr;

+         using binary_node<T>::branch;

+

          assignment_string_node(const operator_type& opr,

                                 expression_ptr branch0,

                                 expression_ptr branch1)

@@ -9184,21 +9193,20 @@ namespace exprtk

          , str0_node_ptr_ (0)

          , str1_range_ptr_(0)

          {

-            if (is_string_node(binary_node<T>::branch_[0].first))

+            if (is_string_node(branch(0)))

             {

-               str0_node_ptr_ = static_cast<strvar_node_ptr>(binary_node<T>::branch_[0].first);

-

-               str0_base_ptr_ = dynamic_cast<str_base_ptr>(binary_node<T>::branch_[0].first);

+               str0_node_ptr_ = static_cast<strvar_node_ptr>(branch(0));

+               str0_base_ptr_ = dynamic_cast<str_base_ptr>(branch(0));

             }

-            if (is_generally_string_node(binary_node<T>::branch_[1].first))

+            if (is_generally_string_node(branch(1)))

             {

-               str1_base_ptr_ = dynamic_cast<str_base_ptr>(binary_node<T>::branch_[1].first);

+               str1_base_ptr_ = dynamic_cast<str_base_ptr>(branch(1));

                if (0 == str1_base_ptr_)

                   return;

-               irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first);

+               irange_ptr range = dynamic_cast<irange_ptr>(branch(1));

                if (0 == range)

                   return;

@@ -9218,10 +9226,10 @@ namespace exprtk

          {

             if (initialised_)

             {

-               assert(binary_node<T>::branch_[0].first);

-               assert(binary_node<T>::branch_[1].first);

+               assert(branch(0));

+               assert(branch(1));

-               binary_node<T>::branch_[1].first->value();

+               branch(1)->value();

                std::size_t r0 = 0;

                std::size_t r1 = 0;

@@ -9234,7 +9242,7 @@ namespace exprtk

                                              str1_base_ptr_->base() + r0,

                                              (r1 - r0) + 1);

-                  binary_node<T>::branch_[0].first->value();

+                  branch(0)->value();

                }

             }

@@ -9297,6 +9305,8 @@ namespace exprtk

          typedef string_range_node<T>* str_rng_node_ptr;

          typedef string_base_node <T>* str_base_ptr;

+         using binary_node<T>::branch;

+

          assignment_string_range_node(const operator_type& opr,

                                       expression_ptr branch0,

                                       expression_ptr branch1)

@@ -9308,13 +9318,11 @@ namespace exprtk

          , str0_range_ptr_   (0)

          , str1_range_ptr_   (0)

          {

-            if (is_string_range_node(binary_node<T>::branch_[0].first))

+            if (is_string_range_node(branch(0)))

             {

-               str0_rng_node_ptr_ = static_cast<str_rng_node_ptr>(binary_node<T>::branch_[0].first);

-

-               str0_base_ptr_ = dynamic_cast<str_base_ptr>(binary_node<T>::branch_[0].first);

-

-               irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[0].first);

+               str0_rng_node_ptr_ = static_cast<str_rng_node_ptr>(branch(0));

+               str0_base_ptr_     = dynamic_cast<str_base_ptr>(branch(0));

+               irange_ptr range   = dynamic_cast<irange_ptr>(branch(0));

                if (0 == range)

                   return;

@@ -9322,14 +9330,14 @@ namespace exprtk

                str0_range_ptr_ = &(range->range_ref());

             }

-            if (is_generally_string_node(binary_node<T>::branch_[1].first))

+            if (is_generally_string_node(branch(1)))

             {

-               str1_base_ptr_ = dynamic_cast<str_base_ptr>(binary_node<T>::branch_[1].first);

+               str1_base_ptr_ = dynamic_cast<str_base_ptr>(branch(1));

                if (0 == str1_base_ptr_)

                   return;

-               irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first);

+               irange_ptr range = dynamic_cast<irange_ptr>(branch(1));

                if (0 == range)

                   return;

@@ -9350,11 +9358,11 @@ namespace exprtk