C++ Mathematical Expression Library (ExprTk) http://www.partow.net/programming/exprtk/index.html
diff --git a/Makefile b/Makefile index 16e0357..76d43a0 100644 --- a/Makefile +++ b/Makefile
@@ -2,7 +2,7 @@ # ************************************************************** # * C++ Mathematical Expression Toolkit Library * # * * -# * Author: Arash Partow (1999-2018) * +# * Author: Arash Partow (1999-2020) * # * URL: http://www.partow.net/programming/exprtk/index.html * # * * # * Copyright notice: * @@ -16,7 +16,7 @@ COMPILER := -c++ -#COMPILER := -clang +#COMPILER := -clang++ OPTIMIZATION_OPT := -O1 BASE_OPTIONS := -pedantic-errors -Wall -Wextra -Werror -Wno-long-long OPTIONS := $(BASE_OPTIONS) $(OPTIMIZATION_OPT)
diff --git a/exprtk.hpp b/exprtk.hpp index 670eda9..ca38375 100644 --- a/exprtk.hpp +++ b/exprtk.hpp
@@ -2,7 +2,7 @@ ****************************************************************** * C++ Mathematical Expression Toolkit Library * * * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -83,12 +83,14 @@ namespace details { - typedef unsigned char uchar_t; - typedef char char_t; - typedef uchar_t* uchar_ptr; - typedef char_t* char_ptr; - typedef uchar_t const* uchar_cptr; - typedef char_t const* char_cptr; + typedef unsigned char uchar_t; + typedef char char_t; + typedef uchar_t* uchar_ptr; + typedef char_t* char_ptr; + typedef uchar_t const* uchar_cptr; + typedef char_t const* char_cptr; + typedef unsigned long long int _uint64_t; + typedef long long int _int64_t; inline bool is_whitespace(const char_t c) { @@ -580,46 +582,64 @@ template <typename Iterator, typename Compare> inline bool match_impl(const Iterator pattern_begin, - const Iterator pattern_end, - const Iterator data_begin, - const Iterator data_end, + const Iterator pattern_end , + const Iterator data_begin , + const Iterator data_end , const typename std::iterator_traits<Iterator>::value_type& zero_or_more, - const typename std::iterator_traits<Iterator>::value_type& zero_or_one) + const typename std::iterator_traits<Iterator>::value_type& zero_or_one ) { - Iterator d_itr = data_begin; - Iterator p_itr = pattern_begin; + const Iterator null_itr(0); - while ((p_itr != pattern_end) && (d_itr != data_end)) + Iterator d_itr = data_begin; + Iterator p_itr = pattern_begin; + Iterator tb_p_itr = null_itr; + Iterator tb_d_itr = null_itr; + + while (d_itr != data_end) { if (zero_or_more == *p_itr) { - while ((p_itr != pattern_end) && (*p_itr == zero_or_more || *p_itr == zero_or_one)) + while ((pattern_end != p_itr) && ((zero_or_more == *p_itr) || (zero_or_one == *p_itr))) { ++p_itr; } - if (p_itr == pattern_end) + if (pattern_end == p_itr) return true; - const typename std::iterator_traits<Iterator>::value_type c = *(p_itr++); + const typename std::iterator_traits<Iterator>::value_type c = *(p_itr); - while ((d_itr != data_end) && !Compare::cmp(c,*d_itr)) + while ((data_end != d_itr) && !Compare::cmp(c,*d_itr)) { ++d_itr; } - ++d_itr; + tb_p_itr = p_itr; + tb_d_itr = d_itr; + + continue; } - else if ((*p_itr == zero_or_one) || Compare::cmp(*p_itr, *d_itr)) + else if (!Compare::cmp(*p_itr, *d_itr) && (zero_or_one != *p_itr)) { - ++d_itr; - ++p_itr; + if (null_itr == tb_d_itr) + return false; + + d_itr = tb_d_itr++; + p_itr = tb_p_itr; + + continue; } - else - return false; + + ++p_itr; + ++d_itr; } - return (d_itr == data_end) && (p_itr == pattern_end); + while ((pattern_end != p_itr) && ((zero_or_more == *p_itr) || (zero_or_one == *p_itr))) + { + ++p_itr; + } + + return (pattern_end == p_itr); } inline bool wc_match(const std::string& wild_card, @@ -774,12 +794,12 @@ 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(long long int ) - exprtk_register_int_type_tag(unsigned short ) - exprtk_register_int_type_tag(unsigned int ) - exprtk_register_int_type_tag(unsigned long long int) + exprtk_register_int_type_tag(short ) + exprtk_register_int_type_tag(int ) + exprtk_register_int_type_tag(_int64_t ) + exprtk_register_int_type_tag(unsigned short) + exprtk_register_int_type_tag(unsigned int ) + exprtk_register_int_type_tag(_uint64_t ) #undef exprtk_register_real_type_tag #undef exprtk_register_int_type_tag @@ -827,9 +847,9 @@ } template <typename T> - inline long long int to_int64_impl(const T v, real_type_tag) + inline _int64_t to_int64_impl(const T v, real_type_tag) { - return static_cast<long long int>(v); + return static_cast<_int64_t>(v); } template <typename T> @@ -1367,7 +1387,7 @@ } template <typename T> - inline long long int to_int64(const T v) + inline _int64_t to_int64(const T v) { const typename details::number_type<T>::type num_type; return to_int64_impl(v, num_type); @@ -1828,7 +1848,7 @@ bool instate = false; - static const char zero = static_cast<uchar_t>('0'); + static const char_t zero = static_cast<uchar_t>('0'); #define parse_digit_1(d) \ if ((digit = (*itr - zero)) < 10) \ @@ -2305,8 +2325,8 @@ inline std::string substr(const std::size_t& begin, const std::size_t& end) { - details::char_cptr begin_itr = ((base_itr_ + begin) < s_end_) ? (base_itr_ + begin) : s_end_; - details::char_cptr end_itr = ((base_itr_ + end) < s_end_) ? (base_itr_ + end) : s_end_; + const details::char_cptr begin_itr = ((base_itr_ + begin) < s_end_) ? (base_itr_ + begin) : s_end_; + const details::char_cptr end_itr = ((base_itr_ + end) < s_end_) ? (base_itr_ + end) : s_end_; return std::string(begin_itr,end_itr); } @@ -2316,9 +2336,9 @@ if (finished()) return ""; else if (token_list_.begin() != token_itr_) - return std::string(base_itr_ + (token_itr_ - 1)->position,s_end_); + return std::string(base_itr_ + (token_itr_ - 1)->position, s_end_); else - return std::string(base_itr_ + token_itr_->position,s_end_); + return std::string(base_itr_ + token_itr_->position, s_end_); } private: @@ -3068,7 +3088,7 @@ { public: - token_joiner(const std::size_t& stride) + explicit token_joiner(const std::size_t& stride) : stride_(stride) {} @@ -3099,7 +3119,7 @@ std::size_t changes = 0; - for (std::size_t i = 0; i < (g.token_list_.size() - 1); ++i) + for (int i = 0; i < static_cast<int>(g.token_list_.size() - 1); ++i) { token t; @@ -3110,6 +3130,9 @@ g.token_list_.erase(g.token_list_.begin() + static_cast<diff_t>(i + 1)); ++changes; + + if (static_cast<std::size_t>(i + 1) >= g.token_list_.size()) + break; } } @@ -3125,7 +3148,7 @@ std::size_t changes = 0; - for (std::size_t i = 0; i < (g.token_list_.size() - 2); ++i) + for (int i = 0; i < static_cast<int>(g.token_list_.size() - 2); ++i) { token t; @@ -3136,6 +3159,9 @@ g.token_list_.erase(g.token_list_.begin() + static_cast<diff_t>(i + 1), g.token_list_.begin() + static_cast<diff_t>(i + 3)); ++changes; + + if (static_cast<std::size_t>(i + 2) >= g.token_list_.size()) + break; } } @@ -3213,6 +3239,7 @@ else if ((t0.type == lexer::token::e_rbracket ) && (t1.type == lexer::token::e_symbol )) match = true; else if ((t0.type == lexer::token::e_rcrlbracket) && (t1.type == lexer::token::e_symbol )) match = true; else if ((t0.type == lexer::token::e_rsqrbracket) && (t1.type == lexer::token::e_symbol )) match = true; + else if ((t0.type == lexer::token::e_symbol ) && (t1.type == lexer::token::e_symbol )) match = true; return (match) ? 1 : -1; } @@ -3226,7 +3253,7 @@ { public: - operator_joiner(const std::size_t& stride) + explicit operator_joiner(const std::size_t& stride) : token_joiner(stride) {} @@ -3624,10 +3651,11 @@ sequence_validator() : lexer::token_scanner(2) { - add_invalid(lexer::token::e_number ,lexer::token::e_number ); - add_invalid(lexer::token::e_string ,lexer::token::e_string ); - add_invalid(lexer::token::e_number ,lexer::token::e_string ); - add_invalid(lexer::token::e_string ,lexer::token::e_number ); + add_invalid(lexer::token::e_number, lexer::token::e_number); + add_invalid(lexer::token::e_string, lexer::token::e_string); + add_invalid(lexer::token::e_number, lexer::token::e_string); + add_invalid(lexer::token::e_string, lexer::token::e_number); + add_invalid_set1(lexer::token::e_assign ); add_invalid_set1(lexer::token::e_shr ); add_invalid_set1(lexer::token::e_shl ); @@ -3655,7 +3683,7 @@ bool operator() (const lexer::token& t0, const lexer::token& t1) { - set_t::value_type p = std::make_pair(t0.type,t1.type); + const set_t::value_type p = std::make_pair(t0.type,t1.type); if (invalid_bracket_check(t0.type,t1.type)) { @@ -3669,7 +3697,7 @@ return true; } - std::size_t error_count() + std::size_t error_count() const { return error_list_.size(); } @@ -3701,21 +3729,21 @@ void add_invalid_set1(lexer::token::token_type t) { - add_invalid(t,lexer::token::e_assign); - add_invalid(t,lexer::token::e_shr ); - add_invalid(t,lexer::token::e_shl ); - add_invalid(t,lexer::token::e_lte ); - add_invalid(t,lexer::token::e_ne ); - add_invalid(t,lexer::token::e_gte ); - add_invalid(t,lexer::token::e_lt ); - add_invalid(t,lexer::token::e_gt ); - add_invalid(t,lexer::token::e_eq ); - add_invalid(t,lexer::token::e_comma ); - add_invalid(t,lexer::token::e_div ); - add_invalid(t,lexer::token::e_mul ); - add_invalid(t,lexer::token::e_mod ); - add_invalid(t,lexer::token::e_pow ); - add_invalid(t,lexer::token::e_colon ); + add_invalid(t, lexer::token::e_assign); + add_invalid(t, lexer::token::e_shr ); + add_invalid(t, lexer::token::e_shl ); + add_invalid(t, lexer::token::e_lte ); + add_invalid(t, lexer::token::e_ne ); + add_invalid(t, lexer::token::e_gte ); + add_invalid(t, lexer::token::e_lt ); + add_invalid(t, lexer::token::e_gt ); + add_invalid(t, lexer::token::e_eq ); + add_invalid(t, lexer::token::e_comma ); + add_invalid(t, lexer::token::e_div ); + add_invalid(t, lexer::token::e_mul ); + add_invalid(t, lexer::token::e_mod ); + add_invalid(t, lexer::token::e_pow ); + add_invalid(t, lexer::token::e_colon ); } bool invalid_bracket_check(lexer::token::token_type base, lexer::token::token_type t) @@ -3725,7 +3753,7 @@ switch (t) { case lexer::token::e_assign : return (']' != base); - case lexer::token::e_string : return true; + case lexer::token::e_string : return (')' != base); default : return false; } } @@ -3781,6 +3809,91 @@ std::vector<std::pair<lexer::token,lexer::token> > error_list_; }; + class sequence_validator_3tokens : public lexer::token_scanner + { + private: + + typedef lexer::token::token_type token_t; + typedef std::pair<token_t,std::pair<token_t,token_t> > token_triplet_t; + typedef std::set<token_triplet_t> set_t; + + public: + + using lexer::token_scanner::operator(); + + sequence_validator_3tokens() + : lexer::token_scanner(3) + { + add_invalid(lexer::token::e_number, lexer::token::e_number, lexer::token::e_number); + add_invalid(lexer::token::e_string, lexer::token::e_string, lexer::token::e_string); + add_invalid(lexer::token::e_comma , lexer::token::e_comma , lexer::token::e_comma ); + + add_invalid(lexer::token::e_add , lexer::token::e_add , lexer::token::e_add ); + add_invalid(lexer::token::e_sub , lexer::token::e_sub , lexer::token::e_sub ); + add_invalid(lexer::token::e_div , lexer::token::e_div , lexer::token::e_div ); + add_invalid(lexer::token::e_mul , lexer::token::e_mul , lexer::token::e_mul ); + add_invalid(lexer::token::e_mod , lexer::token::e_mod , lexer::token::e_mod ); + add_invalid(lexer::token::e_pow , lexer::token::e_pow , lexer::token::e_pow ); + + add_invalid(lexer::token::e_add , lexer::token::e_sub , lexer::token::e_add ); + add_invalid(lexer::token::e_sub , lexer::token::e_add , lexer::token::e_sub ); + add_invalid(lexer::token::e_div , lexer::token::e_mul , lexer::token::e_div ); + add_invalid(lexer::token::e_mul , lexer::token::e_div , lexer::token::e_mul ); + add_invalid(lexer::token::e_mod , lexer::token::e_pow , lexer::token::e_mod ); + add_invalid(lexer::token::e_pow , lexer::token::e_mod , lexer::token::e_pow ); + } + + bool result() + { + return error_list_.empty(); + } + + bool operator() (const lexer::token& t0, const lexer::token& t1, const lexer::token& t2) + { + const set_t::value_type p = std::make_pair(t0.type,std::make_pair(t1.type,t2.type)); + + if (invalid_comb_.find(p) != invalid_comb_.end()) + { + error_list_.push_back(std::make_pair(t0,t1)); + } + + return true; + } + + std::size_t error_count() const + { + return error_list_.size(); + } + + std::pair<lexer::token,lexer::token> error(const std::size_t index) + { + if (index < error_list_.size()) + { + return error_list_[index]; + } + else + { + static const lexer::token error_token; + return std::make_pair(error_token,error_token); + } + } + + void clear_errors() + { + error_list_.clear(); + } + + private: + + void add_invalid(token_t t0, token_t t1, token_t t2) + { + invalid_comb_.insert(std::make_pair(t0,std::make_pair(t1,t2))); + } + + set_t invalid_comb_; + std::vector<std::pair<lexer::token,lexer::token> > error_list_; + }; + struct helper_assembly { inline bool register_scanner(lexer::token_scanner* scanner) @@ -4035,40 +4148,6 @@ return true; } - inline bool token_is_then_assign(const token_t::token_type& ttype, - std::string& token, - const token_advance_mode mode = e_advance) - { - if (current_token_.type != ttype) - { - return false; - } - - token = current_token_.value; - - advance_token(mode); - - return true; - } - - template <typename Allocator, - template <typename,typename> class Container> - inline bool token_is_then_assign(const token_t::token_type& ttype, - Container<std::string,Allocator>& token_list, - const token_advance_mode mode = e_advance) - { - if (current_token_.type != ttype) - { - return false; - } - - token_list.push_back(current_token_.value); - - advance_token(mode); - - return true; - } - inline bool peek_token_is(const token_t::token_type& ttype) { return (lexer_.peek_next_token().type == ttype); @@ -4155,14 +4234,14 @@ inline vector_view<T> make_vector_view(T* data, const std::size_t size, const std::size_t offset = 0) { - return vector_view<T>(data + offset,size); + return vector_view<T>(data + offset, size); } template <typename T> inline vector_view<T> make_vector_view(std::vector<T>& v, const std::size_t size, const std::size_t offset = 0) { - return vector_view<T>(v.data() + offset,size); + return vector_view<T>(v.data() + offset, size); } template <typename T> class results_context; @@ -4179,13 +4258,18 @@ }; type_store() - : size(0), - data(0), + : data(0), + size(0), type(e_unknown) {} + union + { + void* data; + T* vec_data; + }; + std::size_t size; - void* data; store_type type; class parameter_list @@ -4491,27 +4575,33 @@ { 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"; + 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 ">" ; + case e_and : return "and" ; + case e_or : return "or" ; + case e_xor : return "xor" ; + case e_nand : return "nand"; + case e_nor : return "nor" ; + case e_xnor : return "xnor"; + default : return "N/A" ; } } @@ -4585,16 +4675,16 @@ {} control_block(const std::size_t& dsize) - : ref_count(1), + : ref_count(1 ), size (dsize), - data (0), - destruct (true) + data (0 ), + destruct (true ) { create_data(); } control_block(const std::size_t& dsize, data_t dptr, bool dstrct = false) - : ref_count(1), - size (dsize), - data (dptr ), + : ref_count(1 ), + size (dsize ), + data (dptr ), destruct (dstrct) {} @@ -4757,8 +4847,8 @@ static inline std::size_t min_size(control_block* cb0, control_block* cb1) { - std::size_t size0 = cb0->size; - std::size_t size1 = cb1->size; + const std::size_t size0 = cb0->size; + const std::size_t size1 = cb1->size; if (size0 && size1) return std::min(size0,size1); @@ -4845,19 +4935,19 @@ case e_ne : return std::not_equal_to<T>()(arg0,arg1) ? T(1) : T(0); case e_gte : return (arg0 >= arg1) ? T(1) : T(0); case e_gt : return (arg0 > arg1) ? T(1) : T(0); - case e_and : return and_opr<T> (arg0,arg1); + case e_and : return and_opr <T>(arg0,arg1); case e_nand : return nand_opr<T>(arg0,arg1); - case e_or : return or_opr<T> (arg0,arg1); - case e_nor : return nor_opr<T> (arg0,arg1); - case e_xor : return xor_opr<T> (arg0,arg1); + case e_or : return or_opr <T>(arg0,arg1); + case e_nor : return nor_opr <T>(arg0,arg1); + case e_xor : return xor_opr <T>(arg0,arg1); case e_xnor : return xnor_opr<T>(arg0,arg1); - case e_root : return root<T> (arg0,arg1); - case e_roundn : return roundn<T> (arg0,arg1); + case e_root : return root <T>(arg0,arg1); + case e_roundn : return roundn <T>(arg0,arg1); case e_equal : return equal (arg0,arg1); case e_nequal : return nequal (arg0,arg1); - case e_hypot : return hypot<T> (arg0,arg1); - case e_shr : return shr<T> (arg0,arg1); - case e_shl : return shl<T> (arg0,arg1); + case e_hypot : return hypot <T>(arg0,arg1); + case e_shr : return shr <T>(arg0,arg1); + case e_shl : return shl <T>(arg0,arg1); default : exprtk_debug(("numeric::details::process_impl<T> - Invalid binary operation.\n")); return std::numeric_limits<T>::quiet_NaN(); @@ -4912,7 +5002,7 @@ template <typename T> inline T process(const operator_type operation, const T arg0, const T arg1) { - return exprtk::details::numeric::details::process_impl(operation,arg0,arg1); + return exprtk::details::numeric::details::process_impl(operation, arg0, arg1); } } @@ -4923,42 +5013,42 @@ enum node_type { - e_none , e_null , e_constant , e_unary , - e_binary , e_binary_ext , e_trinary , e_quaternary , - e_vararg , e_conditional , e_while , e_repeat , - e_for , e_switch , e_mswitch , e_return , - e_retenv , e_variable , e_stringvar , e_stringconst , - e_stringvarrng , e_cstringvarrng, e_strgenrange , e_strconcat , - e_stringvarsize, e_strswap , e_stringsize , e_stringvararg , - e_function , e_vafunction , e_genfunction , e_strfunction , - e_strcondition , e_strccondition, e_add , e_sub , - e_mul , e_div , e_mod , e_pow , - e_lt , e_lte , e_gt , e_gte , - e_eq , e_ne , e_and , e_nand , - e_or , e_nor , e_xor , e_xnor , - e_in , e_like , e_ilike , e_inranges , - e_ipow , e_ipowinv , e_abs , e_acos , - e_acosh , e_asin , e_asinh , e_atan , - e_atanh , e_ceil , e_cos , e_cosh , - e_exp , e_expm1 , e_floor , e_log , - e_log10 , e_log2 , e_log1p , e_neg , - e_pos , e_round , e_sin , e_sinc , - e_sinh , e_sqrt , e_tan , e_tanh , - e_cot , e_sec , e_csc , e_r2d , - e_d2r , e_d2g , e_g2d , e_notl , - e_sgn , e_erf , e_erfc , e_ncdf , - e_frac , e_trunc , e_uvouv , e_vov , - e_cov , e_voc , e_vob , e_bov , - e_cob , e_boc , e_vovov , e_vovoc , - e_vocov , e_covov , e_covoc , e_vovovov , - e_vovovoc , e_vovocov , e_vocovov , e_covovov , - e_covocov , e_vocovoc , e_covovoc , e_vococov , - e_sf3ext , e_sf4ext , e_nulleq , e_strass , - e_vector , e_vecelem , e_rbvecelem , e_rbveccelem , - e_vecdefass , e_vecvalass , e_vecvecass , e_vecopvalass , - e_vecopvecass , e_vecfunc , e_vecvecswap , e_vecvecineq , - e_vecvalineq , e_valvecineq , e_vecvecarith , e_vecvalarith , - e_valvecarith , e_vecunaryop , e_break , e_continue , + e_none , e_null , e_constant , e_unary , + e_binary , e_binary_ext , e_trinary , e_quaternary , + e_vararg , e_conditional , e_while , e_repeat , + e_for , e_switch , e_mswitch , e_return , + e_retenv , e_variable , e_stringvar , e_stringconst , + e_stringvarrng , e_cstringvarrng , e_strgenrange , e_strconcat , + e_stringvarsize , e_strswap , e_stringsize , e_stringvararg , + e_function , e_vafunction , e_genfunction , e_strfunction , + e_strcondition , e_strccondition , e_add , e_sub , + e_mul , e_div , e_mod , e_pow , + e_lt , e_lte , e_gt , e_gte , + e_eq , e_ne , e_and , e_nand , + e_or , e_nor , e_xor , e_xnor , + e_in , e_like , e_ilike , e_inranges , + e_ipow , e_ipowinv , e_abs , e_acos , + e_acosh , e_asin , e_asinh , e_atan , + e_atanh , e_ceil , e_cos , e_cosh , + e_exp , e_expm1 , e_floor , e_log , + e_log10 , e_log2 , e_log1p , e_neg , + e_pos , e_round , e_sin , e_sinc , + e_sinh , e_sqrt , e_tan , e_tanh , + e_cot , e_sec , e_csc , e_r2d , + e_d2r , e_d2g , e_g2d , e_notl , + e_sgn , e_erf , e_erfc , e_ncdf , + e_frac , e_trunc , e_uvouv , e_vov , + e_cov , e_voc , e_vob , e_bov , + e_cob , e_boc , e_vovov , e_vovoc , + e_vocov , e_covov , e_covoc , e_vovovov , + e_vovovoc , e_vovocov , e_vocovov , e_covovov , + e_covocov , e_vocovoc , e_covovoc , e_vococov , + e_sf3ext , e_sf4ext , e_nulleq , e_strass , + e_vector , e_vecelem , e_rbvecelem , e_rbveccelem , + e_vecdefass , e_vecvalass , e_vecvecass , e_vecopvalass , + e_vecopvecass , e_vecfunc , e_vecvecswap , e_vecvecineq , + e_vecvalineq , e_valvecineq , e_vecvecarith , e_vecvalarith , + e_valvecarith , e_vecunaryop , e_break , e_continue , e_swap }; @@ -5179,7 +5269,7 @@ template <typename T, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline bool all_nodes_valid(const Sequence<expression_node<T>*,Allocator>& b) { for (std::size_t i = 0; i < b.size(); ++i) @@ -5206,7 +5296,7 @@ template <typename T, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline bool all_nodes_variables(Sequence<expression_node<T>*,Allocator>& b) { for (std::size_t i = 0; i < b.size(); ++i) @@ -5232,7 +5322,7 @@ template <typename NodeAllocator, typename T, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline void free_all_nodes(NodeAllocator& node_allocator, Sequence<expression_node<T>*,Allocator>& b) { for (std::size_t i = 0; i < b.size(); ++i) @@ -5342,7 +5432,7 @@ }; template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> class sequence_vector_impl : public vector_holder_base { public: @@ -5790,7 +5880,7 @@ template <typename T, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> static inline void execute(Sequence<std::pair<expression_node<T>*,bool>,Allocator>& branch) { for (std::size_t i = 0; i < branch.size(); ++i) @@ -6618,8 +6708,8 @@ typedef expression_node<T>* expression_ptr; template <typename Allocator, - template <typename,typename> class Sequence> - switch_node(const Sequence<expression_ptr,Allocator>& arg_list) + template <typename, typename> class Sequence> + explicit switch_node(const Sequence<expression_ptr,Allocator>& arg_list) { if (1 != (arg_list.size() & 1)) return; @@ -6696,8 +6786,8 @@ typedef expression_node<T>* expression_ptr; template <typename Allocator, - template <typename,typename> class Sequence> - switch_n_node(const Sequence<expression_ptr,Allocator>& arg_list) + template <typename, typename> class Sequence> + explicit switch_n_node(const Sequence<expression_ptr,Allocator>& arg_list) : switch_node<T>(arg_list) {} @@ -6715,8 +6805,8 @@ typedef expression_node<T>* expression_ptr; template <typename Allocator, - template <typename,typename> class Sequence> - multi_switch_node(const Sequence<expression_ptr,Allocator>& arg_list) + template <typename, typename> class Sequence> + explicit multi_switch_node(const Sequence<expression_ptr,Allocator>& arg_list) { if (0 != (arg_list.size() & 1)) return; @@ -6811,7 +6901,7 @@ : value_(&null_value) {} - variable_node(T& v) + explicit variable_node(T& v) : value_(&v) {} @@ -6912,13 +7002,14 @@ (!n0_c.first && !n1_c.first); } - bool operator() (std::size_t& r0, std::size_t& r1, const std::size_t& size = std::numeric_limits<std::size_t>::max()) const + bool operator() (std::size_t& r0, std::size_t& r1, + const std::size_t& size = std::numeric_limits<std::size_t>::max()) const { if (n0_c.first) r0 = n0_c.second; else if (n0_e.first) { - T r0_value = n0_e.second->value(); + const T r0_value = n0_e.second->value(); if (r0_value < 0) return false; @@ -6932,7 +7023,7 @@ r1 = n1_c.second; else if (n1_e.first) { - T r1_value = n1_e.second->value(); + const T r1_value = n1_e.second->value(); if (r1_value < 0) return false; @@ -7034,7 +7125,7 @@ typedef vector_node<T>* vector_node_ptr; typedef vec_data_store<T> vds_t; - vector_node(vector_holder_t* vh) + explicit vector_node(vector_holder_t* vh) : vector_holder_(vh), vds_((*vector_holder_).size(),(*vector_holder_)[0]) { @@ -7814,8 +7905,8 @@ const std::size_t base_str_size = str_base_ptr_->size(); if ( - range (str_r0,str_r1,base_str_size) && - base_range_( r0, r1,base_str_size) + range (str_r0, str_r1, base_str_size) && + base_range_( r0, r1, base_str_size) ) { const std::size_t size = (r1 - r0) + 1; @@ -7951,8 +8042,8 @@ range_t& range1 = str1_range_ptr_->range_ref(); if ( - range0(str0_r0,str0_r1,str0_base_ptr_->size()) && - range1(str1_r0,str1_r1,str1_base_ptr_->size()) + range0(str0_r0, str0_r1, str0_base_ptr_->size()) && + range1(str1_r0, str1_r1, str1_base_ptr_->size()) ) { const std::size_t size0 = (str0_r1 - str0_r0) + 1; @@ -8051,7 +8142,7 @@ binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - std::swap(str0_node_ptr_->ref(),str1_node_ptr_->ref()); + std::swap(str0_node_ptr_->ref(), str1_node_ptr_->ref()); } return std::numeric_limits<T>::quiet_NaN(); @@ -8122,12 +8213,12 @@ if (0 == str0_base_ptr_) return; - irange_ptr range_ptr = dynamic_cast<irange_ptr>(binary_node<T>::branch_[0].first); + irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[0].first); - if (0 == range_ptr) + if (0 == range) return; - str0_range_ptr_ = &(range_ptr->range_ref()); + str0_range_ptr_ = &(range->range_ref()); } if (is_generally_string_node(binary_node<T>::branch_[1].first)) @@ -8137,12 +8228,12 @@ if (0 == str1_base_ptr_) return; - irange_ptr range_ptr = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first); + irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first); - if (0 == range_ptr) + if (0 == range) return; - str1_range_ptr_ = &(range_ptr->range_ref()); + str1_range_ptr_ = &(range->range_ref()); } initialised_ = str0_base_ptr_ && @@ -8168,8 +8259,8 @@ range_t& range1 = (*str1_range_ptr_); if ( - range0(str0_r0,str0_r1,str0_base_ptr_->size()) && - range1(str1_r0,str1_r1,str1_base_ptr_->size()) + range0(str0_r0, str0_r1, str0_base_ptr_->size()) && + range1(str1_r0, str1_r1, str1_base_ptr_->size()) ) { const std::size_t size0 = range0.cache_size(); @@ -8207,8 +8298,8 @@ exprtk_disable_fallthrough_begin switch (lud.remainder) { - #define case_stmt(N) \ - case N : { std::swap(s0[i],s1[i]); ++i; } \ + #define case_stmt(N) \ + case N : { std::swap(s0[i], s1[i]); ++i; } \ #ifndef exprtk_disable_superscalar_unroll case_stmt(15) case_stmt(14) @@ -8289,7 +8380,7 @@ typedef expression_node <T>* expression_ptr; typedef string_base_node<T>* str_base_ptr; - string_size_node(expression_ptr brnch) + explicit string_size_node(expression_ptr brnch) : branch_(brnch), branch_deletable_(branch_deletable(branch_)), str_base_ptr_(0) @@ -8387,12 +8478,12 @@ if (0 == str1_base_ptr_) return; - irange_ptr range_ptr = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first); + irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first); - if (0 == range_ptr) + if (0 == range) return; - str1_range_ptr_ = &(range_ptr->range_ref()); + str1_range_ptr_ = &(range->range_ref()); } initialised_ = str0_base_ptr_ && @@ -8496,12 +8587,12 @@ str0_base_ptr_ = dynamic_cast<str_base_ptr>(binary_node<T>::branch_[0].first); - irange_ptr range_ptr = dynamic_cast<irange_ptr>(binary_node<T>::branch_[0].first); + irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[0].first); - if (0 == range_ptr) + if (0 == range) return; - str0_range_ptr_ = &(range_ptr->range_ref()); + str0_range_ptr_ = &(range->range_ref()); } if (is_generally_string_node(binary_node<T>::branch_[1].first)) @@ -8511,12 +8602,12 @@ if (0 == str1_base_ptr_) return; - irange_ptr range_ptr = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first); + irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first); - if (0 == range_ptr) + if (0 == range) return; - str1_range_ptr_ = &(range_ptr->range_ref()); + str1_range_ptr_ = &(range->range_ref()); } initialised_ = str0_base_ptr_ && @@ -8547,7 +8638,7 @@ range1(s1_r0, s1_r1, str1_base_ptr_->size()) ) { - std::size_t size = std::min((s0_r1 - s0_r0),(s1_r1 - s1_r0)) + 1; + std::size_t size = std::min((s0_r1 - s0_r0), (s1_r1 - s1_r0)) + 1; std::copy(str1_base_ptr_->base() + s1_r0, str1_base_ptr_->base() + s1_r0 + size, @@ -8677,7 +8768,7 @@ range_t& range = str0_range_ptr_->range_ref(); - if (range(r0,r1,str0_base_ptr_->size())) + if (range(r0, r1, str0_base_ptr_->size())) { const std::size_t size = (r1 - r0) + 1; @@ -8695,7 +8786,7 @@ range_t& range = str1_range_ptr_->range_ref(); - if (range(r0,r1,str1_base_ptr_->size())) + if (range(r0, r1, str1_base_ptr_->size())) { const std::size_t size = (r1 - r0) + 1; @@ -8815,7 +8906,7 @@ std::size_t r0 = 0; std::size_t r1 = 0; - if (range(r0,r1,str0_base_ptr_->size())) + if (range(r0, r1, str0_base_ptr_->size())) { const std::size_t size = (r1 - r0) + 1; @@ -8889,8 +8980,8 @@ typedef irange_t* irange_ptr; template <typename Allocator, - template <typename,typename> class Sequence> - str_vararg_node(const Sequence<expression_ptr,Allocator>& arg_list) + template <typename, typename> class Sequence> + explicit str_vararg_node(const Sequence<expression_ptr,Allocator>& arg_list) : final_node_(arg_list.back()), final_deletable_(branch_deletable(final_node_)), initialised_(false), @@ -9037,7 +9128,7 @@ template <typename T> \ struct sf##NN##_op : public sf_base<T> \ { \ - typedef typename sf_base<T>::Type Type; \ + typedef typename sf_base<T>::Type const Type; \ static inline T process(Type x, Type y, Type z) \ { \ return (OP0); \ @@ -9101,7 +9192,7 @@ template <typename T> \ struct sf##NN##_op : public sf_base<T> \ { \ - typedef typename sf_base<T>::Type Type; \ + typedef typename sf_base<T>::Type const Type; \ static inline T process(Type x, Type y, Type z, Type w) \ { \ return (OP0); \ @@ -9355,8 +9446,8 @@ typedef expression_node<T>* expression_ptr; template <typename Allocator, - template <typename,typename> class Sequence> - vararg_node(const Sequence<expression_ptr,Allocator>& arg_list) + template <typename, typename> class Sequence> + explicit vararg_node(const Sequence<expression_ptr,Allocator>& arg_list) { arg_list_ .resize(arg_list.size()); delete_branch_.resize(arg_list.size()); @@ -9390,10 +9481,7 @@ inline T value() const { - if (!arg_list_.empty()) - return VarArgFunction::process(arg_list_); - else - return std::numeric_limits<T>::quiet_NaN(); + return VarArgFunction::process(arg_list_); } inline typename expression_node<T>::node_type type() const @@ -9415,8 +9503,8 @@ typedef expression_node<T>* expression_ptr; template <typename Allocator, - template <typename,typename> class Sequence> - vararg_varnode(const Sequence<expression_ptr,Allocator>& arg_list) + template <typename, typename> class Sequence> + explicit vararg_varnode(const Sequence<expression_ptr,Allocator>& arg_list) { arg_list_.resize(arg_list.size()); @@ -9460,7 +9548,7 @@ typedef expression_node<T>* expression_ptr; - vectorize_node(const expression_ptr v) + explicit vectorize_node(const expression_ptr v) : ivec_ptr_(0), v_(v), v_deletable_(branch_deletable(v_)) @@ -9692,8 +9780,8 @@ while (vec < upper_bound) { - #define exprtk_loop(N) \ - vec[N] = v; \ + #define exprtk_loop(N) \ + vec[N] = v; \ exprtk_loop( 0) exprtk_loop( 1) exprtk_loop( 2) exprtk_loop( 3) @@ -10249,16 +10337,16 @@ binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - T* vec0 = vec0_node_ptr_->vds().data(); - T* vec1 = vec1_node_ptr_->vds().data(); + T* vec0 = vec0_node_ptr_->vds().data(); + const T* vec1 = vec1_node_ptr_->vds().data(); loop_unroll::details lud(size()); const T* upper_bound = vec0 + lud.upper_bound; while (vec0 < upper_bound) { - #define exprtk_loop(N) \ - vec0[N] = Operation::process(vec0[N],vec1[N]); \ + #define exprtk_loop(N) \ + vec0[N] = Operation::process(vec0[N], vec1[N]); \ exprtk_loop( 0) exprtk_loop( 1) exprtk_loop( 2) exprtk_loop( 3) @@ -10280,8 +10368,8 @@ exprtk_disable_fallthrough_begin switch (lud.remainder) { - #define case_stmt(N) \ - case N : { vec0[i] = Operation::process(vec0[i],vec1[i]); ++i; } \ + #define case_stmt(N) \ + case N : { vec0[i] = Operation::process(vec0[i], vec1[i]); ++i; } \ #ifndef exprtk_disable_superscalar_unroll case_stmt(15) case_stmt(14) @@ -10434,17 +10522,17 @@ binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - T* vec0 = vec0_node_ptr_->vds().data(); - T* vec1 = vec1_node_ptr_->vds().data(); - T* vec2 = vds().data(); + const T* vec0 = vec0_node_ptr_->vds().data(); + const T* vec1 = vec1_node_ptr_->vds().data(); + T* vec2 = vds().data(); loop_unroll::details lud(size()); const T* upper_bound = vec2 + lud.upper_bound; while (vec2 < upper_bound) { - #define exprtk_loop(N) \ - vec2[N] = Operation::process(vec0[N],vec1[N]); \ + #define exprtk_loop(N) \ + vec2[N] = Operation::process(vec0[N], vec1[N]); \ exprtk_loop( 0) exprtk_loop( 1) exprtk_loop( 2) exprtk_loop( 3) @@ -10467,8 +10555,8 @@ exprtk_disable_fallthrough_begin switch (lud.remainder) { - #define case_stmt(N) \ - case N : { vec2[i] = Operation::process(vec0[i],vec1[i]); ++i; } \ + #define case_stmt(N) \ + case N : { vec2[i] = Operation::process(vec0[i], vec1[i]); ++i; } \ #ifndef exprtk_disable_superscalar_unroll case_stmt(15) case_stmt(14) @@ -10593,16 +10681,16 @@ binary_node<T>::branch_[0].first->value(); const T v = binary_node<T>::branch_[1].first->value(); - T* vec0 = vec0_node_ptr_->vds().data(); - T* vec1 = vds().data(); + const T* vec0 = vec0_node_ptr_->vds().data(); + T* vec1 = vds().data(); loop_unroll::details lud(size()); const T* upper_bound = vec0 + lud.upper_bound; while (vec0 < upper_bound) { - #define exprtk_loop(N) \ - vec1[N] = Operation::process(vec0[N],v); \ + #define exprtk_loop(N) \ + vec1[N] = Operation::process(vec0[N], v); \ exprtk_loop( 0) exprtk_loop( 1) exprtk_loop( 2) exprtk_loop( 3) @@ -10624,8 +10712,8 @@ exprtk_disable_fallthrough_begin switch (lud.remainder) { - #define case_stmt(N) \ - case N : { vec1[i] = Operation::process(vec0[i],v); ++i; } \ + #define case_stmt(N) \ + case N : { vec1[i] = Operation::process(vec0[i], v); ++i; } \ #ifndef exprtk_disable_superscalar_unroll case_stmt(15) case_stmt(14) @@ -10748,16 +10836,16 @@ const T v = binary_node<T>::branch_[0].first->value(); binary_node<T>::branch_[1].first->value(); - T* vec0 = vds().data(); - T* vec1 = vec1_node_ptr_->vds().data(); + T* vec0 = vds().data(); + const T* vec1 = vec1_node_ptr_->vds().data(); loop_unroll::details lud(size()); const T* upper_bound = vec0 + lud.upper_bound; while (vec0 < upper_bound) { - #define exprtk_loop(N) \ - vec0[N] = Operation::process(v,vec1[N]); \ + #define exprtk_loop(N) \ + vec0[N] = Operation::process(v, vec1[N]); \ exprtk_loop( 0) exprtk_loop( 1) exprtk_loop( 2) exprtk_loop( 3) @@ -10779,8 +10867,8 @@ exprtk_disable_fallthrough_begin switch (lud.remainder) { - #define case_stmt(N) \ - case N : { vec0[i] = Operation::process(v,vec1[i]); ++i; } \ + #define case_stmt(N) \ + case N : { vec0[i] = Operation::process(v, vec1[i]); ++i; } \ #ifndef exprtk_disable_superscalar_unroll case_stmt(15) case_stmt(14) @@ -10900,8 +10988,8 @@ if (vec0_node_ptr_) { - T* vec0 = vec0_node_ptr_->vds().data(); - T* vec1 = vds().data(); + const T* vec0 = vec0_node_ptr_->vds().data(); + T* vec1 = vds().data(); loop_unroll::details lud(size()); const T* upper_bound = vec0 + lud.upper_bound; @@ -11052,7 +11140,7 @@ typedef std::pair<expression_ptr,bool> branch_t; typedef IFunction ifunction; - function_N_node(ifunction* func) + explicit function_N_node(ifunction* func) : function_((N == func->param_count) ? func : reinterpret_cast<ifunction*>(0)), parameter_count_(func->param_count) {} @@ -11343,7 +11431,7 @@ typedef expression_node<T>* expression_ptr; typedef IFunction ifunction; - function_N_node(ifunction* func) + explicit function_N_node(ifunction* func) : function_((0 == func->param_count) ? func : reinterpret_cast<ifunction*>(0)) {} @@ -11486,6 +11574,7 @@ ts.size = vi->size(); ts.data = vi->vds().data(); ts.type = type_store_t::e_vector; + vi->vec()->vec_holder().set_ref(&ts.vec_data); } #ifndef exprtk_disable_string_capabilities else if (is_generally_string_node(arg_list_[i])) @@ -11651,16 +11740,17 @@ inline T value() const { - T result = std::numeric_limits<T>::quiet_NaN(); - if (gen_function_t::function_) { if (gen_function_t::populate_value_list()) { typedef typename StringFunction::parameter_list_t parameter_list_t; - result = (*gen_function_t::function_)(ret_string_, - parameter_list_t(gen_function_t::typestore_list_)); + const T result = (*gen_function_t::function_) + ( + ret_string_, + parameter_list_t(gen_function_t::typestore_list_) + ); range_.n1_c.second = ret_string_.size() - 1; range_.cache.second = range_.n1_c.second; @@ -11669,7 +11759,7 @@ } } - return result; + return std::numeric_limits<T>::quiet_NaN(); } inline typename expression_node<T>::node_type type() const @@ -11726,20 +11816,21 @@ inline T value() const { - T result = std::numeric_limits<T>::quiet_NaN(); - if (gen_function_t::function_) { if (gen_function_t::populate_value_list()) { typedef typename GenericFunction::parameter_list_t parameter_list_t; - return (*gen_function_t::function_)(param_seq_index_, - parameter_list_t(gen_function_t::typestore_list_)); + return (*gen_function_t::function_) + ( + param_seq_index_, + parameter_list_t(gen_function_t::typestore_list_) + ); } } - return result; + return std::numeric_limits<T>::quiet_NaN(); } inline typename expression_node<T>::node_type type() const @@ -11770,17 +11861,18 @@ inline T value() const { - T result = std::numeric_limits<T>::quiet_NaN(); - if (str_function_t::function_) { if (str_function_t::populate_value_list()) { typedef typename StringFunction::parameter_list_t parameter_list_t; - result = (*str_function_t::function_)(param_seq_index_, - str_function_t::ret_string_, - parameter_list_t(str_function_t::typestore_list_)); + const T result = (*str_function_t::function_) + ( + param_seq_index_, + str_function_t::ret_string_, + parameter_list_t(str_function_t::typestore_list_) + ); str_function_t::range_.n1_c.second = str_function_t::ret_string_.size() - 1; str_function_t::range_.cache.second = str_function_t::range_.n1_c.second; @@ -11789,7 +11881,7 @@ } } - return result; + return std::numeric_limits<T>::quiet_NaN(); } inline typename expression_node<T>::node_type type() const @@ -11994,20 +12086,21 @@ template <typename T> struct opr_base { - typedef typename details::functor_t<T>::Type Type; + typedef typename details::functor_t<T>::Type Type; typedef typename details::functor_t<T>::RefType RefType; - typedef typename details::functor_t<T> functor_t; - typedef typename functor_t::qfunc_t quaternary_functor_t; - typedef typename functor_t::tfunc_t trinary_functor_t; - typedef typename functor_t::bfunc_t binary_functor_t; - typedef typename functor_t::ufunc_t unary_functor_t; + typedef typename details::functor_t<T> functor_t; + typedef typename functor_t::qfunc_t quaternary_functor_t; + typedef typename functor_t::tfunc_t trinary_functor_t; + typedef typename functor_t::bfunc_t binary_functor_t; + typedef typename functor_t::ufunc_t unary_functor_t; }; template <typename T> struct add_op : public opr_base<T> { - typedef typename opr_base<T>::Type Type; + typedef typename opr_base<T>::Type Type; typedef typename opr_base<T>::RefType RefType; + static inline T process(Type t1, Type t2) { return t1 + t2; } static inline T process(Type t1, Type t2, Type t3) { return t1 + t2 + t3; } static inline void assign(RefType t1, Type t2) { t1 += t2; } @@ -12018,8 +12111,9 @@ template <typename T> struct mul_op : public opr_base<T> { - typedef typename opr_base<T>::Type Type; + typedef typename opr_base<T>::Type Type; typedef typename opr_base<T>::RefType RefType; + static inline T process(Type t1, Type t2) { return t1 * t2; } static inline T process(Type t1, Type t2, Type t3) { return t1 * t2 * t3; } static inline void assign(RefType t1, Type t2) { t1 *= t2; } @@ -12030,8 +12124,9 @@ template <typename T> struct sub_op : public opr_base<T> { - typedef typename opr_base<T>::Type Type; + typedef typename opr_base<T>::Type Type; typedef typename opr_base<T>::RefType RefType; + static inline T process(Type t1, Type t2) { return t1 - t2; } static inline T process(Type t1, Type t2, Type t3) { return t1 - t2 - t3; } static inline void assign(RefType t1, Type t2) { t1 -= t2; } @@ -12042,8 +12137,9 @@ template <typename T> struct div_op : public opr_base<T> { - typedef typename opr_base<T>::Type Type; + typedef typename opr_base<T>::Type Type; typedef typename opr_base<T>::RefType RefType; + static inline T process(Type t1, Type t2) { return t1 / t2; } static inline T process(Type t1, Type t2, Type t3) { return t1 / t2 / t3; } static inline void assign(RefType t1, Type t2) { t1 /= t2; } @@ -12054,8 +12150,9 @@ template <typename T> struct mod_op : public opr_base<T> { - typedef typename opr_base<T>::Type Type; + typedef typename opr_base<T>::Type Type; typedef typename opr_base<T>::RefType RefType; + static inline T process(Type t1, Type t2) { return numeric::modulus<T>(t1,t2); } static inline void assign(RefType t1, Type t2) { t1 = numeric::modulus<T>(t1,t2); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_mod; } @@ -12065,8 +12162,9 @@ template <typename T> struct pow_op : public opr_base<T> { - typedef typename opr_base<T>::Type Type; + typedef typename opr_base<T>::Type Type; typedef typename opr_base<T>::RefType RefType; + static inline T process(Type t1, Type t2) { return numeric::pow<T>(t1,t2); } static inline void assign(RefType t1, Type t2) { t1 = numeric::pow<T>(t1,t2); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_pow; } @@ -12077,6 +12175,7 @@ struct lt_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return ((t1 < t2) ? T(1) : T(0)); } static inline T process(const std::string& t1, const std::string& t2) { return ((t1 < t2) ? T(1) : T(0)); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_lt; } @@ -12087,6 +12186,7 @@ struct lte_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return ((t1 <= t2) ? T(1) : T(0)); } static inline T process(const std::string& t1, const std::string& t2) { return ((t1 <= t2) ? T(1) : T(0)); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_lte; } @@ -12097,6 +12197,7 @@ struct gt_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return ((t1 > t2) ? T(1) : T(0)); } static inline T process(const std::string& t1, const std::string& t2) { return ((t1 > t2) ? T(1) : T(0)); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_gt; } @@ -12107,6 +12208,7 @@ struct gte_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return ((t1 >= t2) ? T(1) : T(0)); } static inline T process(const std::string& t1, const std::string& t2) { return ((t1 >= t2) ? T(1) : T(0)); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_gte; } @@ -12127,6 +12229,7 @@ struct equal_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return numeric::equal(t1,t2); } static inline T process(const std::string& t1, const std::string& t2) { return ((t1 == t2) ? T(1) : T(0)); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_eq; } @@ -12137,6 +12240,7 @@ struct ne_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return (std::not_equal_to<T>()(t1,t2) ? T(1) : T(0)); } static inline T process(const std::string& t1, const std::string& t2) { return ((t1 != t2) ? T(1) : T(0)); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_ne; } @@ -12147,6 +12251,7 @@ struct and_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return (details::is_true(t1) && details::is_true(t2)) ? T(1) : T(0); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_and; } static inline details::operator_type operation() { return details::e_and; } @@ -12156,6 +12261,7 @@ struct nand_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return (details::is_true(t1) && details::is_true(t2)) ? T(0) : T(1); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_nand; } static inline details::operator_type operation() { return details::e_nand; } @@ -12165,6 +12271,7 @@ struct or_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return (details::is_true(t1) || details::is_true(t2)) ? T(1) : T(0); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_or; } static inline details::operator_type operation() { return details::e_or; } @@ -12174,6 +12281,7 @@ struct nor_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return (details::is_true(t1) || details::is_true(t2)) ? T(0) : T(1); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_nor; } static inline details::operator_type operation() { return details::e_nor; } @@ -12183,6 +12291,7 @@ struct xor_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return numeric::xor_opr<T>(t1,t2); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_nor; } static inline details::operator_type operation() { return details::e_xor; } @@ -12192,6 +12301,7 @@ struct xnor_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(Type t1, Type t2) { return numeric::xnor_opr<T>(t1,t2); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_nor; } static inline details::operator_type operation() { return details::e_xnor; } @@ -12201,6 +12311,7 @@ struct in_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(const T&, const T&) { return std::numeric_limits<T>::quiet_NaN(); } static inline T process(const std::string& t1, const std::string& t2) { return ((std::string::npos != t2.find(t1)) ? T(1) : T(0)); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_in; } @@ -12211,6 +12322,7 @@ struct like_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(const T&, const T&) { return std::numeric_limits<T>::quiet_NaN(); } static inline T process(const std::string& t1, const std::string& t2) { return (details::wc_match(t2,t1) ? T(1) : T(0)); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_like; } @@ -12221,6 +12333,7 @@ struct ilike_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(const T&, const T&) { return std::numeric_limits<T>::quiet_NaN(); } static inline T process(const std::string& t1, const std::string& t2) { return (details::wc_imatch(t2,t1) ? T(1) : T(0)); } static inline typename expression_node<T>::node_type type() { return expression_node<T>::e_ilike; } @@ -12231,6 +12344,7 @@ struct inrange_op : public opr_base<T> { typedef typename opr_base<T>::Type Type; + static inline T process(const T& t0, const T& t1, const T& t2) { return ((t0 <= t1) && (t1 <= t2)) ? T(1) : T(0); } static inline T process(const std::string& t0, const std::string& t1, const std::string& t2) { @@ -12259,7 +12373,7 @@ template <typename Type, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> static inline T process(const Sequence<Type,Allocator>& arg_list) { switch (arg_list.size()) @@ -12300,14 +12414,14 @@ static inline T process_3(const Sequence& arg_list) { return value(arg_list[0]) + value(arg_list[1]) + - value(arg_list[2]); + value(arg_list[2]) ; } template <typename Sequence> static inline T process_4(const Sequence& arg_list) { return value(arg_list[0]) + value(arg_list[1]) + - value(arg_list[2]) + value(arg_list[3]); + value(arg_list[2]) + value(arg_list[3]) ; } template <typename Sequence> @@ -12315,7 +12429,7 @@ { return value(arg_list[0]) + value(arg_list[1]) + value(arg_list[2]) + value(arg_list[3]) + - value(arg_list[4]); + value(arg_list[4]) ; } }; @@ -12326,7 +12440,7 @@ template <typename Type, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> static inline T process(const Sequence<Type,Allocator>& arg_list) { switch (arg_list.size()) @@ -12367,14 +12481,14 @@ static inline T process_3(const Sequence& arg_list) { return value(arg_list[0]) * value(arg_list[1]) * - value(arg_list[2]); + value(arg_list[2]) ; } template <typename Sequence> static inline T process_4(const Sequence& arg_list) { return value(arg_list[0]) * value(arg_list[1]) * - value(arg_list[2]) * value(arg_list[3]); + value(arg_list[2]) * value(arg_list[3]) ; } template <typename Sequence> @@ -12382,7 +12496,7 @@ { return value(arg_list[0]) * value(arg_list[1]) * value(arg_list[2]) * value(arg_list[3]) * - value(arg_list[4]); + value(arg_list[4]) ; } }; @@ -12393,7 +12507,7 @@ template <typename Type, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> static inline T process(const Sequence<Type,Allocator>& arg_list) { switch (arg_list.size()) @@ -12449,7 +12563,7 @@ template <typename Type, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> static inline T process(const Sequence<Type,Allocator>& arg_list) { switch (arg_list.size()) @@ -12499,16 +12613,16 @@ static inline T process_4(const Sequence& arg_list) { return std::min<T>( - std::min<T>(value(arg_list[0]),value(arg_list[1])), - std::min<T>(value(arg_list[2]),value(arg_list[3]))); + std::min<T>(value(arg_list[0]), value(arg_list[1])), + std::min<T>(value(arg_list[2]), value(arg_list[3]))); } template <typename Sequence> static inline T process_5(const Sequence& arg_list) { return std::min<T>( - std::min<T>(std::min<T>(value(arg_list[0]),value(arg_list[1])), - std::min<T>(value(arg_list[2]),value(arg_list[3]))), + std::min<T>(std::min<T>(value(arg_list[0]), value(arg_list[1])), + std::min<T>(value(arg_list[2]), value(arg_list[3]))), value(arg_list[4])); } }; @@ -12520,7 +12634,7 @@ template <typename Type, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> static inline T process(const Sequence<Type,Allocator>& arg_list) { switch (arg_list.size()) @@ -12570,16 +12684,16 @@ static inline T process_4(const Sequence& arg_list) { return std::max<T>( - std::max<T>(value(arg_list[0]),value(arg_list[1])), - std::max<T>(value(arg_list[2]),value(arg_list[3]))); + std::max<T>(value(arg_list[0]), value(arg_list[1])), + std::max<T>(value(arg_list[2]), value(arg_list[3]))); } template <typename Sequence> static inline T process_5(const Sequence& arg_list) { return std::max<T>( - std::max<T>(std::max<T>(value(arg_list[0]),value(arg_list[1])), - std::max<T>(value(arg_list[2]),value(arg_list[3]))), + std::max<T>(std::max<T>(value(arg_list[0]), value(arg_list[1])), + std::max<T>(value(arg_list[2]), value(arg_list[3]))), value(arg_list[4])); } }; @@ -12591,7 +12705,7 @@ template <typename Type, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> static inline T process(const Sequence<Type,Allocator>& arg_list) { switch (arg_list.size()) @@ -12605,7 +12719,7 @@ { for (std::size_t i = 0; i < arg_list.size(); ++i) { - if (std::equal_to<T>()(T(0),value(arg_list[i]))) + if (std::equal_to<T>()(T(0), value(arg_list[i]))) return T(0); } @@ -12618,15 +12732,15 @@ static inline T process_1(const Sequence& arg_list) { return std::not_equal_to<T>() - (T(0),value(arg_list[0])) ? T(1) : T(0); + (T(0), value(arg_list[0])) ? T(1) : T(0); } template <typename Sequence> static inline T process_2(const Sequence& arg_list) { return ( - std::not_equal_to<T>()(T(0),value(arg_list[0])) && - std::not_equal_to<T>()(T(0),value(arg_list[1])) + std::not_equal_to<T>()(T(0), value(arg_list[0])) && + std::not_equal_to<T>()(T(0), value(arg_list[1])) ) ? T(1) : T(0); } @@ -12634,9 +12748,9 @@ static inline T process_3(const Sequence& arg_list) { return ( - std::not_equal_to<T>()(T(0),value(arg_list[0])) && - std::not_equal_to<T>()(T(0),value(arg_list[1])) && - std::not_equal_to<T>()(T(0),value(arg_list[2])) + std::not_equal_to<T>()(T(0), value(arg_list[0])) && + std::not_equal_to<T>()(T(0), value(arg_list[1])) && + std::not_equal_to<T>()(T(0), value(arg_list[2])) ) ? T(1) : T(0); } @@ -12644,10 +12758,10 @@ static inline T process_4(const Sequence& arg_list) { return ( - std::not_equal_to<T>()(T(0),value(arg_list[0])) && - std::not_equal_to<T>()(T(0),value(arg_list[1])) && - std::not_equal_to<T>()(T(0),value(arg_list[2])) && - std::not_equal_to<T>()(T(0),value(arg_list[3])) + std::not_equal_to<T>()(T(0), value(arg_list[0])) && + std::not_equal_to<T>()(T(0), value(arg_list[1])) && + std::not_equal_to<T>()(T(0), value(arg_list[2])) && + std::not_equal_to<T>()(T(0), value(arg_list[3])) ) ? T(1) : T(0); } @@ -12655,11 +12769,11 @@ static inline T process_5(const Sequence& arg_list) { return ( - std::not_equal_to<T>()(T(0),value(arg_list[0])) && - std::not_equal_to<T>()(T(0),value(arg_list[1])) && - std::not_equal_to<T>()(T(0),value(arg_list[2])) && - std::not_equal_to<T>()(T(0),value(arg_list[3])) && - std::not_equal_to<T>()(T(0),value(arg_list[4])) + std::not_equal_to<T>()(T(0), value(arg_list[0])) && + std::not_equal_to<T>()(T(0), value(arg_list[1])) && + std::not_equal_to<T>()(T(0), value(arg_list[2])) && + std::not_equal_to<T>()(T(0), value(arg_list[3])) && + std::not_equal_to<T>()(T(0), value(arg_list[4])) ) ? T(1) : T(0); } }; @@ -12671,7 +12785,7 @@ template <typename Type, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> static inline T process(const Sequence<Type,Allocator>& arg_list) { switch (arg_list.size()) @@ -12685,7 +12799,7 @@ { for (std::size_t i = 0; i < arg_list.size(); ++i) { - if (std::not_equal_to<T>()(T(0),value(arg_list[i]))) + if (std::not_equal_to<T>()(T(0), value(arg_list[i]))) return T(1); } @@ -12698,15 +12812,15 @@ static inline T process_1(const Sequence& arg_list) { return std::not_equal_to<T>() - (T(0),value(arg_list[0])) ? T(1) : T(0); + (T(0), value(arg_list[0])) ? T(1) : T(0); } template <typename Sequence> static inline T process_2(const Sequence& arg_list) { return ( - std::not_equal_to<T>()(T(0),value(arg_list[0])) || - std::not_equal_to<T>()(T(0),value(arg_list[1])) + std::not_equal_to<T>()(T(0), value(arg_list[0])) || + std::not_equal_to<T>()(T(0), value(arg_list[1])) ) ? T(1) : T(0); } @@ -12714,9 +12828,9 @@ static inline T process_3(const Sequence& arg_list) { return ( - std::not_equal_to<T>()(T(0),value(arg_list[0])) || - std::not_equal_to<T>()(T(0),value(arg_list[1])) || - std::not_equal_to<T>()(T(0),value(arg_list[2])) + std::not_equal_to<T>()(T(0), value(arg_list[0])) || + std::not_equal_to<T>()(T(0), value(arg_list[1])) || + std::not_equal_to<T>()(T(0), value(arg_list[2])) ) ? T(1) : T(0); } @@ -12724,10 +12838,10 @@ static inline T process_4(const Sequence& arg_list) { return ( - std::not_equal_to<T>()(T(0),value(arg_list[0])) || - std::not_equal_to<T>()(T(0),value(arg_list[1])) || - std::not_equal_to<T>()(T(0),value(arg_list[2])) || - std::not_equal_to<T>()(T(0),value(arg_list[3])) + std::not_equal_to<T>()(T(0), value(arg_list[0])) || + std::not_equal_to<T>()(T(0), value(arg_list[1])) || + std::not_equal_to<T>()(T(0), value(arg_list[2])) || + std::not_equal_to<T>()(T(0), value(arg_list[3])) ) ? T(1) : T(0); } @@ -12735,11 +12849,11 @@ static inline T process_5(const Sequence& arg_list) { return ( - std::not_equal_to<T>()(T(0),value(arg_list[0])) || - std::not_equal_to<T>()(T(0),value(arg_list[1])) || - std::not_equal_to<T>()(T(0),value(arg_list[2])) || - std::not_equal_to<T>()(T(0),value(arg_list[3])) || - std::not_equal_to<T>()(T(0),value(arg_list[4])) + std::not_equal_to<T>()(T(0), value(arg_list[0])) || + std::not_equal_to<T>()(T(0), value(arg_list[1])) || + std::not_equal_to<T>()(T(0), value(arg_list[2])) || + std::not_equal_to<T>()(T(0), value(arg_list[3])) || + std::not_equal_to<T>()(T(0), value(arg_list[4])) ) ? T(1) : T(0); } }; @@ -12751,7 +12865,7 @@ template <typename Type, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> static inline T process(const Sequence<Type,Allocator>& arg_list) { switch (arg_list.size()) @@ -13651,15 +13765,15 @@ template <typename T, typename T0, typename T1> \ const typename expression_node<T>::node_type nodetype_T0oT1<T,T0_,T1_>::result = expression_node<T>:: v_; \ - synthesis_node_type_define(const T0&,const T1&, e_vov) - synthesis_node_type_define(const T0&,const T1 , e_voc) - synthesis_node_type_define(const T0 ,const T1&, e_cov) - synthesis_node_type_define( T0&, T1&,e_none) - synthesis_node_type_define(const T0 ,const T1 ,e_none) - synthesis_node_type_define( T0&,const T1 ,e_none) - synthesis_node_type_define(const T0 , T1&,e_none) - synthesis_node_type_define(const T0&, T1&,e_none) - synthesis_node_type_define( T0&,const T1&,e_none) + synthesis_node_type_define(const T0&, const T1&, e_vov) + synthesis_node_type_define(const T0&, const T1 , e_voc) + synthesis_node_type_define(const T0 , const T1&, e_cov) + synthesis_node_type_define( T0&, T1&, e_none) + synthesis_node_type_define(const T0 , const T1 , e_none) + synthesis_node_type_define( T0&, const T1 , e_none) + synthesis_node_type_define(const T0 , T1&, e_none) + synthesis_node_type_define(const T0&, T1&, e_none) + synthesis_node_type_define( T0&, const T1&, e_none) #undef synthesis_node_type_define template <typename T, typename T0, typename T1, typename T2> @@ -13673,15 +13787,15 @@ template <typename T, typename T0, typename T1, typename T2> \ const typename expression_node<T>::node_type nodetype_T0oT1oT2<T,T0_,T1_,T2_>::result = expression_node<T>:: v_; \ - synthesis_node_type_define(const T0&,const T1&,const T2&, e_vovov) - synthesis_node_type_define(const T0&,const T1&,const T2 , e_vovoc) - synthesis_node_type_define(const T0&,const T1 ,const T2&, e_vocov) - synthesis_node_type_define(const T0 ,const T1&,const T2&, e_covov) - synthesis_node_type_define(const T0 ,const T1&,const T2 , e_covoc) - synthesis_node_type_define(const T0 ,const T1 ,const T2 , e_none ) - synthesis_node_type_define(const T0 ,const T1 ,const T2&, e_none ) - synthesis_node_type_define(const T0&,const T1 ,const T2 , e_none ) - synthesis_node_type_define( T0&, T1&, T2&, e_none ) + synthesis_node_type_define(const T0&, const T1&, const T2&, e_vovov) + synthesis_node_type_define(const T0&, const T1&, const T2 , e_vovoc) + synthesis_node_type_define(const T0&, const T1 , const T2&, e_vocov) + synthesis_node_type_define(const T0 , const T1&, const T2&, e_covov) + synthesis_node_type_define(const T0 , const T1&, const T2 , e_covoc) + synthesis_node_type_define(const T0 , const T1 , const T2 , e_none ) + synthesis_node_type_define(const T0 , const T1 , const T2&, e_none ) + synthesis_node_type_define(const T0&, const T1 , const T2 , e_none ) + synthesis_node_type_define( T0&, T1&, T2&, e_none ) #undef synthesis_node_type_define template <typename T, typename T0, typename T1, typename T2, typename T3> @@ -13695,22 +13809,22 @@ template <typename T, typename T0, typename T1, typename T2, typename T3> \ const typename expression_node<T>::node_type nodetype_T0oT1oT2oT3<T,T0_,T1_,T2_,T3_>::result = expression_node<T>:: v_; \ - synthesis_node_type_define(const T0&,const T1&,const T2&, const T3&,e_vovovov) - synthesis_node_type_define(const T0&,const T1&,const T2&, const T3 ,e_vovovoc) - synthesis_node_type_define(const T0&,const T1&,const T2 , const T3&,e_vovocov) - synthesis_node_type_define(const T0&,const T1 ,const T2&, const T3&,e_vocovov) - synthesis_node_type_define(const T0 ,const T1&,const T2&, const T3&,e_covovov) - synthesis_node_type_define(const T0 ,const T1&,const T2 , const T3&,e_covocov) - synthesis_node_type_define(const T0&,const T1 ,const T2&, const T3 ,e_vocovoc) - synthesis_node_type_define(const T0 ,const T1&,const T2&, const T3 ,e_covovoc) - synthesis_node_type_define(const T0&,const T1 ,const T2 , const T3&,e_vococov) - synthesis_node_type_define(const T0 ,const T1 ,const T2 , const T3 ,e_none ) - synthesis_node_type_define(const T0 ,const T1 ,const T2 , const T3&,e_none ) - synthesis_node_type_define(const T0 ,const T1 ,const T2&, const T3 ,e_none ) - synthesis_node_type_define(const T0 ,const T1&,const T2 , const T3 ,e_none ) - synthesis_node_type_define(const T0&,const T1 ,const T2 , const T3 ,e_none ) - synthesis_node_type_define(const T0 ,const T1 ,const T2&, const T3&,e_none ) - synthesis_node_type_define(const T0&,const T1&,const T2 , const T3 ,e_none ) + synthesis_node_type_define(const T0&, const T1&, const T2&, const T3&, e_vovovov) + synthesis_node_type_define(const T0&, const T1&, const T2&, const T3 , e_vovovoc) + synthesis_node_type_define(const T0&, const T1&, const T2 , const T3&, e_vovocov) + synthesis_node_type_define(const T0&, const T1 , const T2&, const T3&, e_vocovov) + synthesis_node_type_define(const T0 , const T1&, const T2&, const T3&, e_covovov) + synthesis_node_type_define(const T0 , const T1&, const T2 , const T3&, e_covocov) + synthesis_node_type_define(const T0&, const T1 , const T2&, const T3 , e_vocovoc) + synthesis_node_type_define(const T0 , const T1&, const T2&, const T3 , e_covovoc) + synthesis_node_type_define(const T0&, const T1 , const T2 , const T3&, e_vococov) + synthesis_node_type_define(const T0 , const T1 , const T2 , const T3 , e_none ) + synthesis_node_type_define(const T0 , const T1 , const T2 , const T3&, e_none ) + synthesis_node_type_define(const T0 , const T1 , const T2&, const T3 , e_none ) + synthesis_node_type_define(const T0 , const T1&, const T2 , const T3 , e_none ) + synthesis_node_type_define(const T0&, const T1 , const T2 , const T3 , e_none ) + synthesis_node_type_define(const T0 , const T1 , const T2&, const T3&, e_none ) + synthesis_node_type_define(const T0&, const T1&, const T2 , const T3 , e_none ) #undef synthesis_node_type_define template <typename T, typename T0, typename T1> @@ -13766,7 +13880,7 @@ bfunc_t p2) { return allocator - .template allocate_type<node_type,T0,T1,bfunc_t&> + .template allocate_type<node_type, T0, T1, bfunc_t&> (p0, p1, p2); } @@ -13812,7 +13926,7 @@ inline T value() const { - return ProcessMode::process(t0_,t1_,t2_,f0_,f1_); + return ProcessMode::process(t0_, t1_, t2_, f0_, f1_); } inline T0 t0() const @@ -13854,7 +13968,7 @@ static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, bfunc_t p3, bfunc_t p4) { return allocator - .template allocate_type<node_type,T0,T1,T2,bfunc_t,bfunc_t> + .template allocate_type<node_type, T0, T1, T2, bfunc_t, bfunc_t> (p0, p1, p2, p3, p4); } @@ -13942,7 +14056,7 @@ static inline std::string id() { - return process_mode_t::template id<T0,T1,T2,T3>(); + return process_mode_t::template id<T0, T1, T2, T3>(); } template <typename Allocator> @@ -13951,7 +14065,7 @@ bfunc_t p4, bfunc_t p5, bfunc_t p6) { return allocator - .template allocate_type<node_type,T0,T1,T2,T3,bfunc_t,bfunc_t> + .template allocate_type<node_type, T0, T1, T2, T3, bfunc_t, bfunc_t> (p0, p1, p2, p3, p4, p5, p6); } @@ -14036,7 +14150,7 @@ static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, tfunc_t p3) { return allocator - .template allocate_type<node_type,T0,T1,T2,tfunc_t> + .template allocate_type<node_type, T0, T1, T2, tfunc_t> (p0, p1, p2, p3); } @@ -14127,7 +14241,7 @@ static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2) { return allocator - .template allocate_type<node_type,T0,T1,T2> + .template allocate_type<node_type, T0, T1, T2> (p0, p1, p2); } @@ -14228,7 +14342,7 @@ static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, T3 p3, qfunc_t p4) { return allocator - .template allocate_type<node_type,T0,T1,T2,T3,qfunc_t> + .template allocate_type<node_type, T0, T1, T2, T3, qfunc_t> (p0, p1, p2, p3, p4); } @@ -14294,7 +14408,7 @@ inline T3 t3() const { - return t2_; + return t3_; } std::string type_id() const @@ -14311,7 +14425,7 @@ static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2, T3 p3) { return allocator - .template allocate_type<node_type,T0,T1,T2,T3> + .template allocate_type<node_type, T0, T1, T2, T3> (p0, p1, p2, p3); } @@ -14347,27 +14461,27 @@ template <typename T, typename T0, typename T1> struct T0oT1_define { - typedef details::T0oT1<T,T0,T1> type0; + typedef details::T0oT1<T, T0, T1> type0; }; template <typename T, typename T0, typename T1, typename T2> struct T0oT1oT2_define { - typedef details::T0oT1oT2<T,T0,T1,T2,typename T0oT1oT2process<T>::mode0> type0; - typedef details::T0oT1oT2<T,T0,T1,T2,typename T0oT1oT2process<T>::mode1> type1; - typedef details::T0oT1oT2_sf3<T,T0,T1,T2> sf3_type; - typedef details::sf3ext_type_node<T,T0,T1,T2> sf3_type_node; + typedef details::T0oT1oT2<T, T0, T1, T2, typename T0oT1oT2process<T>::mode0> type0; + typedef details::T0oT1oT2<T, T0, T1, T2, typename T0oT1oT2process<T>::mode1> type1; + typedef details::T0oT1oT2_sf3<T, T0, T1, T2> sf3_type; + typedef details::sf3ext_type_node<T, T0, T1, T2> sf3_type_node; }; template <typename T, typename T0, typename T1, typename T2, typename T3> struct T0oT1oT2oT3_define { - typedef details::T0oT1oT2oT3<T,T0,T1,T2,T3,typename T0oT1oT20T3process<T>::mode0> type0; - typedef details::T0oT1oT2oT3<T,T0,T1,T2,T3,typename T0oT1oT20T3process<T>::mode1> type1; - typedef details::T0oT1oT2oT3<T,T0,T1,T2,T3,typename T0oT1oT20T3process<T>::mode2> type2; - typedef details::T0oT1oT2oT3<T,T0,T1,T2,T3,typename T0oT1oT20T3process<T>::mode3> type3; - typedef details::T0oT1oT2oT3<T,T0,T1,T2,T3,typename T0oT1oT20T3process<T>::mode4> type4; - typedef details::T0oT1oT2oT3_sf4<T,T0,T1,T2,T3> sf4_type; + typedef details::T0oT1oT2oT3<T, T0, T1, T2, T3, typename T0oT1oT20T3process<T>::mode0> type0; + typedef details::T0oT1oT2oT3<T, T0, T1, T2, T3, typename T0oT1oT20T3process<T>::mode1> type1; + typedef details::T0oT1oT2oT3<T, T0, T1, T2, T3, typename T0oT1oT20T3process<T>::mode2> type2; + typedef details::T0oT1oT2oT3<T, T0, T1, T2, T3, typename T0oT1oT20T3process<T>::mode3> type3; + typedef details::T0oT1oT2oT3<T, T0, T1, T2, T3, typename T0oT1oT20T3process<T>::mode4> type4; + typedef details::T0oT1oT2oT3_sf4<T, T0, T1, T2, T3> sf4_type; }; template <typename T, typename Operation> @@ -15018,12 +15132,12 @@ if (0 == str0_base_ptr_) return; - irange_ptr range_ptr = dynamic_cast<irange_ptr>(binary_node<T>::branch_[0].first); + irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[0].first); - if (0 == range_ptr) + if (0 == range) return; - str0_range_ptr_ = &(range_ptr->range_ref()); + str0_range_ptr_ = &(range->range_ref()); } if (is_generally_string_node(binary_node<T>::branch_[1].first)) @@ -15033,12 +15147,12 @@ if (0 == str1_base_ptr_) return; - irange_ptr range_ptr = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first); + irange_ptr range = dynamic_cast<irange_ptr>(binary_node<T>::branch_[1].first); - if (0 == range_ptr) + if (0 == range) return; - str1_range_ptr_ = &(range_ptr->range_ref()); + str1_range_ptr_ = &(range->range_ref()); } } @@ -15437,37 +15551,37 @@ template <typename ResultNode, typename OpType, typename ExprNode> inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[1]) { - return allocate<ResultNode>(operation,branch[0]); + return allocate<ResultNode>(operation, branch[0]); } template <typename ResultNode, typename OpType, typename ExprNode> inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[2]) { - return allocate<ResultNode>(operation,branch[0],branch[1]); + return allocate<ResultNode>(operation, branch[0], branch[1]); } template <typename ResultNode, typename OpType, typename ExprNode> inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[3]) { - return allocate<ResultNode>(operation,branch[0],branch[1],branch[2]); + return allocate<ResultNode>(operation, branch[0], branch[1], branch[2]); } template <typename ResultNode, typename OpType, typename ExprNode> inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[4]) { - return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3]); + return allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3]); } template <typename ResultNode, typename OpType, typename ExprNode> inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[5]) { - return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3],branch[4]); + return allocate<ResultNode>(operation, branch[0],branch[1], branch[2], branch[3], branch[4]); } template <typename ResultNode, typename OpType, typename ExprNode> inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[6]) { - return allocate<ResultNode>(operation,branch[0],branch[1],branch[2],branch[3],branch[4],branch[5]); + return allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3], branch[4], branch[5]); } template <typename node_type> @@ -15479,7 +15593,7 @@ template <typename node_type, typename Type, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node<typename node_type::value_type>* allocate(const Sequence<Type,Allocator>& seq) const { return (new node_type(seq)); @@ -15978,8 +16092,9 @@ enum return_type { - e_rtrn_scalar = 0, - e_rtrn_string = 1 + e_rtrn_scalar = 0, + e_rtrn_string = 1, + e_rtrn_overload = 2 }; typedef T type; @@ -16030,20 +16145,20 @@ typedef T (*ff00_functor)(); typedef T (*ff01_functor)(T); - typedef T (*ff02_functor)(T,T); - typedef T (*ff03_functor)(T,T,T); - typedef T (*ff04_functor)(T,T,T,T); - typedef T (*ff05_functor)(T,T,T,T,T); - typedef T (*ff06_functor)(T,T,T,T,T,T); - typedef T (*ff07_functor)(T,T,T,T,T,T,T); - typedef T (*ff08_functor)(T,T,T,T,T,T,T,T); - typedef T (*ff09_functor)(T,T,T,T,T,T,T,T,T); - typedef T (*ff10_functor)(T,T,T,T,T,T,T,T,T,T); - typedef T (*ff11_functor)(T,T,T,T,T,T,T,T,T,T,T); - typedef T (*ff12_functor)(T,T,T,T,T,T,T,T,T,T,T,T); - typedef T (*ff13_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T); - typedef T (*ff14_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T,T); - typedef T (*ff15_functor)(T,T,T,T,T,T,T,T,T,T,T,T,T,T,T); + typedef T (*ff02_functor)(T, T); + typedef T (*ff03_functor)(T, T, T); + typedef T (*ff04_functor)(T, T, T, T); + typedef T (*ff05_functor)(T, T, T, T, T); + typedef T (*ff06_functor)(T, T, T, T, T, T); + typedef T (*ff07_functor)(T, T, T, T, T, T, T); + typedef T (*ff08_functor)(T, T, T, T, T, T, T, T); + typedef T (*ff09_functor)(T, T, T, T, T, T, T, T, T); + typedef T (*ff10_functor)(T, T, T, T, T, T, T, T, T, T); + typedef T (*ff11_functor)(T, T, T, T, T, T, T, T, T, T, T); + typedef T (*ff12_functor)(T, T, T, T, T, T, T, T, T, T, T, T); + typedef T (*ff13_functor)(T, T, T, T, T, T, T, T, T, T, T, T, T); + typedef T (*ff14_functor)(T, T, T, T, T, T, T, T, T, T, T, T, T, T); + typedef T (*ff15_functor)(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T); protected: @@ -16051,7 +16166,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc00(ff00_functor ff) : exprtk::ifunction<T>(0), f(ff) {} + explicit freefunc00(ff00_functor ff) : exprtk::ifunction<T>(0), f(ff) {} inline T operator() () { return f(); } ff00_functor f; @@ -16061,7 +16176,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc01(ff01_functor ff) : exprtk::ifunction<T>(1), f(ff) {} + explicit freefunc01(ff01_functor ff) : exprtk::ifunction<T>(1), f(ff) {} inline T operator() (const T& v0) { return f(v0); } ff01_functor f; @@ -16071,7 +16186,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc02(ff02_functor ff) : exprtk::ifunction<T>(2), f(ff) {} + explicit freefunc02(ff02_functor ff) : exprtk::ifunction<T>(2), f(ff) {} inline T operator() (const T& v0, const T& v1) { return f(v0, v1); } ff02_functor f; @@ -16081,7 +16196,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc03(ff03_functor ff) : exprtk::ifunction<T>(3), f(ff) {} + explicit freefunc03(ff03_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); } ff03_functor f; @@ -16091,7 +16206,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc04(ff04_functor ff) : exprtk::ifunction<T>(4), f(ff) {} + explicit freefunc04(ff04_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); } ff04_functor f; @@ -16101,7 +16216,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc05(ff05_functor ff) : exprtk::ifunction<T>(5), f(ff) {} + explicit freefunc05(ff05_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); } ff05_functor f; @@ -16111,7 +16226,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc06(ff06_functor ff) : exprtk::ifunction<T>(6), f(ff) {} + explicit freefunc06(ff06_functor ff) : exprtk::ifunction<T>(6), f(ff) {} inline T operator() (const T& v0, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5) { return f(v0, v1, v2, v3, v4, v5); } ff06_functor f; @@ -16121,7 +16236,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc07(ff07_functor ff) : exprtk::ifunction<T>(7), f(ff) {} + explicit freefunc07(ff07_functor ff) : exprtk::ifunction<T>(7), f(ff) {} inline T operator() (const T& v0, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6) { return f(v0, v1, v2, v3, v4, v5, v6); } @@ -16132,7 +16247,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc08(ff08_functor ff) : exprtk::ifunction<T>(8), f(ff) {} + explicit freefunc08(ff08_functor ff) : exprtk::ifunction<T>(8), f(ff) {} inline T operator() (const T& v0, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7) { return f(v0, v1, v2, v3, v4, v5, v6, v7); } @@ -16143,7 +16258,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc09(ff09_functor ff) : exprtk::ifunction<T>(9), f(ff) {} + explicit freefunc09(ff09_functor ff) : exprtk::ifunction<T>(9), f(ff) {} inline T operator() (const T& v0, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8) { return f(v0, v1, v2, v3, v4, v5, v6, v7, v8); } @@ -16154,7 +16269,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc10(ff10_functor ff) : exprtk::ifunction<T>(10), f(ff) {} + explicit freefunc10(ff10_functor ff) : exprtk::ifunction<T>(10), f(ff) {} inline T operator() (const T& v0, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8, const T& v9) { return f(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9); } @@ -16165,7 +16280,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc11(ff11_functor ff) : exprtk::ifunction<T>(11), f(ff) {} + explicit freefunc11(ff11_functor ff) : exprtk::ifunction<T>(11), f(ff) {} inline T operator() (const T& v0, const T& v1, const T& v2, const T& v3, const T& v4, const T& v5, const T& v6, const T& v7, const T& v8, const T& v9, const T& v10) { return f(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10); } @@ -16176,7 +16291,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc12(ff12_functor ff) : exprtk::ifunction<T>(12), f(ff) {} + explicit freefunc12(ff12_functor ff) : exprtk::ifunction<T>(12), f(ff) {} inline T operator() (const T& v00, const T& v01, const T& v02, const T& v03, const T& v04, const T& v05, const T& v06, const T& v07, const T& v08, const T& v09, const T& v10, const T& v11) @@ -16188,7 +16303,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc13(ff13_functor ff) : exprtk::ifunction<T>(13), f(ff) {} + explicit freefunc13(ff13_functor ff) : exprtk::ifunction<T>(13), f(ff) {} inline T operator() (const T& v00, const T& v01, const T& v02, const T& v03, const T& v04, const T& v05, const T& v06, const T& v07, const T& v08, const T& v09, const T& v10, const T& v11, const T& v12) @@ -16200,7 +16315,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc14(ff14_functor ff) : exprtk::ifunction<T>(14), f(ff) {} + explicit freefunc14(ff14_functor ff) : exprtk::ifunction<T>(14), f(ff) {} inline T operator() (const T& v00, const T& v01, const T& v02, const T& v03, const T& v04, const T& v05, const T& v06, const T& v07, const T& v08, const T& v09, const T& v10, const T& v11, const T& v12, const T& v13) @@ -16212,7 +16327,7 @@ { using exprtk::ifunction<T>::operator(); - freefunc15(ff15_functor ff) : exprtk::ifunction<T>(15), f(ff) {} + explicit freefunc15(ff15_functor ff) : exprtk::ifunction<T>(15), f(ff) {} inline T operator() (const T& v00, const T& v01, const T& v02, const T& v03, const T& v04, const T& v05, const T& v06, const T& v07, const T& v08, const T& v09, const T& v10, const T& v11, const T& v12, const T& v13, const T& v14) @@ -16631,11 +16746,12 @@ #ifndef exprtk_disable_string_capabilities type_store<typename details::stringvar_node<T>,std::string> stringvar_store; #endif - type_store<ifunction<T>,ifunction<T> > function_store; + type_store<ifunction<T>,ifunction<T> > function_store; type_store<ivararg_function <T>,ivararg_function <T> > vararg_function_store; type_store<igeneric_function<T>,igeneric_function<T> > generic_function_store; type_store<igeneric_function<T>,igeneric_function<T> > string_function_store; - type_store<vector_holder_t,vector_holder_t> vector_store; + type_store<igeneric_function<T>,igeneric_function<T> > overload_function_store; + type_store<vector_holder_t,vector_holder_t> vector_store; st_data() { @@ -16685,7 +16801,7 @@ data_(st_data::create()) {} - control_block(st_data* data) + explicit control_block(st_data* data) : ref_count(1), data_(data) {} @@ -16759,7 +16875,7 @@ return (*this); } - inline bool operator==(const symbol_table<T>& st) + inline bool operator==(const symbol_table<T>& st) const { return (this == &st) || (control_block_ == st.control_block_); } @@ -16906,6 +17022,16 @@ return local_data().string_function_store.get(function_name); } + inline generic_function_ptr get_overload_function(const std::string& function_name) const + { + if (!valid()) + return reinterpret_cast<generic_function_ptr>(0); + else if (!valid_symbol(function_name)) + return reinterpret_cast<generic_function_ptr>(0); + else + return local_data().overload_function_store.get(function_name); + } + typedef vector_holder_t* vector_holder_ptr; inline vector_holder_ptr get_vector(const std::string& vector_name) const @@ -17007,7 +17133,7 @@ else if (symbol_exists(variable_name)) return false; else - return local_data().variable_store.add(variable_name,t,is_constant); + return local_data().variable_store.add(variable_name, t, is_constant); } inline bool add_constant(const std::string& constant_name, const T& value) @@ -17022,7 +17148,7 @@ local_data().local_symbol_list_.push_back(value); T& t = local_data().local_symbol_list_.back(); - return add_variable(constant_name,t,true); + return add_variable(constant_name, t, true); } #ifndef exprtk_disable_string_capabilities @@ -17035,7 +17161,7 @@ else if (symbol_exists(stringvar_name)) return false; else - return local_data().stringvar_store.add(stringvar_name,s,is_constant); + return local_data().stringvar_store.add(stringvar_name, s, is_constant); } #endif @@ -17071,14 +17197,33 @@ return false; else if (symbol_exists(function_name)) return false; - else if (std::string::npos != function.parameter_sequence.find_first_not_of("STVZ*?|")) + else if ( + ( + (generic_function_t::e_rtrn_scalar == function.rtrn_type) || + (generic_function_t::e_rtrn_string == function.rtrn_type) + ) && + std::string::npos != function.parameter_sequence.find_first_not_of("STVZ*?|") + ) return false; - else if (generic_function_t::e_rtrn_scalar == function.rtrn_type) - return local_data().generic_function_store.add(function_name,function); - else if (generic_function_t::e_rtrn_string == function.rtrn_type) - return local_data().string_function_store.add(function_name, function); - else + else if ( + (generic_function_t::e_rtrn_overload == function.rtrn_type) && + std::string::npos != function.parameter_sequence.find_first_not_of("STVZ*?|:") + ) return false; + + switch (function.rtrn_type) + { + case generic_function_t::e_rtrn_scalar : + return local_data().generic_function_store.add(function_name,function); + + case generic_function_t::e_rtrn_string : + return local_data().string_function_store.add(function_name,function); + + case generic_function_t::e_rtrn_overload : + return local_data().overload_function_store.add(function_name,function); + } + + return false; } #define exprtk_define_freefunction(NN) \ @@ -17141,14 +17286,33 @@ return false; else if (symbol_exists(function_name,false)) return false; - else if (std::string::npos != function.parameter_sequence.find_first_not_of("STV*?|")) + else if ( + ( + (generic_function_t::e_rtrn_scalar == function.rtrn_type) || + (generic_function_t::e_rtrn_string == function.rtrn_type) + ) && + std::string::npos != function.parameter_sequence.find_first_not_of("STV*?|") + ) return false; - else if (generic_function_t::e_rtrn_scalar == function.rtrn_type) - return local_data().generic_function_store.add(function_name,function); - else if (generic_function_t::e_rtrn_string == function.rtrn_type) - return local_data().string_function_store.add(function_name, function); - else + else if ( + generic_function_t::e_rtrn_overload && + std::string::npos != function.parameter_sequence.find_first_not_of("STV*?|:") + ) return false; + + switch (function.rtrn_type) + { + case generic_function_t::e_rtrn_scalar : + return local_data().generic_function_store.add(function_name,function); + + case generic_function_t::e_rtrn_string : + return local_data().string_function_store.add(function_name,function); + + case generic_function_t::e_rtrn_overload : + return local_data().overload_function_store.add(function_name,function); + } + + return false; } template <std::size_t N> @@ -17175,7 +17339,7 @@ else if (0 == v_size) return false; else - return local_data().vector_store.add(vector_name,v,v_size); + return local_data().vector_store.add(vector_name, v, v_size); } template <typename Allocator> @@ -17337,8 +17501,8 @@ { /* Function will return true if symbol_name exists as either a - reserved symbol, variable, stringvar or function name in any - of the type stores. + reserved symbol, variable, stringvar, vector or function name + in any of the type stores. */ if (!valid()) return false; @@ -17348,6 +17512,8 @@ else if (local_data().stringvar_store.symbol_exists(symbol_name)) return true; #endif + else if (local_data().vector_store.symbol_exists(symbol_name)) + return true; else if (local_data().function_store.symbol_exists(symbol_name)) return true; else if (check_reserved_symb && local_data().is_reserved_symbol(symbol_name)) @@ -17502,6 +17668,21 @@ } } } + + { + std::vector<std::string> name_list; + + st.local_data().overload_function_store.get_list(name_list); + + if (!name_list.empty()) + { + for (std::size_t i = 0; i < name_list.size(); ++i) + { + exprtk::igeneric_function<T>& ifunc = *st.get_overload_function(name_list[i]); + add_function(name_list[i],ifunc); + } + } + } } private: @@ -17629,7 +17810,7 @@ return_invoked(&retinv_null) {} - control_block(expression_ptr e) + explicit control_block(expression_ptr e) : ref_count(1), expr (e), results (0), @@ -17722,6 +17903,13 @@ control_block_->ref_count++; } + explicit expression(const symbol_table<T>& symbol_table) + : control_block_(0) + { + set_expression(new details::null_node<T>()); + symbol_table_list_.push_back(symbol_table); + } + inline expression<T>& operator=(const expression<T>& e) { if (this != &e) @@ -17747,7 +17935,7 @@ return *this; } - inline bool operator==(const expression<T>& e) + inline bool operator==(const expression<T>& e) const { return (this == &e); } @@ -17896,7 +18084,7 @@ control_block_-> local_data_list.push_back( typename expression<T>::control_block:: - data_pack(reinterpret_cast<void*>(data),dt,size)); + data_pack(reinterpret_cast<void*>(data), dt, size)); } } } @@ -17931,7 +18119,7 @@ } control_block* control_block_; - symtab_list_t symbol_table_list_; + symtab_list_t symbol_table_list_; friend class parser<T>; friend class expression_helper<T>; @@ -18336,7 +18524,7 @@ typedef variable_node_t* variable_node_ptr; typedef parser<T> parser_t; - scope_element_manager(parser<T>& p) + explicit scope_element_manager(parser<T>& p) : parser_(p), input_param_cnt_(0) {} @@ -18447,6 +18635,10 @@ inline void free_element(scope_element& se) { + #ifdef exprtk_enable_debugging + exprtk_debug(("free_element() - se[%s]\n", se.name.c_str())); + #endif + switch (se.type) { case scope_element::e_variable : if (se.data ) delete (T*) se.data; @@ -18529,12 +18721,12 @@ typedef parser<T> parser_t; - scope_handler(parser<T>& p) + explicit scope_handler(parser<T>& p) : parser_(p) { parser_.state_.scope_depth++; #ifdef exprtk_enable_debugging - std::string depth(2 * parser_.state_.scope_depth,'-'); + const std::string depth(2 * parser_.state_.scope_depth,'-'); exprtk_debug(("%s> Scope Depth: %02d\n", depth.c_str(), static_cast<int>(parser_.state_.scope_depth))); @@ -18546,7 +18738,7 @@ parser_.sem_.deactivate(parser_.state_.scope_depth); parser_.state_.scope_depth--; #ifdef exprtk_enable_debugging - std::string depth(2 * parser_.state_.scope_depth,'-'); + const std::string depth(2 * parser_.state_.scope_depth,'-'); exprtk_debug(("<%s Scope Depth: %02d\n", depth.c_str(), static_cast<int>(parser_.state_.scope_depth))); @@ -18760,6 +18952,27 @@ return result; } + inline generic_function_ptr get_overload_function(const std::string& function_name) const + { + if (!valid_function_name(function_name)) + return reinterpret_cast<generic_function_ptr>(0); + + generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0); + + for (std::size_t i = 0; i < symtab_list_.size(); ++i) + { + if (!symtab_list_[i].valid()) + continue; + else + result = + local_data(i).overload_function_store.get(function_name); + + if (result) break; + } + + return result; + } + inline vector_holder_ptr get_vector(const std::string& vector_name) const { if (!valid_symbol(vector_name)) @@ -19018,8 +19231,9 @@ enum usr_symbol_type { - e_usr_variable_type = 0, - e_usr_constant_type = 1 + e_usr_unknown_type = 0, + e_usr_variable_type = 1, + e_usr_constant_type = 2 }; enum usr_mode @@ -19098,7 +19312,7 @@ {} template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline std::size_t symbols(Sequence<symbol_t,Allocator>& symbols_list) { if (!collect_variables_ && !collect_functions_) @@ -19121,7 +19335,7 @@ } template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline std::size_t assignment_symbols(Sequence<symbol_t,Allocator>& assignment_list) { if (!collect_assignments_) @@ -19454,7 +19668,7 @@ bool rsrvd_sym_usr_disabled () const { return disable_rsrvd_sym_usr_; } bool zero_return_disabled () const { return disable_zero_return_; } - bool function_enabled(const std::string& function_name) + bool function_enabled(const std::string& function_name) const { if (disabled_func_set_.empty()) return true; @@ -19462,7 +19676,7 @@ return (disabled_func_set_.end() == disabled_func_set_.find(function_name)); } - bool control_struct_enabled(const std::string& control_struct) + bool control_struct_enabled(const std::string& control_struct) const { if (disabled_ctrl_set_.empty()) return true; @@ -19470,7 +19684,7 @@ return (disabled_ctrl_set_.end() == disabled_ctrl_set_.find(control_struct)); } - bool logic_enabled(const std::string& logic_operation) + bool logic_enabled(const std::string& logic_operation) const { if (disabled_logic_set_.empty()) return true; @@ -19478,7 +19692,7 @@ return (disabled_logic_set_.end() == disabled_logic_set_.find(logic_operation)); } - bool arithmetic_enabled(const details::operator_type& arithmetic_operation) + bool arithmetic_enabled(const details::operator_type& arithmetic_operation) const { if (disabled_logic_set_.empty()) return true; @@ -19487,7 +19701,7 @@ .find(arith_opr_to_string(arithmetic_operation)); } - bool assignment_enabled(const details::operator_type& assignment) + bool assignment_enabled(const details::operator_type& assignment) const { if (disabled_assignment_set_.empty()) return true; @@ -19496,7 +19710,7 @@ .find(assign_opr_to_string(assignment)); } - bool inequality_enabled(const details::operator_type& inequality) + bool inequality_enabled(const details::operator_type& inequality) const { if (disabled_inequality_set_.empty()) return true; @@ -19505,7 +19719,7 @@ .find(inequality_opr_to_string(inequality)); } - bool function_disabled(const std::string& function_name) + bool function_disabled(const std::string& function_name) const { if (disabled_func_set_.empty()) return false; @@ -19513,7 +19727,7 @@ return (disabled_func_set_.end() != disabled_func_set_.find(function_name)); } - bool control_struct_disabled(const std::string& control_struct) + bool control_struct_disabled(const std::string& control_struct) const { if (disabled_ctrl_set_.empty()) return false; @@ -19521,7 +19735,7 @@ return (disabled_ctrl_set_.end() != disabled_ctrl_set_.find(control_struct)); } - bool logic_disabled(const std::string& logic_operation) + bool logic_disabled(const std::string& logic_operation) const { if (disabled_logic_set_.empty()) return false; @@ -19529,7 +19743,7 @@ return (disabled_logic_set_.end() != disabled_logic_set_.find(logic_operation)); } - bool assignment_disabled(const details::operator_type assignment_operation) + bool assignment_disabled(const details::operator_type assignment_operation) const { if (disabled_assignment_set_.empty()) return false; @@ -19538,7 +19752,16 @@ .find(assign_opr_to_string(assignment_operation)); } - bool arithmetic_disabled(const details::operator_type arithmetic_operation) + bool logic_disabled(const details::operator_type logic_operation) const + { + if (disabled_logic_set_.empty()) + return false; + else + return disabled_logic_set_.end() != disabled_logic_set_ + .find(logic_opr_to_string(logic_operation)); + } + + bool arithmetic_disabled(const details::operator_type arithmetic_operation) const { if (disabled_arithmetic_set_.empty()) return false; @@ -19547,7 +19770,7 @@ .find(arith_opr_to_string(arithmetic_operation)); } - bool inequality_disabled(const details::operator_type& inequality) + bool inequality_disabled(const details::operator_type& inequality) const { if (disabled_inequality_set_.empty()) return false; @@ -19761,7 +19984,7 @@ disable_zero_return_ = (compile_options & e_disable_zero_return ) == e_disable_zero_return; } - std::string assign_opr_to_string(details::operator_type opr) + std::string assign_opr_to_string(details::operator_type opr) const { switch (opr) { @@ -19775,7 +19998,7 @@ } } - std::string arith_opr_to_string(details::operator_type opr) + std::string arith_opr_to_string(details::operator_type opr) const { switch (opr) { @@ -19788,7 +20011,7 @@ } } - std::string inequality_opr_to_string(details::operator_type opr) + std::string inequality_opr_to_string(details::operator_type opr) const { switch (opr) { @@ -19804,6 +20027,21 @@ } } + std::string logic_opr_to_string(details::operator_type opr) const + { + switch (opr) + { + case details::e_and : return "and" ; + case details::e_or : return "or" ; + case details::e_xor : return "xor" ; + case details::e_nand : return "nand"; + case details::e_nor : return "nor" ; + case details::e_xnor : return "xnor"; + case details::e_notl : return "not" ; + default : return "" ; + } + } + bool enable_replacer_; bool enable_joiner_; bool enable_numeric_check_; @@ -19882,8 +20120,8 @@ if (settings_.replacer_enabled()) { symbol_replacer_.clear(); - symbol_replacer_.add_replace("true" ,"1",lexer::token::e_number); - symbol_replacer_.add_replace("false","0",lexer::token::e_number); + symbol_replacer_.add_replace("true" , "1", lexer::token::e_number); + symbol_replacer_.add_replace("false", "0", lexer::token::e_number); helper_assembly_.token_modifier_list.clear(); helper_assembly_.register_modifier(&symbol_replacer_); } @@ -19926,7 +20164,8 @@ if (settings_.sequence_check_enabled()) { - helper_assembly_.register_scanner(&sequence_validator_); + helper_assembly_.register_scanner(&sequence_validator_ ); + helper_assembly_.register_scanner(&sequence_validator_3tkns_); } } } @@ -19992,7 +20231,7 @@ dec_.return_present_ = true; e = expression_generator_ - .return_envelope(e,results_context_,retinvk_ptr); + .return_envelope(e, results_context_, retinvk_ptr); } expr.set_expression(e); @@ -20014,15 +20253,15 @@ exprtk_error_location)); } - dec_.clear (); - sem_.cleanup (); - return_cleanup(); - if ((0 != e) && branch_deletable(e)) { destroy_node(e); } + dec_.clear (); + sem_.cleanup (); + return_cleanup(); + return false; } } @@ -20102,9 +20341,10 @@ { if (helper_assembly_.error_token_scanner) { - lexer::helper::bracket_checker* bracket_checker_ptr = 0; - lexer::helper::numeric_checker* numeric_checker_ptr = 0; - lexer::helper::sequence_validator* sequence_validator_ptr = 0; + lexer::helper::bracket_checker* bracket_checker_ptr = 0; + lexer::helper::numeric_checker* numeric_checker_ptr = 0; + lexer::helper::sequence_validator* sequence_validator_ptr = 0; + lexer::helper::sequence_validator_3tokens* sequence_validator3_ptr = 0; if (0 != (bracket_checker_ptr = dynamic_cast<lexer::helper::bracket_checker*>(helper_assembly_.error_token_scanner))) { @@ -20152,6 +20392,26 @@ sequence_validator_ptr->clear_errors(); } } + else if (0 != (sequence_validator3_ptr = dynamic_cast<lexer::helper::sequence_validator_3tokens*>(helper_assembly_.error_token_scanner))) + { + for (std::size_t i = 0; i < sequence_validator3_ptr->error_count(); ++i) + { + std::pair<lexer::token,lexer::token> error_token = sequence_validator3_ptr->error(i); + + set_error( + make_error(parser_error::e_token, + error_token.first, + "ERR007 - Invalid token sequence: '" + + error_token.first.value + "' and '" + + error_token.second.value + "'", + exprtk_error_location)); + } + + if (sequence_validator3_ptr->error_count()) + { + sequence_validator3_ptr->clear_errors(); + } + } } return false; @@ -20166,7 +20426,7 @@ return settings_; } - inline parser_error::type get_error(const std::size_t& index) + inline parser_error::type get_error(const std::size_t& index) const { if (index < error_list_.size()) return error_list_[index]; @@ -20237,7 +20497,7 @@ private: - inline bool valid_base_operation(const std::string& symbol) + inline bool valid_base_operation(const std::string& symbol) const { const std::size_t length = symbol.size(); @@ -20251,7 +20511,7 @@ (base_ops_map_.end() != base_ops_map_.find(symbol)); } - inline bool valid_vararg_operation(const std::string& symbol) + inline bool valid_vararg_operation(const std::string& symbol) const { static const std::string s_sum = "sum" ; static const std::string s_mul = "mul" ; @@ -20278,17 +20538,22 @@ settings_.function_enabled(symbol); } - bool is_invalid_arithmetic_operation(const details::operator_type operation) + bool is_invalid_logic_operation(const details::operator_type operation) const + { + return settings_.logic_disabled(operation); + } + + bool is_invalid_arithmetic_operation(const details::operator_type operation) const { return settings_.arithmetic_disabled(operation); } - bool is_invalid_assignment_operation(const details::operator_type operation) + bool is_invalid_assignment_operation(const details::operator_type operation) const { return settings_.assignment_disabled(operation); } - bool is_invalid_inequality_operation(const details::operator_type operation) + bool is_invalid_inequality_operation(const details::operator_type operation) const { return settings_.inequality_disabled(operation); } @@ -20296,9 +20561,9 @@ #ifdef exprtk_enable_debugging inline void next_token() { - std::string ct_str = current_token().value; + const std::string ct_str = current_token().value; parser_helper::next_token(); - std::string depth(2 * state_.scope_depth,' '); + const std::string depth(2 * state_.scope_depth,' '); exprtk_debug(("%s" "prev[%s] --> curr[%s]\n", depth.c_str(), @@ -20312,8 +20577,6 @@ std::vector<expression_node_ptr> arg_list; std::vector<bool> side_effect_list; - expression_node_ptr result = error_node(); - scoped_vec_delete<expression_node_t> sdd((*this),arg_list); lexer::token begin_token; @@ -20334,7 +20597,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR007 - Invalid expression encountered", + "ERR008 - Invalid expression encountered", exprtk_error_location)); } @@ -20348,7 +20611,7 @@ end_token = current_token(); - std::string sub_expr = construct_subexpr(begin_token,end_token); + const std::string sub_expr = construct_subexpr(begin_token, end_token); exprtk_debug(("parse_corpus(%02d) Subexpr: %s\n", static_cast<int>(arg_list.size() - 1), @@ -20380,7 +20643,7 @@ dec_.final_stmt_return_ = true; } - result = simplify(arg_list,side_effect_list); + const expression_node_ptr result = simplify(arg_list,side_effect_list); sdd.delete_ptr = (0 == result); @@ -20443,25 +20706,25 @@ switch (current_token().type) { - case token_t::e_assign : current_state.set(e_level00,e_level00,details::e_assign); break; - case token_t::e_addass : current_state.set(e_level00,e_level00,details::e_addass); break; - case token_t::e_subass : current_state.set(e_level00,e_level00,details::e_subass); break; - case token_t::e_mulass : current_state.set(e_level00,e_level00,details::e_mulass); break; - case token_t::e_divass : current_state.set(e_level00,e_level00,details::e_divass); break; - case token_t::e_modass : current_state.set(e_level00,e_level00,details::e_modass); break; - case token_t::e_swap : current_state.set(e_level00,e_level00,details::e_swap ); break; - case token_t::e_lt : current_state.set(e_level05,e_level06,details:: e_lt); break; - case token_t::e_lte : current_state.set(e_level05,e_level06,details:: e_lte); break; - case token_t::e_eq : current_state.set(e_level05,e_level06,details:: e_eq); break; - case token_t::e_ne : current_state.set(e_level05,e_level06,details:: e_ne); break; - case token_t::e_gte : current_state.set(e_level05,e_level06,details:: e_gte); break; - case token_t::e_gt : current_state.set(e_level05,e_level06,details:: e_gt); break; - case token_t::e_add : current_state.set(e_level07,e_level08,details:: e_add); break; - case token_t::e_sub : current_state.set(e_level07,e_level08,details:: e_sub); break; - case token_t::e_div : current_state.set(e_level10,e_level11,details:: e_div); break; - case token_t::e_mul : current_state.set(e_level10,e_level11,details:: e_mul); break; - case token_t::e_mod : current_state.set(e_level10,e_level11,details:: e_mod); break; - case token_t::e_pow : current_state.set(e_level12,e_level12,details:: e_pow); break; + case token_t::e_assign : current_state.set(e_level00,e_level00, details::e_assign); break; + case token_t::e_addass : current_state.set(e_level00,e_level00, details::e_addass); break; + case token_t::e_subass : current_state.set(e_level00,e_level00, details::e_subass); break; + case token_t::e_mulass : current_state.set(e_level00,e_level00, details::e_mulass); break; + case token_t::e_divass : current_state.set(e_level00,e_level00, details::e_divass); break; + case token_t::e_modass : current_state.set(e_level00,e_level00, details::e_modass); break; + case token_t::e_swap : current_state.set(e_level00,e_level00, details::e_swap ); break; + case token_t::e_lt : current_state.set(e_level05,e_level06, details:: e_lt); break; + case token_t::e_lte : current_state.set(e_level05,e_level06, details:: e_lte); break; + case token_t::e_eq : current_state.set(e_level05,e_level06, details:: e_eq); break; + case token_t::e_ne : current_state.set(e_level05,e_level06, details:: e_ne); break; + case token_t::e_gte : current_state.set(e_level05,e_level06, details:: e_gte); break; + case token_t::e_gt : current_state.set(e_level05,e_level06, details:: e_gt); break; + case token_t::e_add : current_state.set(e_level07,e_level08, details:: e_add); break; + case token_t::e_sub : current_state.set(e_level07,e_level08, details:: e_sub); break; + case token_t::e_div : current_state.set(e_level10,e_level11, details:: e_div); break; + case token_t::e_mul : current_state.set(e_level10,e_level11, details:: e_mul); break; + case token_t::e_mod : current_state.set(e_level10,e_level11, details:: e_mod); break; + case token_t::e_pow : current_state.set(e_level12,e_level12, details:: e_pow); break; default : if (token_t::e_symbol == current_token().type) { static const std::string s_and = "and"; @@ -20557,21 +20820,33 @@ else if (current_state.left < precedence) break; - lexer::token prev_token = current_token(); + const lexer::token prev_token = current_token(); next_token(); expression_node_ptr right_branch = error_node(); expression_node_ptr new_expression = error_node(); - if (is_invalid_arithmetic_operation(current_state.operation)) + if (is_invalid_logic_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) + "'", + "ERR009 - Invalid or disabled logic operation '" + details::to_str(current_state.operation) + "'", + exprtk_error_location)); + + return error_node(); + } + else if (is_invalid_arithmetic_operation(current_state.operation)) + { + free_node(node_allocator_,expression); + + set_error( + make_error(parser_error::e_syntax, + prev_token, + "ERR010 - Invalid or disabled arithmetic operation '" + details::to_str(current_state.operation) + "'", exprtk_error_location)); return error_node(); @@ -20583,7 +20858,7 @@ set_error( make_error(parser_error::e_syntax, prev_token, - "ERR009 - Invalid inequality operation '" + details::to_str(current_state.operation) + "'", + "ERR011 - Invalid inequality operation '" + details::to_str(current_state.operation) + "'", exprtk_error_location)); return error_node(); @@ -20595,7 +20870,7 @@ set_error( make_error(parser_error::e_syntax, prev_token, - "ERR010 - Invalid assignment operation '" + details::to_str(current_state.operation) + "'", + "ERR012 - Invalid or disabled assignment operation '" + details::to_str(current_state.operation) + "'", exprtk_error_location)); return error_node(); @@ -20608,13 +20883,13 @@ details::is_return_node(right_branch) ) { - free_node(node_allocator_, expression); - free_node(node_allocator_,right_branch); + free_node(node_allocator_, expression); + free_node(node_allocator_, right_branch); set_error( make_error(parser_error::e_syntax, prev_token, - "ERR011 - Return statements cannot be part of sub-expressions", + "ERR013 - Return statements cannot be part of sub-expressions", exprtk_error_location)); return error_node(); @@ -20637,11 +20912,12 @@ prev_token, !synthesis_error_.empty() ? synthesis_error_ : - "ERR012 - General parsing error at token: '" + prev_token.value + "'", + "ERR014 - General parsing error at token: '" + prev_token.value + "'", exprtk_error_location)); } - free_node(node_allocator_,expression); + free_node(node_allocator_, expression); + free_node(node_allocator_, right_branch); return error_node(); } @@ -20706,7 +20982,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR013 - Failed to find variable node in symbol table", + "ERR015 - Failed to find variable node in symbol table", exprtk_error_location)); free_node(node_allocator_,node); @@ -20829,7 +21105,7 @@ struct scoped_bool_negator { - scoped_bool_negator(bool& bb) + explicit scoped_bool_negator(bool& bb) : b(bb) { b = !b; } @@ -20841,7 +21117,7 @@ struct scoped_bool_or_restorer { - scoped_bool_or_restorer(bool& bb) + explicit scoped_bool_or_restorer(bool& bb) : b(bb), original_value_(bb) {} @@ -20886,7 +21162,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR014 - Invalid number of parameters for function: '" + function_name + "'", + "ERR016 - Invalid number of parameters for function: '" + function_name + "'", exprtk_error_location)); return error_node(); @@ -20900,7 +21176,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR015 - Failed to generate call to function: '" + function_name + "'", + "ERR017 - Failed to generate call to function: '" + function_name + "'", exprtk_error_location)); return error_node(); @@ -20919,7 +21195,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR016 - Expecting ifunction '" + function_name + "' to have non-zero parameter count", + "ERR018 - Expecting ifunction '" + function_name + "' to have non-zero parameter count", exprtk_error_location)); return error_node(); @@ -20942,7 +21218,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR017 - Expecting argument list for function: '" + function_name + "'", + "ERR019 - Expecting argument list for function: '" + function_name + "'", exprtk_error_location)); return error_node(); @@ -20957,7 +21233,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR018 - Failed to parse argument " + details::to_str(i) + " for function: '" + function_name + "'", + "ERR020 - Failed to parse argument " + details::to_str(i) + " for function: '" + function_name + "'", exprtk_error_location)); return error_node(); @@ -20969,7 +21245,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR019 - Invalid number of arguments for function: '" + function_name + "'", + "ERR021 - Invalid number of arguments for function: '" + function_name + "'", exprtk_error_location)); return error_node(); @@ -20982,7 +21258,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR020 - Invalid number of arguments for function: '" + function_name + "'", + "ERR022 - Invalid number of arguments for function: '" + function_name + "'", exprtk_error_location)); return error_node(); @@ -21011,7 +21287,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR021 - Expecting '()' to proceed call to function: '" + function_name + "'", + "ERR023 - Expecting '()' to proceed call to function: '" + function_name + "'", exprtk_error_location)); free_node(node_allocator_,result); @@ -21036,7 +21312,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR022 - Expected a '(' at start of function call to '" + function_name + + "ERR024 - Expected a '(' at start of function call to '" + function_name + "', instead got: '" + current_token().value + "'", exprtk_error_location)); @@ -21048,7 +21324,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR023 - Expected at least one input parameter for function call '" + function_name + "'", + "ERR025 - Expected at least one input parameter for function call '" + function_name + "'", exprtk_error_location)); return 0; @@ -21074,7 +21350,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR024 - Expected a ',' between function input parameters, instead got: '" + current_token().value + "'", + "ERR026 - Expected a ',' between function input parameters, instead got: '" + current_token().value + "'", exprtk_error_location)); return 0; @@ -21086,7 +21362,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR025 - Invalid number of input parameters passed to function '" + function_name + "'", + "ERR027 - Invalid number of input parameters passed to function '" + function_name + "'", exprtk_error_location)); return 0; @@ -21109,7 +21385,7 @@ set_error( make_error(parser_error::e_syntax, diagnostic_token, - "ERR026 - No entry found for base operation: " + operation_name, + "ERR028 - No entry found for base operation: " + operation_name, exprtk_error_location)); return error_node(); @@ -21124,7 +21400,7 @@ { for (base_ops_map_t::iterator itr = itr_range.first; itr != itr_range.second; ++itr) { - details::base_operation_t& operation = itr->second; + const details::base_operation_t& operation = itr->second; if (operation.num_params == parameter_count) { @@ -21156,7 +21432,7 @@ set_error( make_error(parser_error::e_syntax, diagnostic_token, - "ERR027 - Invalid number of input parameters for call to function: '" + operation_name + "'", + "ERR029 - Invalid number of input parameters for call to function: '" + operation_name + "'", exprtk_error_location)); return error_node(); @@ -21176,7 +21452,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR028 - Expected ',' between if-statement condition and consequent", + "ERR030 - Expected ',' between if-statement condition and consequent", exprtk_error_location)); result = false; } @@ -21185,7 +21461,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR029 - Failed to parse consequent for if-statement", + "ERR031 - Failed to parse consequent for if-statement", exprtk_error_location)); result = false; } @@ -21194,7 +21470,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR030 - Expected ',' between if-statement consequent and alternative", + "ERR032 - Expected ',' between if-statement consequent and alternative", exprtk_error_location)); result = false; } @@ -21203,7 +21479,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR031 - Failed to parse alternative for if-statement", + "ERR033 - Failed to parse alternative for if-statement", exprtk_error_location)); result = false; } @@ -21212,7 +21488,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR032 - Expected ')' at the end of if-statement", + "ERR034 - Expected ')' at the end of if-statement", exprtk_error_location)); result = false; } @@ -21228,13 +21504,13 @@ if (consq_is_str && alter_is_str) { return expression_generator_ - .conditional_string(condition,consequent,alternative); + .conditional_string(condition, consequent, alternative); } set_error( make_error(parser_error::e_syntax, current_token(), - "ERR033 - Return types of ternary if-statement differ", + "ERR035 - Return types of ternary if-statement differ", exprtk_error_location)); result = false; @@ -21252,7 +21528,7 @@ } else return expression_generator_ - .conditional(condition,consequent,alternative); + .conditional(condition, consequent, alternative); } inline expression_node_ptr parse_conditional_statement_02(expression_node_ptr condition) @@ -21269,7 +21545,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR034 - Failed to parse body of consequent for if-statement", + "ERR036 - Failed to parse body of consequent for if-statement", exprtk_error_location)); result = false; @@ -21292,7 +21568,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR035 - Expected ';' at the end of the consequent for if-statement", + "ERR037 - Expected ';' at the end of the consequent for if-statement", exprtk_error_location)); result = false; @@ -21303,7 +21579,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR036 - Failed to parse body of consequent for if-statement", + "ERR038 - Failed to parse body of consequent for if-statement", exprtk_error_location)); result = false; @@ -21323,7 +21599,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR037 - Failed to parse body of the 'else' for if-statement", + "ERR039 - Failed to parse body of the 'else' for if-statement", exprtk_error_location)); result = false; @@ -21336,7 +21612,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR038 - Failed to parse body of if-else statement", + "ERR040 - Failed to parse body of if-else statement", exprtk_error_location)); result = false; @@ -21349,7 +21625,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR039 - Expected ';' at the end of the 'else-if' for the if-statement", + "ERR041 - Expected ';' at the end of the 'else-if' for the if-statement", exprtk_error_location)); result = false; @@ -21360,7 +21636,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR040 - Failed to parse body of the 'else' for if-statement", + "ERR042 - Failed to parse body of the 'else' for if-statement", exprtk_error_location)); result = false; @@ -21385,7 +21661,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR041 - Return types of ternary if-statement differ", + "ERR043 - Return types of ternary if-statement differ", exprtk_error_location)); result = false; @@ -21417,7 +21693,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR042 - Expected '(' at start of if-statement, instead got: '" + current_token().value + "'", + "ERR044 - Expected '(' at start of if-statement, instead got: '" + current_token().value + "'", exprtk_error_location)); return error_node(); @@ -21427,7 +21703,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR043 - Failed to parse condition for if-statement", + "ERR045 - Failed to parse condition for if-statement", exprtk_error_location)); return error_node(); @@ -21459,7 +21735,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR044 - Invalid if-statement", + "ERR046 - Invalid if-statement", exprtk_error_location)); free_node(node_allocator_,condition); @@ -21480,7 +21756,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR045 - Encountered invalid condition branch for ternary if-statement", + "ERR047 - Encountered invalid condition branch for ternary if-statement", exprtk_error_location)); return error_node(); @@ -21490,7 +21766,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR046 - Expected '?' after condition of ternary if-statement", + "ERR048 - Expected '?' after condition of ternary if-statement", exprtk_error_location)); result = false; @@ -21500,7 +21776,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR047 - Failed to parse consequent for ternary if-statement", + "ERR049 - Failed to parse consequent for ternary if-statement", exprtk_error_location)); result = false; @@ -21510,7 +21786,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR048 - Expected ':' between ternary if-statement consequent and alternative", + "ERR050 - Expected ':' between ternary if-statement consequent and alternative", exprtk_error_location)); result = false; @@ -21520,7 +21796,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR049 - Failed to parse alternative for ternary if-statement", + "ERR051 - Failed to parse alternative for ternary if-statement", exprtk_error_location)); result = false; @@ -21543,7 +21819,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR050 - Return types of ternary if-statement differ", + "ERR052 - Return types of ternary if-statement differ", exprtk_error_location)); result = false; @@ -21564,6 +21840,22 @@ .conditional(condition, consequent, alternative); } + inline expression_node_ptr parse_not_statement() + { + if (settings_.logic_disabled("not")) + { + set_error( + make_error(parser_error::e_syntax, + current_token(), + "ERR053 - Invalid or disabled logic operation 'not'", + exprtk_error_location)); + + return error_node(); + } + + return parse_base_operation(); + } + inline expression_node_ptr parse_while_loop() { // Parse: [while][(][test expr][)][{][expression][}] @@ -21580,7 +21872,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR051 - Expected '(' at start of while-loop condition statement", + "ERR054 - Expected '(' at start of while-loop condition statement", exprtk_error_location)); return error_node(); @@ -21590,7 +21882,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR052 - Failed to parse condition for while-loop", + "ERR055 - Failed to parse condition for while-loop", exprtk_error_location)); return error_node(); @@ -21600,7 +21892,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR053 - Expected ')' at end of while-loop condition statement", + "ERR056 - Expected ')' at end of while-loop condition statement", exprtk_error_location)); result = false; @@ -21615,7 +21907,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR054 - Failed to parse body of while-loop")); + "ERR057 - Failed to parse body of while-loop")); result = false; } else if (0 == (result_node = expression_generator_.while_loop(condition, @@ -21625,7 +21917,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR055 - Failed to synthesize while-loop", + "ERR058 - Failed to synthesize while-loop", exprtk_error_location)); result = false; @@ -21667,7 +21959,7 @@ } else { - token_t::token_type seperator = token_t::e_eof; + const token_t::token_type seperator = token_t::e_eof; scope_handler sh(*this); @@ -21693,15 +21985,15 @@ break; } - bool is_next_until = peek_token_is(token_t::e_symbol) && - peek_token_is("until"); + const bool is_next_until = peek_token_is(token_t::e_symbol) && + peek_token_is("until"); if (!token_is(seperator) && is_next_until) { set_error( make_error(parser_error::e_syntax, current_token(), - "ERR056 - Expected '" + token_t::to_str(seperator) + "' in body of repeat until loop", + "ERR059 - Expected '" + token_t::to_str(seperator) + "' in body of repeat until loop", exprtk_error_location)); return error_node(); @@ -21725,7 +22017,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR057 - Failed to parse body of repeat until loop", + "ERR060 - Failed to parse body of repeat until loop", exprtk_error_location)); return error_node(); @@ -21739,7 +22031,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR058 - Expected '(' before condition statement of repeat until loop", + "ERR061 - Expected '(' before condition statement of repeat until loop", exprtk_error_location)); free_node(node_allocator_,branch); @@ -21753,7 +22045,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR059 - Failed to parse condition for repeat until loop", + "ERR062 - Failed to parse condition for repeat until loop", exprtk_error_location)); free_node(node_allocator_,branch); @@ -21765,7 +22057,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR060 - Expected ')' after condition of repeat until loop", + "ERR063 - Expected ')' after condition of repeat until loop", exprtk_error_location)); free_node(node_allocator_, branch); @@ -21786,7 +22078,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR061 - Failed to synthesize repeat until loop", + "ERR064 - Failed to synthesize repeat until loop", exprtk_error_location)); free_node(node_allocator_,condition); @@ -21811,7 +22103,6 @@ scope_element* se = 0; bool result = true; - std::string loop_counter_symbol; next_token(); @@ -21822,7 +22113,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR062 - Expected '(' at start of for-loop", + "ERR065 - Expected '(' at start of for-loop", exprtk_error_location)); return error_node(); @@ -21842,7 +22133,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR063 - Expected a variable at the start of initialiser section of for-loop", + "ERR066 - Expected a variable at the start of initialiser section of for-loop", exprtk_error_location)); return error_node(); @@ -21852,13 +22143,13 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR064 - Expected variable assignment of initialiser section of for-loop", + "ERR067 - Expected variable assignment of initialiser section of for-loop", exprtk_error_location)); return error_node(); } - loop_counter_symbol = current_token().value; + const std::string loop_counter_symbol = current_token().value; se = &sem_.get_element(loop_counter_symbol); @@ -21867,7 +22158,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR065 - For-loop variable '" + loop_counter_symbol+ "' is being shadowed by a previous declaration", + "ERR068 - For-loop variable '" + loop_counter_symbol+ "' is being shadowed by a previous declaration", exprtk_error_location)); return error_node(); @@ -21899,7 +22190,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR066 - Failed to add new local variable '" + loop_counter_symbol + "' to SEM", + "ERR069 - Failed to add new local variable '" + loop_counter_symbol + "' to SEM", exprtk_error_location)); sem_.free_element(nse); @@ -21921,7 +22212,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR067 - Failed to parse initialiser of for-loop", + "ERR070 - Failed to parse initialiser of for-loop", exprtk_error_location)); result = false; @@ -21931,7 +22222,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR068 - Expected ';' after initialiser of for-loop", + "ERR071 - Expected ';' after initialiser of for-loop", exprtk_error_location)); result = false; @@ -21945,7 +22236,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR069 - Failed to parse condition of for-loop", + "ERR072 - Failed to parse condition of for-loop", exprtk_error_location)); result = false; @@ -21955,7 +22246,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR070 - Expected ';' after condition section of for-loop", + "ERR073 - Expected ';' after condition section of for-loop", exprtk_error_location)); result = false; @@ -21969,7 +22260,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR071 - Failed to parse incrementor of for-loop", + "ERR074 - Failed to parse incrementor of for-loop", exprtk_error_location)); result = false; @@ -21979,7 +22270,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR072 - Expected ')' after incrementor section of for-loop", + "ERR075 - Expected ')' after incrementor section of for-loop", exprtk_error_location)); result = false; @@ -21995,7 +22286,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR073 - Failed to parse body of for-loop", + "ERR076 - Failed to parse body of for-loop", exprtk_error_location)); result = false; @@ -22009,8 +22300,6 @@ se->ref_count--; } - sem_.cleanup(); - free_node(node_allocator_, initialiser); free_node(node_allocator_, condition); free_node(node_allocator_, incrementor); @@ -22047,7 +22336,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR074 - Expected keyword 'switch'", + "ERR077 - Expected keyword 'switch'", exprtk_error_location)); return error_node(); @@ -22062,7 +22351,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR075 - Expected '{' for call to switch statement", + "ERR078 - Expected '{' for call to switch statement", exprtk_error_location)); return error_node(); @@ -22075,7 +22364,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR076 - Expected either a 'case' or 'default' statement", + "ERR079 - Expected either a 'case' or 'default' statement", exprtk_error_location)); return error_node(); @@ -22092,7 +22381,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR077 - Expected ':' for case of switch statement", + "ERR080 - Expected ':' for case of switch statement", exprtk_error_location)); return error_node(); @@ -22107,7 +22396,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR078 - Expected ';' at end of case for switch statement", + "ERR081 - Expected ';' at end of case for switch statement", exprtk_error_location)); return error_node(); @@ -22133,7 +22422,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR079 - Expected ':' for default of switch statement", + "ERR082 - Expected ':' for default of switch statement", exprtk_error_location)); return error_node(); @@ -22155,7 +22444,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR080 - Expected ';' at end of default for switch statement", + "ERR083 - Expected ';' at end of default for switch statement", exprtk_error_location)); return error_node(); @@ -22171,7 +22460,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR081 - Expected '}' at end of switch statement", + "ERR084 - Expected '}' at end of switch statement", exprtk_error_location)); return error_node(); @@ -22187,14 +22476,13 @@ inline expression_node_ptr parse_multi_switch_statement() { std::vector<expression_node_ptr> arg_list; - expression_node_ptr result = error_node(); if (!details::imatch(current_token().value,"[*]")) { set_error( make_error(parser_error::e_syntax, current_token(), - "ERR082 - Expected token '[*]'", + "ERR085 - Expected token '[*]'", exprtk_error_location)); return error_node(); @@ -22209,7 +22497,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR083 - Expected '{' for call to [*] statement", + "ERR086 - Expected '{' for call to [*] statement", exprtk_error_location)); return error_node(); @@ -22222,7 +22510,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR084 - Expected a 'case' statement for multi-switch", + "ERR087 - Expected a 'case' statement for multi-switch", exprtk_error_location)); return error_node(); @@ -22240,7 +22528,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR085 - Expected ':' for case of [*] statement", + "ERR088 - Expected ':' for case of [*] statement", exprtk_error_location)); return error_node(); @@ -22256,7 +22544,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR086 - Expected ';' at end of case for [*] statement", + "ERR089 - Expected ';' at end of case for [*] statement", exprtk_error_location)); return error_node(); @@ -22270,7 +22558,7 @@ } else { - arg_list.push_back(condition); + arg_list.push_back( condition); arg_list.push_back(consequent); } @@ -22285,13 +22573,13 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR087 - Expected '}' at end of [*] statement", + "ERR090 - Expected '}' at end of [*] statement", exprtk_error_location)); return error_node(); } - result = expression_generator_.multi_switch_statement(arg_list); + const expression_node_ptr result = expression_generator_.multi_switch_statement(arg_list); svd.delete_ptr = (0 == result); @@ -22301,7 +22589,6 @@ inline expression_node_ptr parse_vararg_function() { std::vector<expression_node_ptr> arg_list; - expression_node_ptr result = error_node(); details::operator_type opt_type = details::e_default; const std::string symbol = current_token().value; @@ -22327,7 +22614,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR088 - Unsupported vararg function: " + symbol, + "ERR091 - Unsupported vararg function: " + symbol, exprtk_error_location)); return error_node(); @@ -22335,7 +22622,7 @@ scoped_vec_delete<expression_node_t> sdd((*this),arg_list); - lodge_symbol(symbol,e_st_function); + lodge_symbol(symbol, e_st_function); next_token(); @@ -22344,7 +22631,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR089 - Expected '(' for call to vararg function: " + symbol, + "ERR092 - Expected '(' for call to vararg function: " + symbol, exprtk_error_location)); return error_node(); @@ -22366,14 +22653,14 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR090 - Expected ',' for call to vararg function: " + symbol, + "ERR093 - Expected ',' for call to vararg function: " + symbol, exprtk_error_location)); return error_node(); } } - result = expression_generator_.vararg_function(opt_type,arg_list); + const expression_node_ptr result = expression_generator_.vararg_function(opt_type,arg_list); sdd.delete_ptr = (0 == result); return result; @@ -22387,7 +22674,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR091 - Expected '[' as start of string range definition", + "ERR094 - Expected '[' as start of string range definition", exprtk_error_location)); free_node(node_allocator_,expression); @@ -22415,7 +22702,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR092 - Failed to generate string range node", + "ERR095 - Failed to generate string range node", exprtk_error_location)); free_node(node_allocator_,expression); @@ -22454,7 +22741,7 @@ template <typename Allocator1, typename Allocator2, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node_ptr simplify(Sequence<expression_node_ptr,Allocator1>& expression_list, Sequence<bool,Allocator2>& side_effect_list, const bool specialise_on_final_type = false) @@ -22551,7 +22838,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR093 - Expected '" + token_t::to_str(close_bracket) + "' for call to multi-sequence" + + "ERR096 - Expected '" + token_t::to_str(close_bracket) + "' for call to multi-sequence" + ((!source.empty()) ? std::string(" section of " + source): ""), exprtk_error_location)); @@ -22591,14 +22878,14 @@ if (token_is(close_bracket)) break; - bool is_next_close = peek_token_is(close_bracket); + const bool is_next_close = peek_token_is(close_bracket); if (!token_is(seperator) && is_next_close) { set_error( make_error(parser_error::e_syntax, current_token(), - "ERR094 - Expected '" + details::to_str(seperator) + "' for call to multi-sequence section of " + source, + "ERR097 - Expected '" + details::to_str(seperator) + "' for call to multi-sequence section of " + source, exprtk_error_location)); return error_node(); @@ -22632,7 +22919,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR095 - Expected '[' for start of range", + "ERR098 - Expected '[' for start of range", exprtk_error_location)); return false; @@ -22653,11 +22940,10 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR096 - Failed parse begin section of range", + "ERR099 - Failed parse begin section of range", exprtk_error_location)); return false; - } else if (is_constant_node(r0)) { @@ -22677,7 +22963,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR097 - Range lower bound less than zero! Constraint: r0 >= 0", + "ERR100 - Range lower bound less than zero! Constraint: r0 >= 0", exprtk_error_location)); return false; @@ -22694,7 +22980,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR098 - Expected ':' for break in range", + "ERR101 - Expected ':' for break in range", exprtk_error_location)); rp.free(); @@ -22717,13 +23003,12 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR099 - Failed parse end section of range", + "ERR102 - Failed parse end section of range", exprtk_error_location)); rp.free(); return false; - } else if (is_constant_node(r1)) { @@ -22743,7 +23028,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR100 - Range upper bound less than zero! Constraint: r1 >= 0", + "ERR103 - Range upper bound less than zero! Constraint: r1 >= 0", exprtk_error_location)); return false; @@ -22760,7 +23045,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR101 - Expected ']' for start of range", + "ERR104 - Expected ']' for start of range", exprtk_error_location)); rp.free(); @@ -22781,7 +23066,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR102 - Invalid range, Constraint: r0 <= r1", + "ERR105 - Invalid range, Constraint: r0 <= r1", exprtk_error_location)); return false; @@ -22813,7 +23098,7 @@ { se.active = true; result = se.str_node; - lodge_symbol(symbol,e_st_local_string); + lodge_symbol(symbol, e_st_local_string); } else { @@ -22822,7 +23107,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR103 - Unknown string symbol", + "ERR106 - Unknown string symbol", exprtk_error_location)); return error_node(); @@ -22836,7 +23121,7 @@ result = expression_generator_(const_str_node->str()); } - lodge_symbol(symbol,e_st_string); + lodge_symbol(symbol, e_st_string); } if (peek_token_is(token_t::e_lsqrbracket)) @@ -22936,7 +23221,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR104 - Overflow in range for string: '" + const_str + "'[" + + "ERR107 - Overflow in range for string: '" + const_str + "'[" + (rp.n0_c.first ? details::to_str(static_cast<int>(rp.n0_c.second)) : "?") + ":" + (rp.n1_c.first ? details::to_str(static_cast<int>(rp.n1_c.second)) : "?") + "]", exprtk_error_location)); @@ -22980,7 +23265,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR105 - Symbol '" + symbol+ " not a vector", + "ERR108 - Symbol '" + symbol+ " not a vector", exprtk_error_location)); return error_node(); @@ -23006,7 +23291,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR106 - Failed to parse index for vector: '" + symbol + "'", + "ERR109 - Failed to parse index for vector: '" + symbol + "'", exprtk_error_location)); return error_node(); @@ -23016,7 +23301,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR107 - Expected ']' for index of vector: '" + symbol + "'", + "ERR110 - Expected ']' for index of vector: '" + symbol + "'", exprtk_error_location)); free_node(node_allocator_,index_expr); @@ -23035,7 +23320,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR108 - Index of " + details::to_str(index) + " out of range for " + "ERR111 - Index of " + details::to_str(index) + " out of range for " "vector '" + symbol + "' of size " + details::to_str(vec_size), exprtk_error_location)); @@ -23045,7 +23330,7 @@ } } - return expression_generator_.vector_element(symbol,vec,index_expr); + return expression_generator_.vector_element(symbol, vec, index_expr); } inline expression_node_ptr parse_vararg_function_call(ivararg_function<T>* vararg_function, const std::string& vararg_function_name) @@ -23067,7 +23352,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR109 - Zero parameter call to vararg function: " + "ERR112 - Zero parameter call to vararg function: " + vararg_function_name + " not allowed", exprtk_error_location)); @@ -23092,7 +23377,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR110 - Expected ',' for call to vararg function: " + "ERR113 - Expected ',' for call to vararg function: " + vararg_function_name, exprtk_error_location)); @@ -23106,7 +23391,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR111 - Zero parameter call to vararg function: " + "ERR114 - Zero parameter call to vararg function: " + vararg_function_name + " not allowed", exprtk_error_location)); @@ -23118,7 +23403,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR112 - Invalid number of parameters to call to vararg function: " + "ERR115 - Invalid number of parameters to call to vararg function: " + vararg_function_name + ", require at least " + details::to_str(static_cast<int>(vararg_function->min_num_args())) + " parameters", exprtk_error_location)); @@ -23130,7 +23415,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR113 - Invalid number of parameters to call to vararg function: " + "ERR116 - Invalid number of parameters to call to vararg function: " + vararg_function_name + ", require no more than " + details::to_str(static_cast<int>(vararg_function->max_num_args())) + " parameters", exprtk_error_location)); @@ -23149,34 +23434,54 @@ { public: + enum return_type_t + { + e_overload = ' ', + e_numeric = 'T', + e_string = 'S' + }; + + struct function_prototype_t + { + return_type_t return_type; + std::string param_seq; + }; + typedef parser<T> parser_t; - typedef std::vector<std::string> param_seq_list_t; + typedef std::vector<function_prototype_t> function_definition_list_t; type_checker(parser_t& p, const std::string& func_name, - const std::string& param_seq) + const std::string& func_prototypes, + const return_type_t default_return_type) : invalid_state_(true), parser_(p), - function_name_(func_name) + function_name_(func_name), + default_return_type_(default_return_type) { - split(param_seq); + parse_function_prototypes(func_prototypes); + } + + void set_default_return_type(const std::string& return_type) + { + default_return_type_ = return_type; } bool verify(const std::string& param_seq, std::size_t& pseq_index) { - if (param_seq_list_.empty()) + if (function_definition_list_.empty()) return true; std::vector<std::pair<std::size_t,char> > error_list; - for (std::size_t i = 0; i < param_seq_list_.size(); ++i) + for (std::size_t i = 0; i < function_definition_list_.size(); ++i) { details::char_t diff_value = 0; std::size_t diff_index = 0; - bool result = details::sequence_match(param_seq_list_[i], - param_seq, - diff_index,diff_value); + const bool result = details::sequence_match(function_definition_list_[i].param_seq, + param_seq, + diff_index, diff_value); if (result) { @@ -23184,7 +23489,7 @@ return true; } else - error_list.push_back(std::make_pair(diff_index,diff_value)); + error_list.push_back(std::make_pair(diff_index, diff_value)); } if (1 == error_list.size()) @@ -23193,8 +23498,9 @@ set_error( make_error(parser_error::e_syntax, parser_.current_token(), - "ERR114 - Failed parameter type check for function '" + function_name_ + "', " - "Expected '" + param_seq_list_[0] + "' call set: '" + param_seq +"'", + "ERR117 - Failed parameter type check for function '" + function_name_ + "', " + "Expected '" + function_definition_list_[0].param_seq + + "' call set: '" + param_seq + "'", exprtk_error_location)); } else @@ -23214,8 +23520,9 @@ set_error( make_error(parser_error::e_syntax, parser_.current_token(), - "ERR115 - Failed parameter type check for function '" + function_name_ + "', " - "Best match: '" + param_seq_list_[max_diff_index] + "' call set: '" + param_seq +"'", + "ERR118 - Failed parameter type check for function '" + function_name_ + "', " + "Best match: '" + function_definition_list_[max_diff_index].param_seq + + "' call set: '" + param_seq + "'", exprtk_error_location)); } @@ -23224,12 +23531,17 @@ std::size_t paramseq_count() const { - return param_seq_list_.size(); + return function_definition_list_.size(); } std::string paramseq(const std::size_t& index) const { - return param_seq_list_[index]; + return function_definition_list_[index].param_seq; + } + + return_type_t return_type(const std::size_t& index) const + { + return function_definition_list_[index].return_type; } bool invalid() const @@ -23239,93 +23551,142 @@ bool allow_zero_parameters() const { - return - param_seq_list_.end() != std::find(param_seq_list_.begin(), - param_seq_list_.end(), - "Z"); + + for (std::size_t i = 0; i < function_definition_list_.size(); ++i) + { + if (std::string::npos != function_definition_list_[i].param_seq.find("Z")) + { + return true; + } + } + + return false; } private: - void split(const std::string& s) + std::vector<std::string> split_param_seq(const std::string& param_seq, const details::char_t delimiter = '|') const { - if (s.empty()) - return; + std::string::const_iterator current_begin = param_seq.begin(); + std::string::const_iterator iter = param_seq.begin(); - std::size_t start = 0; - std::size_t end = 0; + std::vector<std::string> result; - param_seq_list_t param_seq_list; + while (iter != param_seq.end()) + { + if (*iter == delimiter) + { + result.push_back(std::string(current_begin, iter)); + current_begin = ++iter; + } + else + ++iter; + } - struct token_validator + if (current_begin != iter) + { + result.push_back(std::string(current_begin, iter)); + } + + return result; + } + + inline bool is_valid_token(std::string param_seq, + function_prototype_t& funcproto) const + { + // Determine return type + funcproto.return_type = default_return_type_; + + if (param_seq.size() > 2) { - static inline bool process(const std::string& str, - std::size_t s, std::size_t e, - param_seq_list_t& psl) + if (':' == param_seq[1]) { - if ( - (e - s) && - (std::string::npos == str.find("?*")) && - (std::string::npos == str.find("**")) - ) - { - const std::string curr_str = str.substr(s, e - s); + // Note: Only overloaded igeneric functions can have return + // type definitions. + if (type_checker::e_overload != default_return_type_) + return false; - if ("Z" == curr_str) - { - psl.push_back(curr_str); - return true; - } - else if (std::string::npos == curr_str.find_first_not_of("STV*?|")) - { - psl.push_back(curr_str); - return true; - } + switch (param_seq[0]) + { + case 'T' : funcproto.return_type = type_checker::e_numeric; + break; + + case 'S' : funcproto.return_type = type_checker::e_string; + break; + + default : return false; } - return false; + param_seq.erase(0,2); } - }; + } - while (std::string::npos != (end = s.find('|',start))) + if ( + (std::string::npos != param_seq.find("?*")) || + (std::string::npos != param_seq.find("**")) + ) { - if (!token_validator::process(s, start, end, param_seq_list)) + return false; + } + else if ( + (std::string::npos == param_seq.find_first_not_of("STV*?|")) || + ("Z" == param_seq) + ) + { + funcproto.param_seq = param_seq; + return true; + } + + return false; + } + + void parse_function_prototypes(const std::string& func_prototypes) + { + if (func_prototypes.empty()) + return; + + std::vector<std::string> param_seq_list = split_param_seq(func_prototypes); + + typedef std::map<std::string,std::size_t> param_seq_map_t; + param_seq_map_t param_seq_map; + + for (std::size_t i = 0; i < param_seq_list.size(); ++i) + { + function_prototype_t func_proto; + + if (!is_valid_token(param_seq_list[i], func_proto)) { invalid_state_ = false; - const std::string err_param_seq = s.substr(start, end - start); - parser_. set_error( make_error(parser_error::e_syntax, parser_.current_token(), - "ERR116 - Invalid parameter sequence of '" + err_param_seq + - "' for function: " + function_name_, + "ERR119 - Invalid parameter sequence of '" + param_seq_list[i] + + "' for function: " + function_name_, exprtk_error_location)); - return; } - else - start = end + 1; - } - if (start < s.size()) - { - if (token_validator::process(s, start, s.size(), param_seq_list)) - param_seq_list_ = param_seq_list; - else + param_seq_map_t::const_iterator seq_itr = param_seq_map.find(param_seq_list[i]); + + if (param_seq_map.end() != seq_itr) { - const std::string err_param_seq = s.substr(start, s.size() - start); + invalid_state_ = false; parser_. set_error( make_error(parser_error::e_syntax, parser_.current_token(), - "ERR117 - Invalid parameter sequence of '" + err_param_seq + - "' for function: " + function_name_, + "ERR120 - Function '" + function_name_ + "' has a parameter sequence conflict between " + + "pseq_idx[" + details::to_str(seq_itr->second) + "] and" + + "pseq_idx[" + details::to_str(i) + "] " + + "param seq: " + param_seq_list[i], exprtk_error_location)); return; } + + function_definition_list_.push_back(func_proto); } } @@ -23335,7 +23696,8 @@ bool invalid_state_; parser_t& parser_; std::string function_name_; - param_seq_list_t param_seq_list_; + const return_type_t default_return_type_; + function_definition_list_t function_definition_list_; }; inline expression_node_ptr parse_generic_function_call(igeneric_function<T>* function, const std::string& function_name) @@ -23348,30 +23710,14 @@ std::string param_type_list; - type_checker tc((*this), function_name, function->parameter_sequence); + type_checker tc((*this), function_name, function->parameter_sequence, type_checker::e_string); if (tc.invalid()) { set_error( make_error(parser_error::e_syntax, current_token(), - "ERR118 - Type checker instantiation failure for generic function: " + function_name, - exprtk_error_location)); - - return error_node(); - } - - if ( - !function->parameter_sequence.empty() && - function->allow_zero_parameters () && - !tc .allow_zero_parameters () - ) - { - set_error( - make_error(parser_error::e_syntax, - current_token(), - "ERR119 - Mismatch in zero parameter condition for generic function: " - + function_name, + "ERR121 - Type checker instantiation failure for generic function: " + function_name, exprtk_error_location)); return error_node(); @@ -23389,7 +23735,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR120 - Zero parameter call to generic function: " + "ERR122 - Zero parameter call to generic function: " + function_name + " not allowed", exprtk_error_location)); @@ -23421,7 +23767,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR121 - Expected ',' for call to generic function: " + function_name, + "ERR123 - Expected ',' for call to generic function: " + function_name, exprtk_error_location)); return error_node(); @@ -23438,7 +23784,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR122 - Zero parameter call to generic function: " + "ERR124 - Zero parameter call to generic function: " + function_name + " not allowed", exprtk_error_location)); @@ -23455,7 +23801,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR123 - Expected ',' for call to generic function: " + function_name, + "ERR125 - Invalid input parameter sequence for call to generic function: " + function_name, exprtk_error_location)); return error_node(); @@ -23475,37 +23821,39 @@ return result; } - #ifndef exprtk_disable_string_capabilities - inline expression_node_ptr parse_string_function_call(igeneric_function<T>* function, const std::string& function_name) + inline bool parse_igeneric_function_params(std::string& param_type_list, + std::vector<expression_node_ptr>& arg_list, + const std::string& function_name, + igeneric_function<T>* function, + const type_checker& tc) { - std::vector<expression_node_ptr> arg_list; - - scoped_vec_delete<expression_node_t> sdd((*this),arg_list); - - next_token(); - - std::string param_type_list; - - type_checker tc((*this), function_name, function->parameter_sequence); - - if ( - (!function->parameter_sequence.empty()) && - (0 == tc.paramseq_count()) - ) - { - return error_node(); - } - if (token_is(token_t::e_lbracket)) { - if (!token_is(token_t::e_rbracket)) + if (token_is(token_t::e_rbracket)) + { + if ( + !function->allow_zero_parameters() && + !tc .allow_zero_parameters() + ) + { + set_error( + make_error(parser_error::e_syntax, + current_token(), + "ERR126 - Zero parameter call to generic function: " + + function_name + " not allowed", + exprtk_error_location)); + + return false; + } + } + else { for ( ; ; ) { expression_node_ptr arg = parse_expression(); if (0 == arg) - return error_node(); + return false; if (is_ivector_node(arg)) param_type_list += 'V'; @@ -23523,13 +23871,44 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR124 - Expected ',' for call to string function: " + function_name, + "ERR127 - Expected ',' for call to string function: " + function_name, exprtk_error_location)); - return error_node(); + return false; } } } + + return true; + } + else + return false; + } + + #ifndef exprtk_disable_string_capabilities + inline expression_node_ptr parse_string_function_call(igeneric_function<T>* function, const std::string& function_name) + { + // Move pass the function name + next_token(); + + std::string param_type_list; + + type_checker tc((*this), function_name, function->parameter_sequence, type_checker::e_string); + + if ( + (!function->parameter_sequence.empty()) && + (0 == tc.paramseq_count()) + ) + { + return error_node(); + } + + std::vector<expression_node_ptr> arg_list; + scoped_vec_delete<expression_node_t> sdd((*this),arg_list); + + if (!parse_igeneric_function_params(param_type_list, arg_list, function_name, function, tc)) + { + return error_node(); } std::size_t param_seq_index = 0; @@ -23539,7 +23918,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR125 - Expected ',' for call to string function: " + function_name, + "ERR128 - Invalid input parameter sequence for call to string function: " + function_name, exprtk_error_location)); return error_node(); @@ -23558,15 +23937,86 @@ return result; } + + inline expression_node_ptr parse_overload_function_call(igeneric_function<T>* function, const std::string& function_name) + { + // Move pass the function name + next_token(); + + std::string param_type_list; + + type_checker tc((*this), function_name, function->parameter_sequence, type_checker::e_overload); + + if ( + (!function->parameter_sequence.empty()) && + (0 == tc.paramseq_count()) + ) + { + return error_node(); + } + + std::vector<expression_node_ptr> arg_list; + scoped_vec_delete<expression_node_t> sdd((*this),arg_list); + + if (!parse_igeneric_function_params(param_type_list, arg_list, function_name, function, tc)) + { + return error_node(); + } + + std::size_t param_seq_index = 0; + + if (!tc.verify(param_type_list, param_seq_index)) + { + set_error( + make_error(parser_error::e_syntax, + current_token(), + "ERR129 - Invalid input parameter sequence for call to overloaded function: " + function_name, + exprtk_error_location)); + + return error_node(); + } + + expression_node_ptr result = error_node(); + + if (type_checker::e_numeric == tc.return_type(param_seq_index)) + { + if (tc.paramseq_count() <= 1) + result = expression_generator_ + .generic_function_call(function, arg_list); + else + result = expression_generator_ + .generic_function_call(function, arg_list, param_seq_index); + } + else if (type_checker::e_string == tc.return_type(param_seq_index)) + { + if (tc.paramseq_count() <= 1) + result = expression_generator_ + .string_function_call(function, arg_list); + else + result = expression_generator_ + .string_function_call(function, arg_list, param_seq_index); + } + else + { + set_error( + make_error(parser_error::e_syntax, + current_token(), + "ERR130 - Invalid return type for call to overloaded function: " + function_name, + exprtk_error_location)); + } + + sdd.delete_ptr = (0 == result); + return result; + } #endif template <typename Type, std::size_t NumberOfParameters> struct parse_special_function_impl { - static inline expression_node_ptr process(parser<Type>& p,const details::operator_type opt_type, const std::string& sf_name) + static inline expression_node_ptr process(parser<Type>& p, const details::operator_type opt_type, const std::string& sf_name) { expression_node_ptr branch[NumberOfParameters]; - expression_node_ptr result = error_node(); + expression_node_ptr result = error_node(); std::fill_n(branch,NumberOfParameters,reinterpret_cast<expression_node_ptr>(0)); @@ -23579,7 +24029,7 @@ p.set_error( make_error(parser_error::e_syntax, p.current_token(), - "ERR126 - Expected '(' for special function '" + sf_name + "'", + "ERR131 - Expected '(' for special function '" + sf_name + "'", exprtk_error_location)); return error_node(); @@ -23600,7 +24050,7 @@ p.set_error( make_error(parser_error::e_syntax, p.current_token(), - "ERR127 - Expected ',' before next parameter of special function '" + sf_name + "'", + "ERR132 - Expected ',' before next parameter of special function '" + sf_name + "'", exprtk_error_location)); return p.error_node(); @@ -23613,7 +24063,7 @@ p.set_error( make_error(parser_error::e_syntax, p.current_token(), - "ERR128 - Invalid number of parameters for special function '" + sf_name + "'", + "ERR133 - Invalid number of parameters for special function '" + sf_name + "'", exprtk_error_location)); return p.error_node(); @@ -23640,7 +24090,7 @@ set_error( make_error(parser_error::e_token, current_token(), - "ERR129 - Invalid special function[1]: " + sf_name, + "ERR134 - Invalid special function[1]: " + sf_name, exprtk_error_location)); return error_node(); @@ -23654,7 +24104,7 @@ set_error( make_error(parser_error::e_token, current_token(), - "ERR130 - Invalid special function[2]: " + sf_name, + "ERR135 - Invalid special function[2]: " + sf_name, exprtk_error_location)); return error_node(); @@ -23686,7 +24136,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR131 - Break call within a break call is not allowed", + "ERR136 - Break call within a break call is not allowed", exprtk_error_location)); return error_node(); @@ -23709,7 +24159,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR132 - Failed to parse return expression for 'break' statement", + "ERR137 - Failed to parse return expression for 'break' statement", exprtk_error_location)); return error_node(); @@ -23719,7 +24169,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR133 - Expected ']' at the completion of break's return expression", + "ERR138 - Expected ']' at the completion of break's return expression", exprtk_error_location)); free_node(node_allocator_,return_expr); @@ -23737,7 +24187,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR134 - Invalid use of 'break', allowed only in the scope of a loop", + "ERR139 - Invalid use of 'break', allowed only in the scope of a loop", exprtk_error_location)); } @@ -23760,7 +24210,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR135 - Invalid use of 'continue', allowed only in the scope of a loop", + "ERR140 - Invalid use of 'continue', allowed only in the scope of a loop", exprtk_error_location)); return error_node(); @@ -23777,7 +24227,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR136 - Expected '[' as part of vector size definition", + "ERR141 - Expected '[' as part of vector size definition", exprtk_error_location)); return error_node(); @@ -23787,7 +24237,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR137 - Failed to determine size of vector '" + vec_name + "'", + "ERR142 - Failed to determine size of vector '" + vec_name + "'", exprtk_error_location)); return error_node(); @@ -23799,26 +24249,29 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR138 - Expected a literal number as size of vector '" + vec_name + "'", + "ERR143 - Expected a literal number as size of vector '" + vec_name + "'", exprtk_error_location)); return error_node(); } - T vector_size = size_expr->value(); + const T vector_size = size_expr->value(); free_node(node_allocator_,size_expr); + const T max_vector_size = T(2000000000.0); + if ( (vector_size <= T(0)) || std::not_equal_to<T>() - (T(0),vector_size - details::numeric::trunc(vector_size)) + (T(0),vector_size - details::numeric::trunc(vector_size)) || + (vector_size > max_vector_size) ) { set_error( make_error(parser_error::e_syntax, current_token(), - "ERR139 - Invalid vector size. Must be an integer greater than zero, size: " + + "ERR144 - Invalid vector size. Must be an integer in the range [0,2e9], size: " + details::to_str(details::numeric::to_int32(vector_size)), exprtk_error_location)); @@ -23838,7 +24291,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR140 - Expected ']' as part of vector size definition", + "ERR145 - Expected ']' as part of vector size definition", exprtk_error_location)); return error_node(); @@ -23850,7 +24303,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR141 - Expected ':=' as part of vector definition", + "ERR146 - Expected ':=' as part of vector definition", exprtk_error_location)); return error_node(); @@ -23864,7 +24317,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR142 - Failed to parse single vector initialiser", + "ERR147 - Failed to parse single vector initialiser", exprtk_error_location)); return error_node(); @@ -23877,7 +24330,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR143 - Expected ']' to close single value vector initialiser", + "ERR148 - Expected ']' to close single value vector initialiser", exprtk_error_location)); return error_node(); @@ -23905,7 +24358,7 @@ // Are we dealing with a user defined vector? else if (symtab_store_.is_vector(current_token().value)) { - lodge_symbol(current_token().value,e_st_vector); + lodge_symbol(current_token().value, e_st_vector); if (0 != (initialiser = parse_expression())) vec_initilizer_list.push_back(initialiser); @@ -23924,7 +24377,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR144 - Expected '{' as part of vector initialiser list", + "ERR149 - Expected '{' as part of vector initialiser list", exprtk_error_location)); return error_node(); @@ -23944,7 +24397,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR145 - Expected '{' as part of vector initialiser list", + "ERR150 - Expected '{' as part of vector initialiser list", exprtk_error_location)); return error_node(); @@ -23955,14 +24408,14 @@ if (token_is(token_t::e_rcrlbracket)) break; - bool is_next_close = peek_token_is(token_t::e_rcrlbracket); + const bool is_next_close = peek_token_is(token_t::e_rcrlbracket); if (!token_is(token_t::e_comma) && is_next_close) { set_error( make_error(parser_error::e_syntax, current_token(), - "ERR146 - Expected ',' between vector initialisers", + "ERR151 - Expected ',' between vector initialisers", exprtk_error_location)); return error_node(); @@ -23974,9 +24427,9 @@ } if ( - !token_is(token_t::e_rbracket ,prsrhlpr_t::e_hold) && - !token_is(token_t::e_rcrlbracket,prsrhlpr_t::e_hold) && - !token_is(token_t::e_rsqrbracket,prsrhlpr_t::e_hold) + !token_is(token_t::e_rbracket , prsrhlpr_t::e_hold) && + !token_is(token_t::e_rcrlbracket, prsrhlpr_t::e_hold) && + !token_is(token_t::e_rsqrbracket, prsrhlpr_t::e_hold) ) { if (!token_is(token_t::e_eof)) @@ -23984,7 +24437,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR147 - Expected ';' at end of vector definition", + "ERR152 - Expected ';' at end of vector definition", exprtk_error_location)); return error_node(); @@ -23996,7 +24449,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR148 - Initialiser list larger than the number of elements in the vector: '" + vec_name + "'", + "ERR153 - Initialiser list larger than the number of elements in the vector: '" + vec_name + "'", exprtk_error_location)); return error_node(); @@ -24016,7 +24469,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR149 - Illegal redefinition of local vector: '" + vec_name + "'", + "ERR154 - Illegal redefinition of local vector: '" + vec_name + "'", exprtk_error_location)); return error_node(); @@ -24050,7 +24503,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR150 - Failed to add new local vector '" + vec_name + "' to SEM", + "ERR155 - Failed to add new local vector '" + vec_name + "' to SEM", exprtk_error_location)); sem_.free_element(nse); @@ -24067,17 +24520,21 @@ state_.activate_side_effect("parse_define_vector_statement()"); - lodge_symbol(vec_name,e_st_local_vector); + lodge_symbol(vec_name, e_st_local_vector); expression_node_ptr result = error_node(); if (null_initialisation) result = expression_generator_(T(0.0)); else if (vec_to_vec_initialiser) + { + expression_node_ptr vec_node = node_allocator_.allocate<vector_node_t>(vec_holder); + result = expression_generator_( details::e_assign, - node_allocator_.allocate<vector_node_t>(vec_holder), + vec_node, vec_initilizer_list[0]); + } else result = node_allocator_ .allocate<details::vector_assignment_node<T> >( @@ -24105,7 +24562,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR151 - Illegal redefinition of local variable: '" + str_name + "'", + "ERR156 - Illegal redefinition of local variable: '" + str_name + "'", exprtk_error_location)); free_node(node_allocator_,initialisation_expression); @@ -24137,7 +24594,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR152 - Failed to add new local string variable '" + str_name + "' to SEM", + "ERR157 - Failed to add new local string variable '" + str_name + "' to SEM", exprtk_error_location)); free_node(node_allocator_,initialisation_expression); @@ -24152,7 +24609,7 @@ exprtk_debug(("parse_define_string_statement() - INFO - Added new local string variable: %s\n",nse.name.c_str())); } - lodge_symbol(str_name,e_st_local_string); + lodge_symbol(str_name, e_st_local_string); state_.activate_side_effect("parse_define_string_statement()"); @@ -24183,7 +24640,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR153 - Illegal variable definition", + "ERR158 - Illegal variable definition", exprtk_error_location)); return error_node(); @@ -24204,7 +24661,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR154 - Expected a symbol for variable definition", + "ERR159 - Expected a symbol for variable definition", exprtk_error_location)); return error_node(); @@ -24214,7 +24671,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR155 - Illegal redefinition of reserved keyword: '" + var_name + "'", + "ERR160 - Illegal redefinition of reserved keyword: '" + var_name + "'", exprtk_error_location)); return error_node(); @@ -24224,7 +24681,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR156 - Illegal redefinition of variable '" + var_name + "'", + "ERR161 - Illegal redefinition of variable '" + var_name + "'", exprtk_error_location)); return error_node(); @@ -24234,7 +24691,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR157 - Illegal redefinition of local variable: '" + var_name + "'", + "ERR162 - Illegal redefinition of local variable: '" + var_name + "'", exprtk_error_location)); return error_node(); @@ -24254,7 +24711,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR158 - Failed to parse initialisation expression", + "ERR163 - Failed to parse initialisation expression", exprtk_error_location)); return error_node(); @@ -24262,9 +24719,9 @@ } if ( - !token_is(token_t::e_rbracket ,prsrhlpr_t::e_hold) && - !token_is(token_t::e_rcrlbracket,prsrhlpr_t::e_hold) && - !token_is(token_t::e_rsqrbracket,prsrhlpr_t::e_hold) + !token_is(token_t::e_rbracket , prsrhlpr_t::e_hold) && + !token_is(token_t::e_rcrlbracket, prsrhlpr_t::e_hold) && + !token_is(token_t::e_rsqrbracket, prsrhlpr_t::e_hold) ) { if (!token_is(token_t::e_eof,prsrhlpr_t::e_hold)) @@ -24272,7 +24729,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR159 - Expected ';' after variable definition", + "ERR164 - Expected ';' after variable definition", exprtk_error_location)); free_node(node_allocator_,initialisation_expression); @@ -24300,7 +24757,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR160 - Illegal redefinition of local variable: '" + var_name + "'", + "ERR165 - Illegal redefinition of local variable: '" + var_name + "'", exprtk_error_location)); free_node(node_allocator_, initialisation_expression); @@ -24332,7 +24789,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR161 - Failed to add new local variable '" + var_name + "' to SEM", + "ERR166 - Failed to add new local variable '" + var_name + "' to SEM", exprtk_error_location)); free_node(node_allocator_, initialisation_expression); @@ -24349,7 +24806,7 @@ state_.activate_side_effect("parse_define_var_statement()"); - lodge_symbol(var_name,e_st_local_variable); + lodge_symbol(var_name, e_st_local_variable); expression_node_ptr branch[2] = {0}; @@ -24369,7 +24826,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR162 - Expected a '{}' for uninitialised var definition", + "ERR167 - Expected a '{}' for uninitialised var definition", exprtk_error_location)); return error_node(); @@ -24379,7 +24836,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR163 - Expected ';' after uninitialised variable definition", + "ERR168 - Expected ';' after uninitialised variable definition", exprtk_error_location)); return error_node(); @@ -24396,7 +24853,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR164 - Illegal redefinition of local variable: '" + var_name + "'", + "ERR169 - Illegal redefinition of local variable: '" + var_name + "'", exprtk_error_location)); return error_node(); @@ -24426,7 +24883,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR165 - Failed to add new local variable '" + var_name + "' to SEM", + "ERR170 - Failed to add new local variable '" + var_name + "' to SEM", exprtk_error_location)); sem_.free_element(nse); @@ -24438,7 +24895,7 @@ nse.name.c_str())); } - lodge_symbol(var_name,e_st_local_variable); + lodge_symbol(var_name, e_st_local_variable); state_.activate_side_effect("parse_uninitialised_var_statement()"); @@ -24459,7 +24916,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR166 - Expected '(' at start of swap statement", + "ERR171 - Expected '(' at start of swap statement", exprtk_error_location)); return error_node(); @@ -24478,7 +24935,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR167 - Expected a symbol for variable or vector element definition", + "ERR172 - Expected a symbol for variable or vector element definition", exprtk_error_location)); return error_node(); @@ -24490,7 +24947,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR168 - First parameter to swap is an invalid vector element: '" + var0_name + "'", + "ERR173 - First parameter to swap is an invalid vector element: '" + var0_name + "'", exprtk_error_location)); return error_node(); @@ -24516,14 +24973,14 @@ variable0 = se.var_node; } - lodge_symbol(var0_name,e_st_variable); + lodge_symbol(var0_name, e_st_variable); if (0 == variable0) { set_error( make_error(parser_error::e_syntax, current_token(), - "ERR169 - First parameter to swap is an invalid variable: '" + var0_name + "'", + "ERR174 - First parameter to swap is an invalid variable: '" + var0_name + "'", exprtk_error_location)); return error_node(); @@ -24537,7 +24994,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR170 - Expected ',' between parameters to swap", + "ERR175 - Expected ',' between parameters to swap", exprtk_error_location)); if (variable0_generated) @@ -24555,7 +25012,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR171 - Expected a symbol for variable or vector element definition", + "ERR176 - Expected a symbol for variable or vector element definition", exprtk_error_location)); if (variable0_generated) @@ -24572,7 +25029,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR172 - Second parameter to swap is an invalid vector element: '" + var1_name + "'", + "ERR177 - Second parameter to swap is an invalid vector element: '" + var1_name + "'", exprtk_error_location)); if (variable0_generated) @@ -24603,14 +25060,14 @@ variable1 = se.var_node; } - lodge_symbol(var1_name,e_st_variable); + lodge_symbol(var1_name, e_st_variable); if (0 == variable1) { set_error( make_error(parser_error::e_syntax, current_token(), - "ERR173 - Second parameter to swap is an invalid variable: '" + var1_name + "'", + "ERR178 - Second parameter to swap is an invalid variable: '" + var1_name + "'", exprtk_error_location)); if (variable0_generated) @@ -24629,7 +25086,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR174 - Expected ')' at end of swap statement", + "ERR179 - Expected ')' at end of swap statement", exprtk_error_location)); if (variable0_generated) @@ -24686,7 +25143,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR175 - Return call within a return call is not allowed", + "ERR180 - Return call within a return call is not allowed", exprtk_error_location)); return error_node(); @@ -24710,7 +25167,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR176 - Expected '[' at start of return statement", + "ERR181 - Expected '[' at start of return statement", exprtk_error_location)); return error_node(); @@ -24733,7 +25190,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR177 - Expected ',' between values during call to return", + "ERR182 - Expected ',' between values during call to return", exprtk_error_location)); return error_node(); @@ -24745,13 +25202,13 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR178 - Zero parameter return statement not allowed", + "ERR183 - Zero parameter return statement not allowed", exprtk_error_location)); return error_node(); } - lexer::token prev_token = current_token(); + const lexer::token prev_token = current_token(); if (token_is(token_t::e_rsqrbracket)) { @@ -24760,7 +25217,7 @@ set_error( make_error(parser_error::e_syntax, prev_token, - "ERR179 - Invalid ']' found during return call", + "ERR184 - Invalid ']' found during return call", exprtk_error_location)); return error_node(); @@ -24813,7 +25270,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR180 - Invalid sequence of variable '"+ symbol + "' and bracket", + "ERR185 - Invalid sequence of variable '"+ symbol + "' and bracket", exprtk_error_location)); return false; @@ -24861,7 +25318,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR181 - Invalid sequence of brackets", + "ERR186 - Invalid sequence of brackets", exprtk_error_location)); return false; @@ -24894,7 +25351,7 @@ if (!post_variable_process(symbol)) return error_node(); - lodge_symbol(symbol,e_st_variable); + lodge_symbol(symbol, e_st_variable); next_token(); return variable; @@ -24910,7 +25367,7 @@ if (scope_element::e_variable == se.type) { se.active = true; - lodge_symbol(symbol,e_st_local_variable); + lodge_symbol(symbol, e_st_local_variable); if (!post_variable_process(symbol)) return error_node(); @@ -24946,7 +25403,7 @@ if (function) { - lodge_symbol(symbol,e_st_function); + lodge_symbol(symbol, e_st_function); expression_node_ptr func_node = parse_function_invocation(function,symbol); @@ -24958,7 +25415,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR182 - Failed to generate node for function: '" + symbol + "'", + "ERR187 - Failed to generate node for function: '" + symbol + "'", exprtk_error_location)); return error_node(); @@ -24972,7 +25429,7 @@ if (vararg_function) { - lodge_symbol(symbol,e_st_function); + lodge_symbol(symbol, e_st_function); expression_node_ptr vararg_func_node = parse_vararg_function_call(vararg_function, symbol); @@ -24984,7 +25441,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR183 - Failed to generate node for vararg function: '" + symbol + "'", + "ERR188 - Failed to generate node for vararg function: '" + symbol + "'", exprtk_error_location)); return error_node(); @@ -24998,7 +25455,7 @@ if (generic_function) { - lodge_symbol(symbol,e_st_function); + lodge_symbol(symbol, e_st_function); expression_node_ptr genericfunc_node = parse_generic_function_call(generic_function, symbol); @@ -25010,7 +25467,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR184 - Failed to generate node for generic function: '" + symbol + "'", + "ERR189 - Failed to generate node for generic function: '" + symbol + "'", exprtk_error_location)); return error_node(); @@ -25025,7 +25482,7 @@ if (string_function) { - lodge_symbol(symbol,e_st_function); + lodge_symbol(symbol, e_st_function); expression_node_ptr stringfunc_node = parse_string_function_call(string_function, symbol); @@ -25037,7 +25494,33 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR185 - Failed to generate node for string function: '" + symbol + "'", + "ERR190 - Failed to generate node for string function: '" + symbol + "'", + exprtk_error_location)); + + return error_node(); + } + } + } + + { + // Are we dealing with a vararg overloaded scalar/string returning function? + igeneric_function<T>* overload_function = symtab_store_.get_overload_function(symbol); + + if (overload_function) + { + lodge_symbol(symbol, e_st_function); + + expression_node_ptr overloadfunc_node = + parse_overload_function_call(overload_function, symbol); + + if (overloadfunc_node) + return overloadfunc_node; + else + { + set_error( + make_error(parser_error::e_syntax, + current_token(), + "ERR191 - Failed to generate node for overload function: '" + symbol + "'", exprtk_error_location)); return error_node(); @@ -25049,7 +25532,7 @@ // Are we dealing with a vector? if (symtab_store_.is_vector(symbol)) { - lodge_symbol(symbol,e_st_vector); + lodge_symbol(symbol, e_st_vector); return parse_vector(); } @@ -25063,7 +25546,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR186 - Invalid use of reserved symbol '" + symbol + "'", + "ERR192 - Invalid use of reserved symbol '" + symbol + "'", exprtk_error_location)); return error_node(); @@ -25083,7 +25566,7 @@ { T default_value = T(0); - typename unknown_symbol_resolver::usr_symbol_type usr_symbol_type; + typename unknown_symbol_resolver::usr_symbol_type usr_symbol_type = unknown_symbol_resolver::e_usr_unknown_type; if (unknown_symbol_resolver_->process(symbol, usr_symbol_type, default_value, error_message)) { @@ -25111,7 +25594,7 @@ var = expression_generator_(var->value()); } - lodge_symbol(symbol,e_st_variable); + lodge_symbol(symbol, e_st_variable); if (!post_variable_process(symbol)) return error_node(); @@ -25126,7 +25609,7 @@ set_error( make_error(parser_error::e_symtab, current_token(), - "ERR187 - Failed to create variable: '" + symbol + "'" + + "ERR193 - Failed to create variable: '" + symbol + "'" + (error_message.empty() ? "" : " - " + error_message), exprtk_error_location)); @@ -25146,7 +25629,7 @@ set_error( make_error(parser_error::e_symtab, current_token(), - "ERR188 - Failed to resolve symbol: '" + symbol + "'" + + "ERR194 - Failed to resolve symbol: '" + symbol + "'" + (error_message.empty() ? "" : " - " + error_message), exprtk_error_location)); } @@ -25158,7 +25641,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR189 - Undefined symbol: '" + symbol + "'", + "ERR195 - Undefined symbol: '" + symbol + "'", exprtk_error_location)); return error_node(); @@ -25177,11 +25660,16 @@ static const std::string symbol_var = "var" ; static const std::string symbol_swap = "swap" ; static const std::string symbol_return = "return" ; + static const std::string symbol_not = "not" ; if (valid_vararg_operation(current_token().value)) { return parse_vararg_function(); } + else if (details::imatch(current_token().value, symbol_not)) + { + return parse_not_statement(); + } else if (valid_base_operation(current_token().value)) { return parse_base_operation(); @@ -25265,7 +25753,7 @@ set_error( make_error(parser_error::e_symtab, current_token(), - "ERR190 - Variable or function detected, yet symbol-table is invalid, Symbol: " + current_token().value, + "ERR196 - Variable or function detected, yet symbol-table is invalid, Symbol: " + current_token().value, exprtk_error_location)); return error_node(); @@ -25289,7 +25777,7 @@ set_error( make_error(parser_error::e_numeric, current_token(), - "ERR191 - Failed generate node for scalar: '" + current_token().value + "'", + "ERR197 - Failed generate node for scalar: '" + current_token().value + "'", exprtk_error_location)); return error_node(); @@ -25303,7 +25791,7 @@ set_error( make_error(parser_error::e_numeric, current_token(), - "ERR192 - Failed to convert '" + current_token().value + "' to a number", + "ERR198 - Failed to convert '" + current_token().value + "' to a number", exprtk_error_location)); return error_node(); @@ -25330,7 +25818,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR193 - Expected ')' instead of: '" + current_token().value + "'", + "ERR199 - Expected ')' instead of: '" + current_token().value + "'", exprtk_error_location)); free_node(node_allocator_,branch); @@ -25355,7 +25843,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR194 - Expected ']' instead of: '" + current_token().value + "'", + "ERR200 - Expected ']' instead of: '" + current_token().value + "'", exprtk_error_location)); free_node(node_allocator_,branch); @@ -25380,7 +25868,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR195 - Expected '}' instead of: '" + current_token().value + "'", + "ERR201 - Expected '}' instead of: '" + current_token().value + "'", exprtk_error_location)); free_node(node_allocator_,branch); @@ -25420,7 +25908,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR196 - Premature end of expression[1]", + "ERR202 - Premature end of expression[1]", exprtk_error_location)); return error_node(); @@ -25430,7 +25918,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR197 - Premature end of expression[2]", + "ERR203 - Premature end of expression[2]", exprtk_error_location)); return error_node(); @@ -25604,7 +26092,7 @@ return true; } - inline details::operator_type get_operator(const binary_functor_t& bop) + inline details::operator_type get_operator(const binary_functor_t& bop) const { return (*inv_binary_op_map_).find(bop)->second; } @@ -25663,9 +26151,9 @@ (details::e_frac == operation) || (details::e_trunc == operation) ; } - inline bool sf3_optimisable(const std::string& sf3id, trinary_functor_t& tfunc) + inline bool sf3_optimisable(const std::string& sf3id, trinary_functor_t& tfunc) const { - typename sf3_map_t::iterator itr = sf3_map_->find(sf3id); + typename sf3_map_t::const_iterator itr = sf3_map_->find(sf3id); if (sf3_map_->end() == itr) return false; @@ -25675,9 +26163,9 @@ return true; } - inline bool sf4_optimisable(const std::string& sf4id, quaternary_functor_t& qfunc) + inline bool sf4_optimisable(const std::string& sf4id, quaternary_functor_t& qfunc) const { - typename sf4_map_t::iterator itr = sf4_map_->find(sf4id); + typename sf4_map_t::const_iterator itr = sf4_map_->find(sf4id); if (sf4_map_->end() == itr) return false; @@ -25687,9 +26175,9 @@ return true; } - inline bool sf3_optimisable(const std::string& sf3id, details::operator_type& operation) + inline bool sf3_optimisable(const std::string& sf3id, details::operator_type& operation) const { - typename sf3_map_t::iterator itr = sf3_map_->find(sf3id); + typename sf3_map_t::const_iterator itr = sf3_map_->find(sf3id); if (sf3_map_->end() == itr) return false; @@ -25699,9 +26187,9 @@ return true; } - inline bool sf4_optimisable(const std::string& sf4id, details::operator_type& operation) + inline bool sf4_optimisable(const std::string& sf4id, details::operator_type& operation) const { - typename sf4_map_t::iterator itr = sf4_map_->find(sf4id); + typename sf4_map_t::const_iterator itr = sf4_map_->find(sf4id); if (sf4_map_->end() == itr) return false; @@ -25829,7 +26317,7 @@ (details::e_xnor == operation) ; } - inline std::string branch_to_id(expression_node_ptr branch) + inline std::string branch_to_id(expression_node_ptr branch) const { static const std::string null_str ("(null)" ); static const std::string const_str ("(c)" ); @@ -25870,7 +26358,7 @@ return "ERROR"; } - inline std::string branch_to_id(expression_node_ptr (&branch)[2]) + inline std::string branch_to_id(expression_node_ptr (&branch)[2]) const { return branch_to_id(branch[0]) + std::string("o") + branch_to_id(branch[1]); } @@ -25988,7 +26476,7 @@ !details::is_constant_node(branch[1]) ; } - inline bool is_invalid_assignment_op(const details::operator_type& operation, expression_node_ptr (&branch)[2]) + inline bool is_invalid_assignment_op(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const { if (is_assignment_operation(operation)) { @@ -26010,14 +26498,14 @@ return false; } - inline bool is_constpow_operation(const details::operator_type& operation, expression_node_ptr(&branch)[2]) + inline bool is_constpow_operation(const details::operator_type& operation, expression_node_ptr(&branch)[2]) const { if ( - !is_constant_node(branch[1]) || - is_constant_node(branch[0]) || - is_variable_node(branch[0]) || - is_vector_node (branch[0]) || - is_generally_string_node(branch[0]) + !details::is_constant_node(branch[1]) || + details::is_constant_node(branch[0]) || + details::is_variable_node(branch[0]) || + details::is_vector_node (branch[0]) || + details::is_generally_string_node(branch[0]) ) return false; @@ -26026,7 +26514,7 @@ return cardinal_pow_optimisable(operation, c); } - inline bool is_invalid_break_continue_op(expression_node_ptr (&branch)[2]) + inline bool is_invalid_break_continue_op(expression_node_ptr (&branch)[2]) const { return ( details::is_break_node (branch[0]) || @@ -26036,7 +26524,7 @@ ); } - inline bool is_invalid_string_op(const details::operator_type& operation, expression_node_ptr (&branch)[2]) + inline bool is_invalid_string_op(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const { const bool b0_string = is_generally_string_node(branch[0]); const bool b1_string = is_generally_string_node(branch[1]); @@ -26056,7 +26544,7 @@ return result; } - inline bool is_invalid_string_op(const details::operator_type& operation, expression_node_ptr (&branch)[3]) + inline bool is_invalid_string_op(const details::operator_type& operation, expression_node_ptr (&branch)[3]) const { const bool b0_string = is_generally_string_node(branch[0]); const bool b1_string = is_generally_string_node(branch[1]); @@ -26077,7 +26565,7 @@ return result; } - inline bool is_string_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) + inline bool is_string_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const { const bool b0_string = is_generally_string_node(branch[0]); const bool b1_string = is_generally_string_node(branch[1]); @@ -26085,7 +26573,7 @@ return (b0_string && b1_string && valid_string_operation(operation)); } - inline bool is_string_operation(const details::operator_type& operation, expression_node_ptr (&branch)[3]) + inline bool is_string_operation(const details::operator_type& operation, expression_node_ptr (&branch)[3]) const { const bool b0_string = is_generally_string_node(branch[0]); const bool b1_string = is_generally_string_node(branch[1]); @@ -26095,7 +26583,7 @@ } #ifndef exprtk_disable_sc_andor - inline bool is_shortcircuit_expression(const details::operator_type& operation) + inline bool is_shortcircuit_expression(const details::operator_type& operation) const { return ( (details::e_scand == operation) || @@ -26103,13 +26591,13 @@ ); } #else - inline bool is_shortcircuit_expression(const details::operator_type&) + inline bool is_shortcircuit_expression(const details::operator_type&) const { return false; } #endif - inline bool is_null_present(expression_node_ptr (&branch)[2]) + inline bool is_null_present(expression_node_ptr (&branch)[2]) const { return ( details::is_null_node(branch[0]) || @@ -26117,7 +26605,7 @@ ); } - inline bool is_vector_eqineq_logic_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) + inline bool is_vector_eqineq_logic_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const { if (!is_ivector_node(branch[0]) && !is_ivector_node(branch[1])) return false; @@ -26139,7 +26627,7 @@ ); } - inline bool is_vector_arithmetic_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) + inline bool is_vector_arithmetic_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const { if (!is_ivector_node(branch[0]) && !is_ivector_node(branch[1])) return false; @@ -26312,15 +26800,19 @@ return (*this)(operation,branch); } - inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr b0, expression_node_ptr b1) + inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr& b0, expression_node_ptr& b1) { - if ((0 == b0) || (0 == b1)) - return error_node(); - else + expression_node_ptr result = error_node(); + + if ((0 != b0) && (0 != b1)) { expression_node_ptr branch[2] = { b0, b1 }; - return expression_generator<Type>::operator()(operation,branch); + result = expression_generator<Type>::operator()(operation, branch); + b0 = branch[0]; + b1 = branch[1]; } + + return result; } inline expression_node_ptr conditional(expression_node_ptr condition, @@ -26514,7 +27006,7 @@ return result; } - else if (details::is_null_node(condition)) + else if (details::is_null_node(condition) || (0 == condition)) { free_node(*node_allocator_, initialiser); free_node(*node_allocator_, condition); @@ -26546,7 +27038,7 @@ } template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node_ptr const_optimise_switch(Sequence<expression_node_ptr,Allocator>& arg_list) { expression_node_ptr result = error_node(); @@ -26582,7 +27074,7 @@ } template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node_ptr const_optimise_mswitch(Sequence<expression_node_ptr,Allocator>& arg_list) { expression_node_ptr result = error_node(); @@ -26707,7 +27199,7 @@ }; template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node_ptr switch_statement(Sequence<expression_node_ptr,Allocator>& arg_list) { if (arg_list.empty()) @@ -26747,7 +27239,7 @@ } template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node_ptr multi_switch_statement(Sequence<expression_node_ptr,Allocator>& arg_list) { if (!all_nodes_valid(arg_list)) @@ -27059,7 +27551,7 @@ } template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node_ptr const_optimise_varargfunc(const details::operator_type& operation, Sequence<expression_node_ptr,Allocator>& arg_list) { expression_node_ptr temp_node = error_node(); @@ -27091,7 +27583,7 @@ return node_allocator_->allocate<literal_node_t>(v); } - inline bool special_one_parameter_vararg(const details::operator_type& operation) + inline bool special_one_parameter_vararg(const details::operator_type& operation) const { return ( (details::e_sum == operation) || @@ -27103,7 +27595,7 @@ } template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node_ptr varnode_optimise_varargfunc(const details::operator_type& operation, Sequence<expression_node_ptr,Allocator>& arg_list) { switch (operation) @@ -27126,7 +27618,7 @@ } template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node_ptr vectorize_func(const details::operator_type& operation, Sequence<expression_node_ptr,Allocator>& arg_list) { if (1 == arg_list.size()) @@ -27151,7 +27643,7 @@ } template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline expression_node_ptr vararg_function(const details::operator_type& operation, Sequence<expression_node_ptr,Allocator>& arg_list) { if (!all_nodes_valid(arg_list)) @@ -27513,7 +28005,7 @@ template <typename NodePtr, typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline bool is_constant_foldable(const Sequence<NodePtr,Allocator>& b) const { for (std::size_t i = 0; i < b.size(); ++i) @@ -27659,6 +28151,8 @@ } else if (details::is_vector_elem_node(branch[0])) { + lodge_assignment(e_st_vecelem,branch[0]); + switch (operation) { #define case_stmt(op0,op1) \ @@ -27677,6 +28171,8 @@ } else if (details::is_rebasevector_elem_node(branch[0])) { + lodge_assignment(e_st_vecelem,branch[0]); + switch (operation) { #define case_stmt(op0,op1) \ @@ -27695,6 +28191,8 @@ } else if (details::is_rebasevector_celem_node(branch[0])) { + lodge_assignment(e_st_vecelem,branch[0]); + switch (operation) { #define case_stmt(op0,op1) \ @@ -28045,7 +28543,7 @@ case_stmt(details::e_xnor, details::xnor_op) \ #ifndef exprtk_disable_cardinal_pow_optimisation - template <typename TType, template <typename,typename> class IPowNode> + template <typename TType, template <typename, typename> class IPowNode> inline expression_node_ptr cardinal_pow_optimisation_impl(const TType& v, const unsigned int& p) { switch (p) @@ -28095,7 +28593,7 @@ } } - inline bool cardinal_pow_optimisable(const details::operator_type& operation, const T& c) + inline bool cardinal_pow_optimisable(const details::operator_type& operation, const T& c) const { return (details::e_pow == operation) && (details::numeric::abs(c) <= T(60)) && details::numeric::is_integer(c); } @@ -28299,8 +28797,9 @@ { expression_node_ptr result = error_node(); - const bool synthesis_result = synthesize_sf4ext_expression::template compile_right<vtype> - (expr_gen, v, operation, branch[1], result); + const bool synthesis_result = + synthesize_sf4ext_expression::template compile_right<vtype> + (expr_gen, v, operation, branch[1], result); if (synthesis_result) { @@ -28373,8 +28872,9 @@ { expression_node_ptr result = error_node(); - const bool synthesis_result = synthesize_sf4ext_expression::template compile_left<vtype> - (expr_gen, v, operation, branch[0], result); + const bool synthesis_result = + synthesize_sf4ext_expression::template compile_left<vtype> + (expr_gen, v, operation, branch[0], result); if (synthesis_result) { @@ -28555,7 +29055,11 @@ { expression_node_ptr result = error_node(); - if (synthesize_sf4ext_expression::template compile_right<ctype>(expr_gen,c,operation,branch[1],result)) + const bool synthesis_result = + synthesize_sf4ext_expression::template compile_right<ctype> + (expr_gen, c, operation, branch[1], result); + + if (synthesis_result) { free_node(*expr_gen.node_allocator_,branch[1]); @@ -28670,8 +29174,9 @@ { expression_node_ptr result = error_node(); - const bool synthesis_result = synthesize_sf4ext_expression::template compile_left<ctype> - (expr_gen, c, operation, branch[0], result); + const bool synthesis_result = + synthesize_sf4ext_expression::template compile_left<ctype> + (expr_gen, c, operation, branch[0], result); if (synthesis_result) { @@ -29221,7 +29726,8 @@ if (!expr_gen.sf3_optimisable(id,sf3opr)) return false; else - result = synthesize_sf3ext_expression::template process<T0,T1,T2>(expr_gen,sf3opr,t0,t1,t2); + result = synthesize_sf3ext_expression::template process<T0, T1, T2> + (expr_gen, sf3opr, t0, t1, t2); return true; } @@ -29288,7 +29794,7 @@ if (!expr_gen.sf4_optimisable(id,sf4opr)) return false; else - result = synthesize_sf4ext_expression::template process<T0,T1,T2,T3> + result = synthesize_sf4ext_expression::template process<T0, T1, T2, T3> (expr_gen, sf4opr, t0, t1, t2, t3); return true; @@ -29308,28 +29814,28 @@ typedef details::T0oT1oT2_base_node<Type>* sf3ext_base_ptr; sf3ext_base_ptr n = static_cast<sf3ext_base_ptr>(sf3node); - std::string id = "t" + expr_gen.to_str(operation) + "(" + n->type_id() + ")"; + const std::string id = "t" + expr_gen.to_str(operation) + "(" + n->type_id() + ")"; switch (n->type()) { case details::expression_node<Type>::e_covoc : return compile_right_impl - <typename covoc_t::sf3_type_node,ExternalType,ctype,vtype,ctype> + <typename covoc_t::sf3_type_node,ExternalType, ctype, vtype, ctype> (expr_gen, id, t, sf3node, result); case details::expression_node<Type>::e_covov : return compile_right_impl - <typename covov_t::sf3_type_node,ExternalType,ctype,vtype,vtype> + <typename covov_t::sf3_type_node,ExternalType, ctype, vtype, vtype> (expr_gen, id, t, sf3node, result); case details::expression_node<Type>::e_vocov : return compile_right_impl - <typename vocov_t::sf3_type_node,ExternalType,vtype,ctype,vtype> + <typename vocov_t::sf3_type_node,ExternalType, vtype, ctype, vtype> (expr_gen, id, t, sf3node, result); case details::expression_node<Type>::e_vovoc : return compile_right_impl - <typename vovoc_t::sf3_type_node,ExternalType,vtype,vtype,ctype> + <typename vovoc_t::sf3_type_node,ExternalType, vtype, vtype, ctype> (expr_gen, id, t, sf3node, result); case details::expression_node<Type>::e_vovov : return compile_right_impl - <typename vovov_t::sf3_type_node,ExternalType,vtype,vtype,vtype> + <typename vovov_t::sf3_type_node,ExternalType, vtype, vtype, vtype> (expr_gen, id, t, sf3node, result); default : return false; @@ -29351,28 +29857,28 @@ sf3ext_base_ptr n = static_cast<sf3ext_base_ptr>(sf3node); - std::string id = "(" + n->type_id() + ")" + expr_gen.to_str(operation) + "t"; + const std::string id = "(" + n->type_id() + ")" + expr_gen.to_str(operation) + "t"; switch (n->type()) { case details::expression_node<Type>::e_covoc : return compile_left_impl - <typename covoc_t::sf3_type_node,ExternalType,ctype,vtype,ctype> + <typename covoc_t::sf3_type_node,ExternalType, ctype, vtype, ctype> (expr_gen, id, t, sf3node, result); case details::expression_node<Type>::e_covov : return compile_left_impl - <typename covov_t::sf3_type_node,ExternalType,ctype,vtype,vtype> + <typename covov_t::sf3_type_node,ExternalType, ctype, vtype, vtype> (expr_gen, id, t, sf3node, result); case details::expression_node<Type>::e_vocov : return compile_left_impl - <typename vocov_t::sf3_type_node,ExternalType,vtype,ctype,vtype> + <typename vocov_t::sf3_type_node,ExternalType, vtype, ctype, vtype> (expr_gen, id, t, sf3node, result); case details::expression_node<Type>::e_vovoc : return compile_left_impl - <typename vovoc_t::sf3_type_node,ExternalType,vtype,vtype,ctype> + <typename vovoc_t::sf3_type_node,ExternalType, vtype, vtype, ctype> (expr_gen, id, t, sf3node, result); case details::expression_node<Type>::e_vovov : return compile_left_impl - <typename vovov_t::sf3_type_node,ExternalType,vtype,vtype,vtype> + <typename vovov_t::sf3_type_node,ExternalType, vtype, vtype, vtype> (expr_gen, id, t, sf3node, result); default : return false; @@ -29394,7 +29900,7 @@ T1 t1 = n->t1(); T2 t2 = n->t2(); - return synthesize_sf4ext_expression::template compile<ExternalType,T0,T1,T2> + return synthesize_sf4ext_expression::template compile<ExternalType, T0, T1, T2> (expr_gen, id, t, t0, t1, t2, result); } else @@ -29416,7 +29922,7 @@ T1 t1 = n->t1(); T2 t2 = n->t2(); - return synthesize_sf4ext_expression::template compile<T0,T1,T2,ExternalType> + return synthesize_sf4ext_expression::template compile<T0, T1, T2, ExternalType> (expr_gen, id, t0, t1, t2, t, result); } else @@ -29480,7 +29986,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t"; } }; @@ -29540,7 +30049,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)"; } }; @@ -29601,7 +30113,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t"; } }; @@ -29661,7 +30176,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)"; } }; @@ -29721,7 +30239,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t"; } }; @@ -29781,7 +30302,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)"; } }; @@ -29841,7 +30365,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t"; } }; @@ -29901,7 +30428,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)"; } }; @@ -30000,7 +30530,7 @@ const bool synthesis_result = synthesize_sf3ext_expression::template compile<ctype, vtype, ctype> - (expr_gen, id(expr_gen, o0, o1), c0, v, c1,result); + (expr_gen, id(expr_gen, o0, o1), c0, v, c1, result); if (synthesis_result) return result; @@ -30015,7 +30545,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t"; } }; @@ -30129,7 +30662,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)"; } }; @@ -30252,7 +30788,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)"; } }; @@ -30374,7 +30913,10 @@ static inline std::string id(expression_generator<Type>& expr_gen, const details::operator_type o0, const details::operator_type o1) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t"; } }; @@ -30484,7 +31026,7 @@ const bool synthesis_result = synthesize_sf4ext_expression::template compile<T0, T1, T2, T3> - (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3,result); + (expr_gen, id(expr_gen, o0, o1, o2), v0, v1, v2, v3, result); if (synthesis_result) return result; @@ -30503,7 +31045,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t)"; } }; @@ -30587,7 +31133,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t)"; } }; @@ -30671,7 +31221,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t)"; } }; @@ -30755,7 +31309,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t)"; } }; @@ -30839,7 +31397,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t)"; } }; @@ -31028,7 +31590,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t)"; } }; @@ -31267,7 +31833,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t)"; } }; @@ -31456,7 +32026,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t)"; } }; @@ -31644,7 +32218,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t)"; } }; @@ -31696,7 +32274,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t))"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t))"; } }; @@ -31752,7 +32334,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t))"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t))"; } }; @@ -31808,7 +32394,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t))"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t))"; } }; @@ -31864,7 +32454,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t))"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t))"; } }; @@ -31921,7 +32515,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t))"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t))"; } }; @@ -31978,7 +32576,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t))"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t))"; } }; @@ -32034,7 +32636,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t))"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t))"; } }; @@ -32090,7 +32696,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t))"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t))"; } }; @@ -32146,7 +32756,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "(t" << expr_gen.to_str(o2) << "t))"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "(t" << expr_gen.to_str(o2) + << "t))"; } }; @@ -32202,7 +32816,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "((t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "((t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t)"; } }; @@ -32258,7 +32876,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "((t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "((t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t)"; } }; @@ -32314,7 +32936,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "((t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "((t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t)"; } }; @@ -32370,7 +32996,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "((t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "((t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t)"; } }; @@ -32427,7 +33057,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "((t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "((t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t)"; } }; @@ -32484,7 +33118,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "((t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "((t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t)"; } }; @@ -32540,7 +33178,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "((t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "((t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t)"; } }; @@ -32597,7 +33239,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "t" << expr_gen.to_str(o0) << "((t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t)"); + return details::build_string() + << "t" << expr_gen.to_str(o0) + << "((t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t)"; } }; @@ -32670,7 +33316,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "((t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "((t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -32727,7 +33377,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "((t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "((t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -32783,7 +33437,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "((t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "((t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -32839,7 +33497,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "((t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "((t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -32895,7 +33557,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "((t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "((t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -32951,7 +33617,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "((t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "((t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33008,7 +33678,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "((t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "((t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33065,7 +33739,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "((t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "((t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33121,7 +33799,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "((t" << expr_gen.to_str(o0) << "t)" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "((t" << expr_gen.to_str(o0) + << "t)" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33177,7 +33859,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33234,7 +33920,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33290,7 +33980,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33345,7 +34039,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33401,7 +34099,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33457,7 +34159,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33514,7 +34220,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33571,7 +34281,11 @@ const details::operator_type o1, const details::operator_type o2) { - return (details::build_string() << "(t" << expr_gen.to_str(o0) << "(t" << expr_gen.to_str(o1) << "t)" << expr_gen.to_str(o2) << "t"); + return details::build_string() + << "(t" << expr_gen.to_str(o0) + << "(t" << expr_gen.to_str(o1) + << "t)" << expr_gen.to_str(o2) + << "t"; } }; @@ -33938,8 +34652,8 @@ { const std::string s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str (); std::string& s1 = static_cast<details::string_range_node<Type>*> (branch[1])->ref (); - range_t rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range(); - range_t rp1 = static_cast<details::string_range_node<Type>*> (branch[1])->range(); + const range_t rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range(); + const range_t rp1 = static_cast<details::string_range_node<Type>*> (branch[1])->range(); static_cast<details::const_string_range_node<Type>*>(branch[0])->range_ref().clear(); static_cast<details::string_range_node<Type>*> (branch[1])->range_ref().clear(); @@ -33952,9 +34666,9 @@ inline expression_node_ptr synthesize_csrocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) { - std::string s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str (); + const std::string s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str (); const std::string s1 = static_cast<details::string_literal_node<Type>*> (branch[1])->str (); - range_t rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range(); + const range_t rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range(); static_cast<details::const_string_range_node<Type>*>(branch[0])->range_ref().clear(); @@ -33965,10 +34679,10 @@ inline expression_node_ptr synthesize_csrocsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) { - std::string s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str (); - std::string s1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->str (); - range_t rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range(); - range_t rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range(); + const std::string s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str (); + const std::string s1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->str (); + const range_t rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range(); + const range_t rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range(); static_cast<details::const_string_range_node<Type>*>(branch[0])->range_ref().clear(); static_cast<details::const_string_range_node<Type>*>(branch[1])->range_ref().clear(); @@ -34118,9 +34832,9 @@ std::string& s1 = static_cast<details::stringvar_node<Type>*>(branch[1])->ref(); std::string& s2 = static_cast<details::stringvar_node<Type>*>(branch[2])->ref(); - typedef typename details::sosos_node<Type,std::string&,std::string&,std::string&,details::inrange_op<Type> > inrange_t; + typedef typename details::sosos_node<Type, std::string&, std::string&, std::string&, details::inrange_op<Type> > inrange_t; - return node_allocator_->allocate_type<inrange_t,std::string&,std::string&,std::string&>(s0,s1,s2); + return node_allocator_->allocate_type<inrange_t, std::string&, std::string&, std::string&>(s0, s1, s2); } else if ( details::is_const_string_node(branch[0]) && @@ -34132,12 +34846,12 @@ std::string& s1 = static_cast< details::stringvar_node<Type>*>(branch[1])->ref(); std::string s2 = static_cast<details::string_literal_node<Type>*>(branch[2])->str(); - typedef typename details::sosos_node<Type,std::string,std::string&,std::string,details::inrange_op<Type> > inrange_t; + typedef typename details::sosos_node<Type, std::string, std::string&, std::string, details::inrange_op<Type> > inrange_t; details::free_node(*node_allocator_,branch[0]); details::free_node(*node_allocator_,branch[2]); - return node_allocator_->allocate_type<inrange_t,std::string,std::string&,std::string>(s0,s1,s2); + return node_allocator_->allocate_type<inrange_t, std::string, std::string&, std::string>(s0, s1, s2); } else if ( details::is_string_node(branch[0]) && @@ -34149,11 +34863,11 @@ std::string s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str(); std::string& s2 = static_cast< details::stringvar_node<Type>*>(branch[2])->ref(); - typedef typename details::sosos_node<Type,std::string&,std::string,std::string&,details::inrange_op<Type> > inrange_t; + typedef typename details::sosos_node<Type, std::string&, std::string, std::string&, details::inrange_op<Type> > inrange_t; details::free_node(*node_allocator_,branch[1]); - return node_allocator_->allocate_type<inrange_t,std::string&,std::string,std::string&>(s0,s1,s2); + return node_allocator_->allocate_type<inrange_t, std::string&, std::string, std::string&>(s0, s1, s2); } else if ( details::is_string_node(branch[0]) && @@ -34165,11 +34879,11 @@ std::string& s1 = static_cast< details::stringvar_node<Type>*>(branch[1])->ref(); std::string s2 = static_cast<details::string_literal_node<Type>*>(branch[2])->str(); - typedef typename details::sosos_node<Type,std::string&,std::string&,std::string,details::inrange_op<Type> > inrange_t; + typedef typename details::sosos_node<Type, std::string&, std::string&, std::string, details::inrange_op<Type> > inrange_t; details::free_node(*node_allocator_,branch[2]); - return node_allocator_->allocate_type<inrange_t,std::string&,std::string&,std::string>(s0,s1,s2); + return node_allocator_->allocate_type<inrange_t, std::string&, std::string&, std::string>(s0, s1, s2); } else if ( details::is_const_string_node(branch[0]) && @@ -34181,11 +34895,11 @@ std::string& s1 = static_cast< details::stringvar_node<Type>*>(branch[1])->ref(); std::string& s2 = static_cast< details::stringvar_node<Type>*>(branch[2])->ref(); - typedef typename details::sosos_node<Type,std::string,std::string&,std::string&,details::inrange_op<Type> > inrange_t; + typedef typename details::sosos_node<Type, std::string, std::string&, std::string&, details::inrange_op<Type> > inrange_t; details::free_node(*node_allocator_,branch[0]); - return node_allocator_->allocate_type<inrange_t,std::string,std::string&,std::string&>(s0,s1,s2); + return node_allocator_->allocate_type<inrange_t, std::string, std::string&, std::string&>(s0, s1, s2); } else return error_node(); @@ -34213,8 +34927,8 @@ typedef typename details::null_eq_node<T> nulleq_node_t; - bool b0_null = details::is_null_node(branch[0]); - bool b1_null = details::is_null_node(branch[1]); + const bool b0_null = details::is_null_node(branch[0]); + const bool b1_null = details::is_null_node(branch[1]); if (b0_null && b1_null) { @@ -34319,7 +35033,7 @@ if (is_constant_foldable<N>(branch)) { - Type v = expression_point->value(); + const Type v = expression_point->value(); details::free_node(*node_allocator_,expression_point); return node_allocator_->allocate<literal_node_t>(v); @@ -34685,48 +35399,123 @@ lexer::helper::helper_assembly helper_assembly_; - lexer::helper::commutative_inserter commutative_inserter_; - lexer::helper::operator_joiner operator_joiner_2_; - lexer::helper::operator_joiner operator_joiner_3_; - lexer::helper::symbol_replacer symbol_replacer_; - lexer::helper::bracket_checker bracket_checker_; - lexer::helper::numeric_checker numeric_checker_; - lexer::helper::sequence_validator sequence_validator_; + lexer::helper::commutative_inserter commutative_inserter_; + lexer::helper::operator_joiner operator_joiner_2_; + lexer::helper::operator_joiner operator_joiner_3_; + lexer::helper::symbol_replacer symbol_replacer_; + lexer::helper::bracket_checker bracket_checker_; + lexer::helper::numeric_checker numeric_checker_; + lexer::helper::sequence_validator sequence_validator_; + lexer::helper::sequence_validator_3tokens sequence_validator_3tkns_; template <typename ParserType> friend void details::disable_type_checking(ParserType& p); }; + namespace details + { + template <typename T> + struct collector_helper + { + typedef exprtk::symbol_table<T> symbol_table_t; + typedef exprtk::expression<T> expression_t; + typedef exprtk::parser<T> parser_t; + typedef typename parser_t::dependent_entity_collector::symbol_t symbol_t; + typedef typename parser_t::unknown_symbol_resolver usr_t; + + struct resolve_as_vector : public parser_t::unknown_symbol_resolver + { + typedef exprtk::parser<T> parser_t; + + resolve_as_vector() + : usr_t(usr_t::e_usrmode_extended) + {} + + virtual bool process(const std::string& unknown_symbol, + symbol_table_t& symbol_table, + std::string&) + { + static T v[1]; + symbol_table.add_vector(unknown_symbol,v); + return true; + } + }; + + static inline bool collection_pass(const std::string& expression_string, + std::set<std::string>& symbol_set, + const bool collect_variables, + const bool collect_functions, + const bool vector_pass, + symbol_table_t& ext_symbol_table) + { + symbol_table_t symbol_table; + expression_t expression; + parser_t parser; + + resolve_as_vector vect_resolver; + + expression.register_symbol_table(symbol_table ); + expression.register_symbol_table(ext_symbol_table); + + if (vector_pass) + parser.enable_unknown_symbol_resolver(&vect_resolver); + else + parser.enable_unknown_symbol_resolver(); + + if (collect_variables) + parser.dec().collect_variables() = true; + + if (collect_functions) + parser.dec().collect_functions() = true; + + bool pass_result = false; + + details::disable_type_checking(parser); + + if (parser.compile(expression_string, expression)) + { + pass_result = true; + + std::deque<symbol_t> symb_list; + parser.dec().symbols(symb_list); + + for (std::size_t i = 0; i < symb_list.size(); ++i) + { + symbol_set.insert(symb_list[i].first); + } + } + + return pass_result; + } + }; + } + template <typename Allocator, template <typename, typename> class Sequence> - inline bool collect_variables(const std::string& expr_str, + inline bool collect_variables(const std::string& expression, Sequence<std::string, Allocator>& symbol_list) { typedef double T; - typedef exprtk::symbol_table<T> symbol_table_t; - typedef exprtk::expression<T> expression_t; - typedef exprtk::parser<T> parser_t; - typedef parser_t::dependent_entity_collector::symbol_t symbol_t; + typedef details::collector_helper<T> collect_t; - symbol_table_t symbol_table; - expression_t expression; - parser_t parser; + collect_t::symbol_table_t null_symbol_table; - expression.register_symbol_table(symbol_table); + std::set<std::string> symbol_set; - parser.enable_unknown_symbol_resolver(); - parser.dec().collect_variables() = true; + const bool variable_pass = collect_t::collection_pass + (expression, symbol_set, true, false, false, null_symbol_table); + const bool vector_pass = collect_t::collection_pass + (expression, symbol_set, true, false, true, null_symbol_table); - if (!parser.compile(expr_str, expression)) + if (!variable_pass && !vector_pass) return false; - std::deque<symbol_t> symb_list; + std::set<std::string>::iterator itr = symbol_set.begin(); - parser.dec().symbols(symb_list); - - for (std::size_t i = 0; i < symb_list.size(); ++i) + while (symbol_set.end() != itr) { - symbol_list.push_back(symb_list[i].first); + symbol_list.push_back(*itr); + ++itr; } return true; @@ -34735,37 +35524,28 @@ template <typename T, typename Allocator, template <typename, typename> class Sequence> - inline bool collect_variables(const std::string& expr_str, + inline bool collect_variables(const std::string& expression, exprtk::symbol_table<T>& extrnl_symbol_table, Sequence<std::string, Allocator>& symbol_list) { - typedef exprtk::symbol_table<T> symbol_table_t; - typedef exprtk::expression<T> expression_t; - typedef exprtk::parser<T> parser_t; - typedef typename parser_t::dependent_entity_collector::symbol_t symbol_t; + typedef details::collector_helper<T> collect_t; - symbol_table_t symbol_table; - expression_t expression; - parser_t parser; + std::set<std::string> symbol_set; - expression.register_symbol_table(symbol_table); - expression.register_symbol_table(extrnl_symbol_table); + const bool variable_pass = collect_t::collection_pass + (expression, symbol_set, true, false, false, extrnl_symbol_table); + const bool vector_pass = collect_t::collection_pass + (expression, symbol_set, true, false, true, extrnl_symbol_table); - parser.enable_unknown_symbol_resolver(); - parser.dec().collect_variables() = true; - - details::disable_type_checking(parser); - - if (!parser.compile(expr_str, expression)) + if (!variable_pass && !vector_pass) return false; - std::deque<symbol_t> symb_list; + std::set<std::string>::iterator itr = symbol_set.begin(); - parser.dec().symbols(symb_list); - - for (std::size_t i = 0; i < symb_list.size(); ++i) + while (symbol_set.end() != itr) { - symbol_list.push_back(symb_list[i].first); + symbol_list.push_back(*itr); + ++itr; } return true; @@ -34773,34 +35553,30 @@ template <typename Allocator, template <typename, typename> class Sequence> - inline bool collect_functions(const std::string& expr_str, + inline bool collect_functions(const std::string& expression, Sequence<std::string, Allocator>& symbol_list) { typedef double T; - typedef exprtk::symbol_table<T> symbol_table_t; - typedef exprtk::expression<T> expression_t; - typedef exprtk::parser<T> parser_t; - typedef parser_t::dependent_entity_collector::symbol_t symbol_t; + typedef details::collector_helper<T> collect_t; - symbol_table_t symbol_table; - expression_t expression; - parser_t parser; + collect_t::symbol_table_t null_symbol_table; - expression.register_symbol_table(symbol_table); + std::set<std::string> symbol_set; - parser.enable_unknown_symbol_resolver(); - parser.dec().collect_functions() = true; + const bool variable_pass = collect_t::collection_pass + (expression, symbol_set, false, true, false, null_symbol_table); + const bool vector_pass = collect_t::collection_pass + (expression, symbol_set, false, true, true, null_symbol_table); - if (!parser.compile(expr_str, expression)) + if (!variable_pass && !vector_pass) return false; - std::deque<symbol_t> symb_list; + std::set<std::string>::iterator itr = symbol_set.begin(); - parser.dec().symbols(symb_list); - - for (std::size_t i = 0; i < symb_list.size(); ++i) + while (symbol_set.end() != itr) { - symbol_list.push_back(symb_list[i].first); + symbol_list.push_back(*itr); + ++itr; } return true; @@ -34809,37 +35585,28 @@ template <typename T, typename Allocator, template <typename, typename> class Sequence> - inline bool collect_functions(const std::string& expr_str, + inline bool collect_functions(const std::string& expression, exprtk::symbol_table<T>& extrnl_symbol_table, Sequence<std::string, Allocator>& symbol_list) { - typedef exprtk::symbol_table<T> symbol_table_t; - typedef exprtk::expression<T> expression_t; - typedef exprtk::parser<T> parser_t; - typedef typename parser_t::dependent_entity_collector::symbol_t symbol_t; + typedef details::collector_helper<T> collect_t; - symbol_table_t symbol_table; - expression_t expression; - parser_t parser; + std::set<std::string> symbol_set; - expression.register_symbol_table(symbol_table); - expression.register_symbol_table(extrnl_symbol_table); + const bool variable_pass = collect_t::collection_pass + (expression, symbol_set, false, true, false, extrnl_symbol_table); + const bool vector_pass = collect_t::collection_pass + (expression, symbol_set, false, true, true, extrnl_symbol_table); - parser.enable_unknown_symbol_resolver(); - parser.dec().collect_functions() = true; - - details::disable_type_checking(parser); - - if (!parser.compile(expr_str, expression)) + if (!variable_pass && !vector_pass) return false; - std::deque<symbol_t> symb_list; + std::set<std::string>::iterator itr = symbol_set.begin(); - parser.dec().symbols(symb_list); - - for (std::size_t i = 0; i < symb_list.size(); ++i) + while (symbol_set.end() != itr) { - symbol_list.push_back(symb_list[i].first); + symbol_list.push_back(*itr); + ++itr; } return true; @@ -34886,7 +35653,7 @@ { T& x = var->ref(); T x_original = x; - T result = integrate(e,x,r0,r1,number_of_intervals); + T result = integrate(e, x, r0, r1, number_of_intervals); x = x_original; return result; @@ -34977,7 +35744,7 @@ { T& x = var->ref(); T x_original = x; - T result = derivative(e,x,h); + T result = derivative(e, x, h); x = x_original; return result; @@ -35004,7 +35771,7 @@ { T& x = var->ref(); const T x_original = x; - const T result = second_derivative(e,x,h); + const T result = second_derivative(e, x, h); x = x_original; return result; @@ -35031,7 +35798,7 @@ { T& x = var->ref(); const T x_original = x; - const T result = third_derivative(e,x,h); + const T result = third_derivative(e, x, h); x = x_original; return result; @@ -35324,62 +36091,62 @@ inline virtual T operator() (const T& x, const T& c1, const T& c0) { - poly_rtrn(1) poly_impl<T,1>::evaluate(x,c1,c0); + poly_rtrn(1) poly_impl<T,1>::evaluate(x, c1, c0); } inline virtual T operator() (const T& x, const T& c2, const T& c1, const T& c0) { - poly_rtrn(2) poly_impl<T,2>::evaluate(x,c2,c1,c0); + poly_rtrn(2) poly_impl<T,2>::evaluate(x, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(3) poly_impl<T,3>::evaluate(x,c3,c2,c1,c0); + poly_rtrn(3) poly_impl<T,3>::evaluate(x, c3, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(4) poly_impl<T,4>::evaluate(x,c4,c3,c2,c1,c0); + poly_rtrn(4) poly_impl<T,4>::evaluate(x, c4, c3, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(5) poly_impl<T,5>::evaluate(x,c5,c4,c3,c2,c1,c0); + poly_rtrn(5) poly_impl<T,5>::evaluate(x, c5, c4, c3, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(6) poly_impl<T,6>::evaluate(x,c6,c5,c4,c3,c2,c1,c0); + poly_rtrn(6) poly_impl<T,6>::evaluate(x, c6, c5, c4, c3, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(7) poly_impl<T,7>::evaluate(x,c7,c6,c5,c4,c3,c2,c1,c0); + poly_rtrn(7) poly_impl<T,7>::evaluate(x, c7, c6, c5, c4, c3, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(8) poly_impl<T,8>::evaluate(x,c8,c7,c6,c5,c4,c3,c2,c1,c0); + poly_rtrn(8) poly_impl<T,8>::evaluate(x, c8, c7, c6, c5, c4, c3, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c9, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(9) poly_impl<T,9>::evaluate(x,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0); + poly_rtrn(9) poly_impl<T,9>::evaluate(x, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c10, const T& c9, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(10) poly_impl<T,10>::evaluate(x,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0); + poly_rtrn(10) poly_impl<T,10>::evaluate(x, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c11, const T& c10, const T& c9, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(11) poly_impl<T,11>::evaluate(x,c11,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0); + poly_rtrn(11) poly_impl<T,11>::evaluate(x, c11, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0); } inline virtual T operator() (const T& x, const T& c12, const T& c11, const T& c10, const T& c9, const T& c8, const T& c7, const T& c6, const T& c5, const T& c4, const T& c3, const T& c2, const T& c1, const T& c0) { - poly_rtrn(12) poly_impl<T,12>::evaluate(x,c12,c11,c10,c9,c8,c7,c6,c5,c4,c3,c2,c1,c0); + poly_rtrn(12) poly_impl<T,12>::evaluate(x, c12, c11, c10, c9, c8, c7, c6, c5, c4, c3, c2, c1, c0); } #undef poly_rtrn @@ -35868,7 +36635,7 @@ def_fp_retval(6) template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> inline bool add(const std::string& name, const std::string& expression, const Sequence<std::string,Allocator>& var_list, @@ -35964,7 +36731,7 @@ private: template <typename Allocator, - template <typename,typename> class Sequence> + template <typename, typename> class Sequence> bool compile_expression(const std::string& name, const std::string& expression, const Sequence<std::string,Allocator>& input_var_list, @@ -36146,89 +36913,90 @@ template <typename T> inline bool pgo_primer() { - static const std::string expression_list[] - = { - "(y + x)", - "2 * (y + x)", - "(2 * y + 2 * x)", - "(y + x / y) * (x - y / x)", - "x / ((x + y) * (x - y)) / y", - "1 - ((x * y) + (y / x)) - 3", - "sin(2 * x) + cos(pi / y)", - "1 - sin(2 * x) + cos(pi / y)", - "sqrt(1 - sin(2 * x) + cos(pi / y) / 3)", - "(x^2 / sin(2 * pi / y)) -x / 2", - "x + (cos(y - sin(2 / x * pi)) - sin(x - cos(2 * y / pi))) - y", - "clamp(-1.0, sin(2 * pi * x) + cos(y / 2 * pi), +1.0)", - "iclamp(-1.0, sin(2 * pi * x) + cos(y / 2 * pi), +1.0)", - "max(3.33, min(sqrt(1 - sin(2 * x) + cos(pi / y) / 3), 1.11))", - "if(avg(x,y) <= x + y, x - y, x * y) + 2 * pi / x", - "1.1x^1 + 2.2y^2 - 3.3x^3 + 4.4y^4 - 5.5x^5 + 6.6y^6 - 7.7x^27 + 8.8y^55", - "(yy + xx)", - "2 * (yy + xx)", - "(2 * yy + 2 * xx)", - "(yy + xx / yy) * (xx - yy / xx)", - "xx / ((xx + yy) * (xx - yy)) / yy", - "1 - ((xx * yy) + (yy / xx)) - 3", - "sin(2 * xx) + cos(pi / yy)", - "1 - sin(2 * xx) + cos(pi / yy)", - "sqrt(1 - sin(2 * xx) + cos(pi / yy) / 3)", - "(xx^2 / sin(2 * pi / yy)) -xx / 2", - "xx + (cos(yy - sin(2 / xx * pi)) - sin(xx - cos(2 * yy / pi))) - yy", - "clamp(-1.0, sin(2 * pi * xx) + cos(yy / 2 * pi), +1.0)", - "max(3.33, min(sqrt(1 - sin(2 * xx) + cos(pi / yy) / 3), 1.11))", - "if(avg(xx,yy) <= xx + yy, xx - yy, xx * yy) + 2 * pi / xx", - "1.1xx^1 + 2.2yy^2 - 3.3xx^3 + 4.4yy^4 - 5.5xx^5 + 6.6yy^6 - 7.7xx^27 + 8.8yy^55", - "(1.1*(2.2*(3.3*(4.4*(5.5*(6.6*(7.7*(8.8*(9.9+x)))))))))", - "(((((((((x+9.9)*8.8)*7.7)*6.6)*5.5)*4.4)*3.3)*2.2)*1.1)", - "(x + y) * z", "x + (y * z)", "(x + y) * 7", "x + (y * 7)", - "(x + 7) * y", "x + (7 * y)", "(7 + x) * y", "7 + (x * y)", - "(2 + x) * 3", "2 + (x * 3)", "(2 + 3) * x", "2 + (3 * x)", - "(x + 2) * 3", "x + (2 * 3)", - "(x + y) * (z / w)", "(x + y) * (z / 7)", "(x + y) * (7 / z)", "(x + 7) * (y / z)", - "(7 + x) * (y / z)", "(2 + x) * (y / z)", "(x + 2) * (y / 3)", "(2 + x) * (y / 3)", - "(x + 2) * (3 / y)", "x + (y * (z / w))", "x + (y * (z / 7))", "x + (y * (7 / z))", - "x + (7 * (y / z))", "7 + (x * (y / z))", "2 + (x * (3 / y))", "x + (2 * (y / 4))", - "2 + (x * (y / 3))", "x + (2 * (3 / y))", - "x + ((y * z) / w)", "x + ((y * z) / 7)", "x + ((y * 7) / z)", "x + ((7 * y) / z)", - "7 + ((y * z) / w)", "2 + ((x * 3) / y)", "x + ((2 * y) / 3)", "2 + ((x * y) / 3)", - "x + ((2 * 3) / y)", "(((x + y) * z) / w)", - "(((x + y) * z) / 7)", "(((x + y) * 7) / z)", "(((x + 7) * y) / z)", "(((7 + x) * y) / z)", - "(((2 + x) * 3) / y)", "(((x + 2) * y) / 3)", "(((2 + x) * y) / 3)", "(((x + 2) * 3) / y)", - "((x + (y * z)) / w)", "((x + (y * z)) / 7)", "((x + (y * 7)) / y)", "((x + (7 * y)) / z)", - "((7 + (x * y)) / z)", "((2 + (x * 3)) / y)", "((x + (2 * y)) / 3)", "((2 + (x * y)) / 3)", - "((x + (2 * 3)) / y)", - "(xx + yy) * zz", "xx + (yy * zz)", - "(xx + yy) * 7", "xx + (yy * 7)", - "(xx + 7) * yy", "xx + (7 * yy)", - "(7 + xx) * yy", "7 + (xx * yy)", - "(2 + x) * 3", "2 + (x * 3)", - "(2 + 3) * x", "2 + (3 * x)", - "(x + 2) * 3", "x + (2 * 3)", - "(xx + yy) * (zz / ww)", "(xx + yy) * (zz / 7)", - "(xx + yy) * (7 / zz)", "(xx + 7) * (yy / zz)", - "(7 + xx) * (yy / zz)", "(2 + xx) * (yy / zz)", - "(xx + 2) * (yy / 3)", "(2 + xx) * (yy / 3)", - "(xx + 2) * (3 / yy)", "xx + (yy * (zz / ww))", - "xx + (yy * (zz / 7))", "xx + (yy * (7 / zz))", - "xx + (7 * (yy / zz))", "7 + (xx * (yy / zz))", - "2 + (xx * (3 / yy))", "xx + (2 * (yy / 4))", - "2 + (xx * (yy / 3))", "xx + (2 * (3 / yy))", - "xx + ((yy * zz) / ww)", "xx + ((yy * zz) / 7)", - "xx + ((yy * 7) / zz)", "xx + ((7 * yy) / zz)", - "7 + ((yy * zz) / ww)", "2 + ((xx * 3) / yy)", - "xx + ((2 * yy) / 3)", "2 + ((xx * yy) / 3)", - "xx + ((2 * 3) / yy)", "(((xx + yy) * zz) / ww)", - "(((xx + yy) * zz) / 7)", "(((xx + yy) * 7) / zz)", - "(((xx + 7) * yy) / zz)", "(((7 + xx) * yy) / zz)", - "(((2 + xx) * 3) / yy)", "(((xx + 2) * yy) / 3)", - "(((2 + xx) * yy) / 3)", "(((xx + 2) * 3) / yy)", - "((xx + (yy * zz)) / ww)", "((xx + (yy * zz)) / 7)", - "((xx + (yy * 7)) / yy)", "((xx + (7 * yy)) / zz)", - "((7 + (xx * yy)) / zz)", "((2 + (xx * 3)) / yy)", - "((xx + (2 * yy)) / 3)", "((2 + (xx * yy)) / 3)", - "((xx + (2 * 3)) / yy)" - }; + static const std::string expression_list[] = + { + "(y + x)", + "2 * (y + x)", + "(2 * y + 2 * x)", + "(y + x / y) * (x - y / x)", + "x / ((x + y) * (x - y)) / y", + "1 - ((x * y) + (y / x)) - 3", + "sin(2 * x) + cos(pi / y)", + "1 - sin(2 * x) + cos(pi / y)", + "sqrt(1 - sin(2 * x) + cos(pi / y) / 3)", + "(x^2 / sin(2 * pi / y)) -x / 2", + "x + (cos(y - sin(2 / x * pi)) - sin(x - cos(2 * y / pi))) - y", + "clamp(-1.0, sin(2 * pi * x) + cos(y / 2 * pi), +1.0)", + "iclamp(-1.0, sin(2 * pi * x) + cos(y / 2 * pi), +1.0)", + "max(3.33, min(sqrt(1 - sin(2 * x) + cos(pi / y) / 3), 1.11))", + "if(avg(x,y) <= x + y, x - y, x * y) + 2 * pi / x", + "1.1x^1 + 2.2y^2 - 3.3x^3 + 4.4y^4 - 5.5x^5 + 6.6y^6 - 7.7x^27 + 8.8y^55", + "(yy + xx)", + "2 * (yy + xx)", + "(2 * yy + 2 * xx)", + "(yy + xx / yy) * (xx - yy / xx)", + "xx / ((xx + yy) * (xx - yy)) / yy", + "1 - ((xx * yy) + (yy / xx)) - 3", + "sin(2 * xx) + cos(pi / yy)", + "1 - sin(2 * xx) + cos(pi / yy)", + "sqrt(1 - sin(2 * xx) + cos(pi / yy) / 3)", + "(xx^2 / sin(2 * pi / yy)) -xx / 2", + "xx + (cos(yy - sin(2 / xx * pi)) - sin(xx - cos(2 * yy / pi))) - yy", + "clamp(-1.0, sin(2 * pi * xx) + cos(yy / 2 * pi), +1.0)", + "max(3.33, min(sqrt(1 - sin(2 * xx) + cos(pi / yy) / 3), 1.11))", + "if(avg(xx,yy) <= xx + yy, xx - yy, xx * yy) + 2 * pi / xx", + "1.1xx^1 + 2.2yy^2 - 3.3xx^3 + 4.4yy^4 - 5.5xx^5 + 6.6yy^6 - 7.7xx^27 + 8.8yy^55", + "(1.1*(2.2*(3.3*(4.4*(5.5*(6.6*(7.7*(8.8*(9.9+x)))))))))", + "(((((((((x+9.9)*8.8)*7.7)*6.6)*5.5)*4.4)*3.3)*2.2)*1.1)", + "(x + y) * z", "x + (y * z)", "(x + y) * 7", "x + (y * 7)", + "(x + 7) * y", "x + (7 * y)", "(7 + x) * y", "7 + (x * y)", + "(2 + x) * 3", "2 + (x * 3)", "(2 + 3) * x", "2 + (3 * x)", + "(x + 2) * 3", "x + (2 * 3)", + "(x + y) * (z / w)", "(x + y) * (z / 7)", "(x + y) * (7 / z)", "(x + 7) * (y / z)", + "(7 + x) * (y / z)", "(2 + x) * (y / z)", "(x + 2) * (y / 3)", "(2 + x) * (y / 3)", + "(x + 2) * (3 / y)", "x + (y * (z / w))", "x + (y * (z / 7))", "x + (y * (7 / z))", + "x + (7 * (y / z))", "7 + (x * (y / z))", "2 + (x * (3 / y))", "x + (2 * (y / 4))", + "2 + (x * (y / 3))", "x + (2 * (3 / y))", + "x + ((y * z) / w)", "x + ((y * z) / 7)", "x + ((y * 7) / z)", "x + ((7 * y) / z)", + "7 + ((y * z) / w)", "2 + ((x * 3) / y)", "x + ((2 * y) / 3)", "2 + ((x * y) / 3)", + "x + ((2 * 3) / y)", "(((x + y) * z) / w)", + "(((x + y) * z) / 7)", "(((x + y) * 7) / z)", "(((x + 7) * y) / z)", "(((7 + x) * y) / z)", + "(((2 + x) * 3) / y)", "(((x + 2) * y) / 3)", "(((2 + x) * y) / 3)", "(((x + 2) * 3) / y)", + "((x + (y * z)) / w)", "((x + (y * z)) / 7)", "((x + (y * 7)) / y)", "((x + (7 * y)) / z)", + "((7 + (x * y)) / z)", "((2 + (x * 3)) / y)", "((x + (2 * y)) / 3)", "((2 + (x * y)) / 3)", + "((x + (2 * 3)) / y)", + "(xx + yy) * zz", "xx + (yy * zz)", + "(xx + yy) * 7", "xx + (yy * 7)", + "(xx + 7) * yy", "xx + (7 * yy)", + "(7 + xx) * yy", "7 + (xx * yy)", + "(2 + x) * 3", "2 + (x * 3)", + "(2 + 3) * x", "2 + (3 * x)", + "(x + 2) * 3", "x + (2 * 3)", + "(xx + yy) * (zz / ww)", "(xx + yy) * (zz / 7)", + "(xx + yy) * (7 / zz)", "(xx + 7) * (yy / zz)", + "(7 + xx) * (yy / zz)", "(2 + xx) * (yy / zz)", + "(xx + 2) * (yy / 3)", "(2 + xx) * (yy / 3)", + "(xx + 2) * (3 / yy)", "xx + (yy * (zz / ww))", + "xx + (yy * (zz / 7))", "xx + (yy * (7 / zz))", + "xx + (7 * (yy / zz))", "7 + (xx * (yy / zz))", + "2 + (xx * (3 / yy))", "xx + (2 * (yy / 4))", + "2 + (xx * (yy / 3))", "xx + (2 * (3 / yy))", + "xx + ((yy * zz) / ww)", "xx + ((yy * zz) / 7)", + "xx + ((yy * 7) / zz)", "xx + ((7 * yy) / zz)", + "7 + ((yy * zz) / ww)", "2 + ((xx * 3) / yy)", + "xx + ((2 * yy) / 3)", "2 + ((xx * yy) / 3)", + "xx + ((2 * 3) / yy)", "(((xx + yy) * zz) / ww)", + "(((xx + yy) * zz) / 7)", "(((xx + yy) * 7) / zz)", + "(((xx + 7) * yy) / zz)", "(((7 + xx) * yy) / zz)", + "(((2 + xx) * 3) / yy)", "(((xx + 2) * yy) / 3)", + "(((2 + xx) * yy) / 3)", "(((xx + 2) * 3) / yy)", + "((xx + (yy * zz)) / ww)", "((xx + (yy * zz)) / 7)", + "((xx + (yy * 7)) / yy)", "((xx + (7 * yy)) / zz)", + "((7 + (xx * yy)) / zz)", "((2 + (xx * 3)) / yy)", + "((xx + (2 * yy)) / 3)", "((2 + (xx * yy)) / 3)", + "((xx + (2 * 3)) / yy)" + }; + static const std::size_t expression_list_size = sizeof(expression_list) / sizeof(std::string); T x = T(0); @@ -36283,8 +37051,8 @@ { static const T lower_bound = T(-20); static const T upper_bound = T(+20); + static const T delta = T(0.1); - T delta = T(0.1); T total = T(0); for (x = lower_bound; x <= upper_bound; x += delta) @@ -36308,7 +37076,7 @@ { for (std::size_t i = 0; i < 10000; ++i) { - T v = T(123.456 + i); + const T v = T(123.456 + i); if (details::is_true(details::numeric::nequal(details::numeric::fast_exp<T, 1>::result(v),details::numeric::pow(v,T( 1))))) return false; @@ -36413,14 +37181,14 @@ { if (stop_time_.tv_sec >= start_time_.tv_sec) { - return 1000000LLU * static_cast<unsigned long long int>(stop_time_.tv_sec - start_time_.tv_sec ) + - static_cast<unsigned long long int>(stop_time_.tv_usec - start_time_.tv_usec) ; + return 1000000LLU * static_cast<details::_uint64_t>(stop_time_.tv_sec - start_time_.tv_sec ) + + static_cast<details::_uint64_t>(stop_time_.tv_usec - start_time_.tv_usec) ; } else - return std::numeric_limits<unsigned long long int>::max(); + return std::numeric_limits<details::_uint64_t>::max(); } else - return std::numeric_limits<unsigned long long int>::max(); + return std::numeric_limits<details::_uint64_t>::max(); } inline double time() const @@ -36751,7 +37519,7 @@ } } - bool eof() + bool eof() const { switch (mode) { @@ -36762,7 +37530,7 @@ } } - file_mode get_file_mode(const std::string& access) + file_mode get_file_mode(const std::string& access) const { if (access.empty() || access.size() > 2) return e_error; @@ -36840,11 +37608,9 @@ inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - std::string file_name; + std::string file_name = to_str(string_t(parameters[0])); std::string access; - file_name = to_str(string_t(parameters[0])); - if (file_name.empty()) return T(0); @@ -36925,27 +37691,27 @@ case 0 : { const string_t buffer(parameters[1]); amount = buffer.size(); - return T(fd->write(buffer,amount) ? 1 : 0); + return T(fd->write(buffer, amount) ? 1 : 0); } case 1 : { const string_t buffer(parameters[1]); amount = std::min(buffer.size(), static_cast<std::size_t>(scalar_t(parameters[2])())); - return T(fd->write(buffer,amount) ? 1 : 0); + return T(fd->write(buffer, amount) ? 1 : 0); } case 2 : { const vector_t vec(parameters[1]); amount = vec.size(); - return T(fd->write(vec,amount) ? 1 : 0); + return T(fd->write(vec, amount) ? 1 : 0); } case 3 : { const vector_t vec(parameters[1]); amount = std::min(vec.size(), static_cast<std::size_t>(scalar_t(parameters[2])())); - return T(fd->write(vec,amount) ? 1 : 0); + return T(fd->write(vec, amount) ? 1 : 0); } } @@ -37146,10 +37912,10 @@ namespace details { template <typename T> - inline void kahan_sum(T& sum, T& error, T v) + inline void kahan_sum(T& sum, T& error, const T v) { - T x = v - error; - T y = sum + x; + const T x = v - error; + const T y = sum + x; error = (y - sum) - x; sum = y; } @@ -37870,10 +38636,10 @@ if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 3, 4, 1)) return std::numeric_limits<T>::quiet_NaN(); - else if (helper::invalid_range(y,r0,r1)) + else if (helper::invalid_range(y, r0, r1)) return std::numeric_limits<T>::quiet_NaN(); - T a = scalar_t(parameters[0])(); + const T a = scalar_t(parameters[0])(); for (std::size_t i = r0; i <= r1; ++i) { @@ -37917,7 +38683,7 @@ if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 4, 5, 1)) return std::numeric_limits<T>::quiet_NaN(); - else if (helper::invalid_range(y,r0,r1)) + else if (helper::invalid_range(y, r0, r1)) return std::numeric_limits<T>::quiet_NaN(); const T a = scalar_t(parameters[0])(); @@ -37966,12 +38732,12 @@ if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 3, 4, 1)) return std::numeric_limits<T>::quiet_NaN(); - else if (helper::invalid_range(y,r0,r1)) + else if (helper::invalid_range(y, r0, r1)) return std::numeric_limits<T>::quiet_NaN(); - else if (helper::invalid_range(z,r0,r1)) + else if (helper::invalid_range(z, r0, r1)) return std::numeric_limits<T>::quiet_NaN(); - T a = scalar_t(parameters[0])(); + const T a = scalar_t(parameters[0])(); for (std::size_t i = r0; i <= r1; ++i) { @@ -38016,9 +38782,9 @@ if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 4, 5, 1)) return std::numeric_limits<T>::quiet_NaN(); - else if (helper::invalid_range(y,r0,r1)) + else if (helper::invalid_range(y, r0, r1)) return std::numeric_limits<T>::quiet_NaN(); - else if (helper::invalid_range(z,r0,r1)) + else if (helper::invalid_range(z, r0, r1)) return std::numeric_limits<T>::quiet_NaN(); const T a = scalar_t(parameters[0])(); @@ -38066,7 +38832,7 @@ if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 4, 5, 1)) return std::numeric_limits<T>::quiet_NaN(); - else if (helper::invalid_range(z,r0,r1)) + else if (helper::invalid_range(z, r0, r1)) return std::numeric_limits<T>::quiet_NaN(); const T a = scalar_t(parameters[0])(); @@ -38113,7 +38879,7 @@ if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0)) return std::numeric_limits<T>::quiet_NaN(); - else if (helper::invalid_range(y,r0,r1)) + else if (helper::invalid_range(y, r0, r1)) return std::numeric_limits<T>::quiet_NaN(); T result = T(0); @@ -38159,7 +38925,7 @@ if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0)) return std::numeric_limits<T>::quiet_NaN(); - else if (helper::invalid_range(y,r0,r1)) + else if (helper::invalid_range(y, r0, r1)) return std::numeric_limits<T>::quiet_NaN(); T result = T(0); @@ -38215,7 +38981,7 @@ exprtk_register_function("any_true" ,nt) exprtk_register_function("any_false" ,nf) exprtk_register_function("count" , c) - exprtk_register_function("copy" , cp) + exprtk_register_function("copy" ,cp) exprtk_register_function("rotate_left" ,rl) exprtk_register_function("rol" ,rl) exprtk_register_function("rotate_right" ,rr) @@ -38249,9 +39015,9 @@ namespace information { static const char* library = "Mathematical Expression Toolkit"; - static const char* version = "2.71828182845904523536028747135266249775724709369" - "9959574966967627724076630353547594571382178525166"; - static const char* date = "20180101"; + static const char* version = "2.7182818284590452353602874713526624977572470936999595749" + "669676277240766303535475945713821785251664274274663919320"; + static const char* date = "20200101"; static inline std::string data() {
diff --git a/exprtk_benchmark.cpp b/exprtk_benchmark.cpp index e219765..8e9c5fa 100644 --- a/exprtk_benchmark.cpp +++ b/exprtk_benchmark.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * ExprTk vs Native Benchmarks * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: *
diff --git a/exprtk_simple_example_01.cpp b/exprtk_simple_example_01.cpp index 46ee209..80eafe1 100644 --- a/exprtk_simple_example_01.cpp +++ b/exprtk_simple_example_01.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 1 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -29,7 +29,8 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string expression_string = "clamp(-1.0,sin(2 * pi * x) + cos(x / 2 * pi),+1.0)"; + const std::string expression_string = + "clamp(-1.0,sin(2 * pi * x) + cos(x / 2 * pi),+1.0)"; T x; @@ -45,8 +46,8 @@ for (x = T(-5); x <= T(+5); x += T(0.001)) { - T y = expression.value(); - printf("%19.15f\t%19.15f\n",x,y); + const T y = expression.value(); + printf("%19.15f\t%19.15f\n", x, y); } }
diff --git a/exprtk_simple_example_02.cpp b/exprtk_simple_example_02.cpp index 4e3b915..56b9c9b 100644 --- a/exprtk_simple_example_02.cpp +++ b/exprtk_simple_example_02.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 2 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -29,14 +29,15 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string expr_string = "a*(4/pi)*" - "((1 /1)*sin( 2*pi*f*t)+(1 /3)*sin( 6*pi*f*t)+" - " (1 /5)*sin(10*pi*f*t)+(1 /7)*sin(14*pi*f*t)+" - " (1 /9)*sin(18*pi*f*t)+(1/11)*sin(22*pi*f*t)+" - " (1/13)*sin(26*pi*f*t)+(1/15)*sin(30*pi*f*t)+" - " (1/17)*sin(34*pi*f*t)+(1/19)*sin(38*pi*f*t)+" - " (1/21)*sin(42*pi*f*t)+(1/23)*sin(46*pi*f*t)+" - " (1/25)*sin(50*pi*f*t)+(1/27)*sin(54*pi*f*t))"; + const std::string expr_string = + "a*(4/pi)*" + "((1 /1)*sin( 2*pi*f*t)+(1 /3)*sin( 6*pi*f*t)+" + " (1 /5)*sin(10*pi*f*t)+(1 /7)*sin(14*pi*f*t)+" + " (1 /9)*sin(18*pi*f*t)+(1/11)*sin(22*pi*f*t)+" + " (1/13)*sin(26*pi*f*t)+(1/15)*sin(30*pi*f*t)+" + " (1/17)*sin(34*pi*f*t)+(1/19)*sin(38*pi*f*t)+" + " (1/21)*sin(42*pi*f*t)+(1/23)*sin(46*pi*f*t)+" + " (1/25)*sin(50*pi*f*t)+(1/27)*sin(54*pi*f*t))"; static const T pi = T(3.141592653589793238462643383279502); @@ -60,8 +61,8 @@ for (t = (T(-2) * pi); t <= (T(+2) * pi); t += delta) { - T result = expression.value(); - printf("%19.15f\t%19.15f\n",t,result); + const T result = expression.value(); + printf("%19.15f\t%19.15f\n", t, result); } }
diff --git a/exprtk_simple_example_03.cpp b/exprtk_simple_example_03.cpp index b929192..8e5a164 100644 --- a/exprtk_simple_example_03.cpp +++ b/exprtk_simple_example_03.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 3 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -29,7 +29,8 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string expression_string = "25x^5 - 35x^4 - 15x^3 + 40x^2 - 15x + 1"; + const std::string expression_string = + "25x^5 - 35x^4 - 15x^3 + 40x^2 - 15x + 1"; const T r0 = T(0); const T r1 = T(1); @@ -48,7 +49,7 @@ for (x = r0; x <= r1; x += delta) { - printf("%19.15f\t%19.15f\n",x,expression.value()); + printf("%19.15f\t%19.15f\n", x, expression.value()); } }
diff --git a/exprtk_simple_example_04.cpp b/exprtk_simple_example_04.cpp index eb1a4e3..aca7014 100644 --- a/exprtk_simple_example_04.cpp +++ b/exprtk_simple_example_04.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 4 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -73,7 +73,7 @@ { x = static_cast<T>(i); - T result = expression.value(); + const T result = expression.value(); printf("fibonacci(%3d) = %10.0f\n", static_cast<int>(i),
diff --git a/exprtk_simple_example_05.cpp b/exprtk_simple_example_05.cpp index 408f6d4..50d7987 100644 --- a/exprtk_simple_example_05.cpp +++ b/exprtk_simple_example_05.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 5 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -50,7 +50,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string expression_string = + const std::string expression_string = "myfunc(sin(x / pi), otherfunc(3 * y, x / 2, x * y))"; T x = T(1); @@ -70,7 +70,7 @@ parser_t parser; parser.compile(expression_string,expression); - T result = expression.value(); + const T result = expression.value(); printf("Result: %10.5f\n",result); }
diff --git a/exprtk_simple_example_06.cpp b/exprtk_simple_example_06.cpp index e3d81b3..0af6f8b 100644 --- a/exprtk_simple_example_06.cpp +++ b/exprtk_simple_example_06.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 6 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -29,7 +29,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string expression_string = + const std::string expression_string = " for (var i := 0; i < min(x[],y[],z[]); i += 1) " " { " " z[i] := 3sin(x[i]) + 2log(y[i]); "
diff --git a/exprtk_simple_example_07.cpp b/exprtk_simple_example_07.cpp index 736a7b9..bdf3c3b 100644 --- a/exprtk_simple_example_07.cpp +++ b/exprtk_simple_example_07.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 7 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -29,7 +29,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string expression_string = "not(A and B) or C"; + const std::string expression_string = "not(A and B) or C"; symbol_table_t symbol_table; symbol_table.create_variable("A"); @@ -53,7 +53,7 @@ symbol_table.get_variable("B")->ref() = T((i & 0x02) ? 1 : 0); symbol_table.get_variable("C")->ref() = T((i & 0x04) ? 1 : 0); - int result = static_cast<int>(expression.value()); + const int result = static_cast<int>(expression.value()); printf(" %d | %d | %d | %d | %d \n", i,
diff --git a/exprtk_simple_example_08.cpp b/exprtk_simple_example_08.cpp index b033ab3..4565098 100644 --- a/exprtk_simple_example_08.cpp +++ b/exprtk_simple_example_08.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 8 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -28,7 +28,7 @@ typedef exprtk::symbol_table<T> symbol_table_t; typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - typedef exprtk::parser_error::type error_t; + typedef exprtk::parser_error::type err_t; typedef exprtk::function_compositor<T> compositor_t; typedef typename compositor_t::function function_t; @@ -65,7 +65,7 @@ for (std::size_t i = 0; i < parser.error_count(); ++i) { - error_t error = parser.get_error(i); + const err_t error = parser.get_error(i); printf("Error: %02d Position: %02d Type: [%14s] Msg: %s\tExpression: %s\n", static_cast<unsigned int>(i), @@ -78,7 +78,7 @@ return; } - T result = expression.value(); + const T result = expression.value(); printf("%s = %e\n", expression_string.c_str(), result); }
diff --git a/exprtk_simple_example_09.cpp b/exprtk_simple_example_09.cpp index 79fb3f9..b11f193 100644 --- a/exprtk_simple_example_09.cpp +++ b/exprtk_simple_example_09.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 9 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -133,9 +133,9 @@ { x = static_cast<T>(i); - T result1 = expression1.value(); - T result2 = expression2.value(); - T result3 = expression3.value(); + const T result1 = expression1.value(); + const T result2 = expression2.value(); + const T result3 = expression3.value(); printf("%03d Result1: %c Result2: %c Result3: %c\n", static_cast<unsigned int>(i),
diff --git a/exprtk_simple_example_10.cpp b/exprtk_simple_example_10.cpp index 6ce237b..13728da 100644 --- a/exprtk_simple_example_10.cpp +++ b/exprtk_simple_example_10.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 10 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -64,7 +64,7 @@ " } ", "x")); - std::string expression_str = "newton_sqrt(x)"; + const std::string expression_str = "newton_sqrt(x)"; expression_t expression; expression.register_symbol_table(symbol_table); @@ -76,7 +76,7 @@ { x = static_cast<T>(i); - T result = expression.value(); + const T result = expression.value(); printf("sqrt(%03d) - Result: %15.13f\tReal: %15.13f\n", static_cast<unsigned int>(i),
diff --git a/exprtk_simple_example_11.cpp b/exprtk_simple_example_11.cpp index 87bacf7..454c8f0 100644 --- a/exprtk_simple_example_11.cpp +++ b/exprtk_simple_example_11.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 11 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -29,7 +29,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string wave_program = + const std::string wave_program = " var r := 0; " " for (var i := 0; i < 1000; i += 1) " " { " @@ -59,8 +59,8 @@ for (t = (T(-2) * pi); t <= (T(+2) * pi); t += delta) { - T result = expression.value(); - printf("%19.15f\t%19.15f\n",t,result); + const T result = expression.value(); + printf("%19.15f\t%19.15f\n", t, result); } }
diff --git a/exprtk_simple_example_12.cpp b/exprtk_simple_example_12.cpp index b80411b..ce398bd 100644 --- a/exprtk_simple_example_12.cpp +++ b/exprtk_simple_example_12.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 12 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -29,7 +29,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string bubblesort_program = + const std::string bubblesort_program = " var upper_bound := v[]; " " var swapped := false; " " repeat "
diff --git a/exprtk_simple_example_13.cpp b/exprtk_simple_example_13.cpp index 1dfbd31..e1922e8 100644 --- a/exprtk_simple_example_13.cpp +++ b/exprtk_simple_example_13.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 13 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -31,7 +31,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string sgfilter_program = + const std::string sgfilter_program = " var weight[9] := " " { " " -21, 14, 39, " @@ -89,7 +89,7 @@ for (std::size_t i = 0; i < v_out.size(); ++i) { - printf("%10.6f\t%10.6f\n",v_in[i],v_out[i]); + printf("%10.6f\t%10.6f\n", v_in[i], v_out[i]); } }
diff --git a/exprtk_simple_example_14.cpp b/exprtk_simple_example_14.cpp index 397a86d..bc508a2 100644 --- a/exprtk_simple_example_14.cpp +++ b/exprtk_simple_example_14.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 14 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -28,7 +28,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string stddev_program = + const std::string stddev_program = " var x[25] := { " " 1, 2, 3, 4, 5, " " 6, 7, 8, 9, 10, " @@ -44,7 +44,7 @@ parser_t parser; parser.compile(stddev_program,expression); - T stddev = expression.value(); + const T stddev = expression.value(); printf("stddev(1..25) = %10.6f\n",stddev); }
diff --git a/exprtk_simple_example_15.cpp b/exprtk_simple_example_15.cpp index f3a2ef5..f7364fd 100644 --- a/exprtk_simple_example_15.cpp +++ b/exprtk_simple_example_15.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 15 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -29,7 +29,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string bsm_model_program = + const std::string bsm_model_program = " var d1 := (log(s / x) + (r + v^2 / 2) * t) / (v * sqrt(t)); " " var d2 := d1 - v * sqrt(t); " " " @@ -71,7 +71,7 @@ printf("BSM(%s,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f) = %10.6f\n", callput_flag.c_str(), - s,x,t,r,v, + s, x, t, r, v, bsm); } @@ -82,7 +82,7 @@ printf("BSM(%s,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f) = %10.6f\n", callput_flag.c_str(), - s,x,t,r,v, + s, x, t, r, v, bsm); } }
diff --git a/exprtk_simple_example_16.cpp b/exprtk_simple_example_16.cpp index 64c366e..cd76f84 100644 --- a/exprtk_simple_example_16.cpp +++ b/exprtk_simple_example_16.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 16 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -30,7 +30,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string linear_least_squares_program = + const std::string linear_least_squares_program = " if (x[] == y[]) " " { " " beta := (sum(x * y) - sum(x) * sum(y) / x[]) / "
diff --git a/exprtk_simple_example_17.cpp b/exprtk_simple_example_17.cpp index a80e0ca..50263aa 100644 --- a/exprtk_simple_example_17.cpp +++ b/exprtk_simple_example_17.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 17 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -47,7 +47,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string monte_carlo_pi_program = + const std::string monte_carlo_pi_program = " var experiments[5 * 10^7] := [(rnd_01^2 + rnd_01^2) <= 1]; " " 4 * sum(experiments) / experiments[]; ";
diff --git a/exprtk_simple_example_18.cpp b/exprtk_simple_example_18.cpp index c5bdf04..4fabc72 100644 --- a/exprtk_simple_example_18.cpp +++ b/exprtk_simple_example_18.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 18 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -29,7 +29,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string fileio_program = + const std::string fileio_program = " var file_name := 'file.txt'; " " var stream := null; " " "
diff --git a/exprtk_simple_example_19.cpp b/exprtk_simple_example_19.cpp index d317559..5d0fc20 100644 --- a/exprtk_simple_example_19.cpp +++ b/exprtk_simple_example_19.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Simple Example 19 * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -55,7 +55,7 @@ if ( (1 == ps_index) && !exprtk::rtl::vecops::helper:: - load_vector_range<T>::process(parameters,r0,r1,1,2,0) + load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0) ) return T(0); @@ -84,7 +84,7 @@ typedef exprtk::expression<T> expression_t; typedef exprtk::parser<T> parser_t; - std::string vecrandu_program = + const std::string vecrandu_program = " var noise[6] := [0]; " " " " if (randu(noise,0,5) == false) "
diff --git a/exprtk_test.cpp b/exprtk_test.cpp index b33c2bf..91e7593 100644 --- a/exprtk_test.cpp +++ b/exprtk_test.cpp
@@ -3,7 +3,7 @@ * C++ Mathematical Expression Toolkit Library * * * * Examples and Unit-Tests * - * Author: Arash Partow (1999-2018) * + * Author: Arash Partow (1999-2020) * * URL: http://www.partow.net/programming/exprtk/index.html * * * * Copyright notice: * @@ -23,6 +23,7 @@ #include <deque> #include <fstream> #include <iostream> +#include <numeric> #include <string> #include <vector> @@ -2452,83 +2453,90 @@ test_ab<T>("var x := 'XXXXX'; var y := '01234567890'; var i := 0; x[0:i+3] <=> y[:]; (x == '0123X') and (y == 'XXXX4567890')", "","",T(1.0)), test_ab<T>("var x := 'XXXXX'; var y := '01234567890'; var i := 0; x[0:i+4] <=> y[:]; (x == '01234') and (y == 'XXXXX567890')", "","",T(1.0)), - test_ab<T>("a like b", "abcd", "abcd", T(1.0)), - test_ab<T>("a like b", "abcd", "abc*", T(1.0)), - test_ab<T>("a like b", "abcd", "*bcd", T(1.0)), - test_ab<T>("a like b", "abcd", "abc?", T(1.0)), - test_ab<T>("a like b", "abcd", "?bcd", T(1.0)), - test_ab<T>("a like b", "abcd", "ab?d", T(1.0)), - test_ab<T>("a like b", "abcd", "ab*d", T(1.0)), - test_ab<T>("a like b", "abcd", "a?cd", T(1.0)), - test_ab<T>("a like b", "abcd", "a*cd", T(1.0)), - test_ab<T>("a like b", "abcd", "a??d", T(1.0)), - test_ab<T>("a like b", "abcd", "a*?d", T(1.0)), - test_ab<T>("a like b", "abcd", "*bc*", T(1.0)), - test_ab<T>("a like b", "abcd", "?bc?", T(1.0)), - test_ab<T>("a like b", "abcd", "????", T(1.0)), - test_ab<T>("a like b", "abcd", "a???", T(1.0)), - test_ab<T>("a like b", "abcd", "ab??", T(1.0)), - test_ab<T>("a like b", "abcd", "abc?", T(1.0)), - test_ab<T>("a like b", "abcd", "???d", T(1.0)), - test_ab<T>("a like b", "abcd", "??cd", T(1.0)), - test_ab<T>("a like b", "abcd", "?bcd", T(1.0)), - test_ab<T>("a like b", "abcd", "?b?d", T(1.0)), - test_ab<T>("a like b", "abcd", "a?c?", T(1.0)), - test_ab<T>("a like b", "abcd", "a??d", T(1.0)), - test_ab<T>("a like b", "abcd", "?bc?", T(1.0)), - test_ab<T>("a like b", "abcd", "ab**", T(1.0)), - test_ab<T>("a like b", "abcd", "ab*?", T(1.0)), - test_ab<T>("a like b", "abcd", "a***", T(1.0)), - test_ab<T>("a like b", "abcd", "**cd", T(1.0)), - test_ab<T>("a like b", "abcd", "*?cd", T(1.0)), - test_ab<T>("a like b", "abcd", "***d", T(1.0)), - test_ab<T>("a like b", "abcd", "*bc*", T(1.0)), - test_ab<T>("a like b", "abcd", "*bc?", T(1.0)), - test_ab<T>("a like b", "abcd", "*b??", T(1.0)), - test_ab<T>("a like b", "abcd", "?bc*", T(1.0)), - test_ab<T>("a like b", "abcd", "??c*", T(1.0)), - test_ab<T>("a like b", "abcd", "*b?*", T(1.0)), - test_ab<T>("a like b", "ab" , "a*" , T(1.0)), - test_ab<T>("a like b", "ab" , "a?" , T(1.0)), + test_ab<T>("var v[4] := {1,2,3,4}; for (var i := 0; i < v[]; i += 1) { v[i] += 10; v[i] == 0 }; sum(v) == (1 + 2 + 3 + 4) + (v[] * 10)", "","",T(1.0)), + test_ab<T>("var v[4] := {1,2,3,4}; for (var i := 0; i < v[]; i += 1) { v[i] -= 10; v[i] == 0 }; sum(v) == (1 + 2 + 3 + 4) - (v[] * 10)", "","",T(1.0)), + test_ab<T>("var v[4] := {1,2,3,4}; for (var i := 0; i < v[]; i += 1) { v[i] *= 10; v[i] == 0 }; sum(v) == (1 + 2 + 3 + 4) * 10", "","",T(1.0)), + test_ab<T>("var v[4] := {1,2,3,4}; for (var i := 0; i < v[]; i += 1) { v[i] /= 10; v[i] == 0 }; sum(v) == (1 + 2 + 3 + 4) / 10", "","",T(1.0)), - test_ab<T>("a ilike b", "aBcD", "abcd", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "abc*", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "*bcd", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "abc?", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "?bcd", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "ab?d", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "ab*d", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "a?cd", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "a*cd", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "a??d", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "a*?d", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "*bc*", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "?bc?", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "????", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "a???", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "ab??", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "abc?", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "???d", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "??cd", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "?bcd", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "?b?d", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "a?c?", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "a??d", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "?bc?", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "ab**", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "ab*?", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "a***", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "**cd", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "*?cd", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "***d", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "*bc*", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "*bc?", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "*b??", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "?bc*", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "??c*", T(1.0)), - test_ab<T>("a ilike b", "aBcD", "*b?*", T(1.0)), - test_ab<T>("a ilike b", "aB" , "a*" , T(1.0)), - test_ab<T>("a ilike b", "aB" , "a?" , T(1.0)) + test_ab<T>("a like b", "abcd", "abcd*", T(1.0)), + test_ab<T>("a like b", "abcd", "abcd" , T(1.0)), + test_ab<T>("a like b", "abcd", "abc*" , T(1.0)), + test_ab<T>("a like b", "abcd", "*bcd" , T(1.0)), + test_ab<T>("a like b", "abcd", "abc?" , T(1.0)), + test_ab<T>("a like b", "abcd", "?bcd" , T(1.0)), + test_ab<T>("a like b", "abcd", "ab?d" , T(1.0)), + test_ab<T>("a like b", "abcd", "ab*d" , T(1.0)), + test_ab<T>("a like b", "abcd", "a?cd" , T(1.0)), + test_ab<T>("a like b", "abcd", "a*cd" , T(1.0)), + test_ab<T>("a like b", "abcd", "a??d" , T(1.0)), + test_ab<T>("a like b", "abcd", "a*?d" , T(1.0)), + test_ab<T>("a like b", "abcd", "*bc*" , T(1.0)), + test_ab<T>("a like b", "abcd", "?bc?" , T(1.0)), + test_ab<T>("a like b", "abcd", "????" , T(1.0)), + test_ab<T>("a like b", "abcd", "a???" , T(1.0)), + test_ab<T>("a like b", "abcd", "ab??" , T(1.0)), + test_ab<T>("a like b", "abcd", "abc?" , T(1.0)), + test_ab<T>("a like b", "abcd", "???d" , T(1.0)), + test_ab<T>("a like b", "abcd", "??cd" , T(1.0)), + test_ab<T>("a like b", "abcd", "?bcd" , T(1.0)), + test_ab<T>("a like b", "abcd", "?b?d" , T(1.0)), + test_ab<T>("a like b", "abcd", "a?c?" , T(1.0)), + test_ab<T>("a like b", "abcd", "a??d" , T(1.0)), + test_ab<T>("a like b", "abcd", "?bc?" , T(1.0)), + test_ab<T>("a like b", "abcd", "ab**" , T(1.0)), + test_ab<T>("a like b", "abcd", "ab*?" , T(1.0)), + test_ab<T>("a like b", "abcd", "a***" , T(1.0)), + test_ab<T>("a like b", "abcd", "**cd" , T(1.0)), + test_ab<T>("a like b", "abcd", "*?cd" , T(1.0)), + test_ab<T>("a like b", "abcd", "***d" , T(1.0)), + test_ab<T>("a like b", "abcd", "*bc*" , T(1.0)), + test_ab<T>("a like b", "abcd", "*bc?" , T(1.0)), + test_ab<T>("a like b", "abcd", "*b??" , T(1.0)), + test_ab<T>("a like b", "abcd", "?bc*" , T(1.0)), + test_ab<T>("a like b", "abcd", "??c*" , T(1.0)), + test_ab<T>("a like b", "abcd", "*b?*" , T(1.0)), + test_ab<T>("a like b", "ab" , "a*" , T(1.0)), + test_ab<T>("a like b", "ab" , "a?" , T(1.0)), + + test_ab<T>("a ilike b", "aBcD", "abcd*", T(1.0)), + test_ab<T>("a ilike b", "aBcD", "abcd" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "abc*" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "*bcd" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "abc?" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "?bcd" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "ab?d" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "ab*d" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "a?cd" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "a*cd" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "a??d" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "a*?d" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "*bc*" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "?bc?" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "????" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "a???" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "ab??" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "abc?" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "???d" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "??cd" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "?bcd" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "?b?d" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "a?c?" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "a??d" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "?bc?" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "ab**" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "ab*?" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "a***" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "**cd" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "*?cd" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "***d" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "*bc*" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "*bc?" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "*b??" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "?bc*" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "??c*" , T(1.0)), + test_ab<T>("a ilike b", "aBcD", "*b?*" , T(1.0)), + test_ab<T>("a ilike b", "aB" , "a*" , T(1.0)), + test_ab<T>("a ilike b", "aB" , "a?" , T(1.0)) }; static const std::size_t test_list_size = sizeof(test_list) / sizeof(test_ab<T>); @@ -2667,6 +2675,10 @@ template <typename T> inline bool run_test03() { + typedef exprtk::symbol_table<T> symbol_table_t; + typedef exprtk::expression<T> expression_t; + typedef exprtk::parser<T> parser_t; + std::string expression_string = "A+A0+aA+Aa0+b+B1+Bb+bB1+A+A0+AA+AA0+B+B1+BB+BB1+a+a0+aa+aa0+b+b1+bb+bb1+" "c+C2+Cc+Cc2+D+D3+dD+dD3+C+C2+CC+CC2+D+D3+DD+DD3+c+c2+cc+cc2+d+d3+dd+dd3+" "E+E4+eE+Ee4+f+F5+Ff+fF5+E+E4+EE+EE4+F+F5+FF+FF5+e+e4+ee+ee4+f+f5+ff+ff5+" @@ -2704,9 +2716,9 @@ for (std::size_t r = 0; r < rounds; ++r) { - exprtk::symbol_table<T> symbol_table_0; - exprtk::symbol_table<T> symbol_table_1; - exprtk::expression<T> expression; + symbol_table_t symbol_table_0; + symbol_table_t symbol_table_1; + expression_t expression; std::vector<T> v; v.resize(variable_list_size); @@ -2804,7 +2816,38 @@ "1 v x", "1 v y", "x v 1", - "y v 1" + "y v 1", + + "(x == 'a string' )", + "(x == 'a string'[1:2] )", + "(x == 'a string' + 'b string' )", + "(x == ('a string' + 'b string')[3:5])", + "('a string' == x )", + "('a string'[1:2] == x )", + "('a string' + 'b string' == x )", + "(('a string' + 'b string')[3:5] == x)", + + "var a; var b; 3in(a)+sin(b) ", + "var a; var b; sin(a)+3in(b) ", + "var a; var b; sqrt(a)<3in(8) ", + "var a; var b; (1.99-3in((b-b))) ", + "var a; var b; ((3in(sin((b+b)))/1.06)-a) ", + "var a; var b; ((sin(3in((b+b)))/1.06)-a) ", + "var a; var b; (3in(x*(y+z))+cos(x*(y-z))) ", + "var a; var b; (cos(x*(y+z))+3in(x*(y-z))) ", + + "1++++", + "1+-+-+", + "1===", + "1====", + "[*][*][*][*][*]", + + "var v[1] := {}; var s0appe0 := false; repeat s0appe0 false for(){(){}}", + "var v[2] := {}; repeat var s0appe0 := false; s0appe0 false for(){(){}}", + "var v[3] := {}; repeat var s0appe0 := false; for(){(){}} s0appe0 false", + "var v[4] := {}; repeat var s0appe0 := false; s0appe0 for(){(){}} false", + "var v[5] := {}; repeat for(){(){}} var s0appe0 := false; s0appe0 false", + "var v{};v ;v 60;v 60;v o5" }; const std::size_t invalid_expr_size = sizeof(invalid_expr) / sizeof(std::string); @@ -2812,9 +2855,9 @@ { for (std::size_t i = 0; i < invalid_expr_size; ++i) { - exprtk::symbol_table<T> symbol_table; - - exprtk::expression<T> expression; + symbol_table_t symbol_table; + expression_t expression; + parser_t parser; T x = T(0); std::string s; @@ -2824,8 +2867,6 @@ 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", @@ -2841,14 +2882,13 @@ std::string s; std::vector<T> v(10, T(1.234)); - exprtk::symbol_table<T> symbol_table; + symbol_table_t symbol_table; + parser_t parser; 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; @@ -2862,6 +2902,64 @@ } } } + + { + const std::string base_expression = + "1+(2+2(3+3(4+4cos(((((a+((x*(e-tan((cos((((((b/(tan(((1.60*a)-0.34))-0.76))-x)+y)-3.27)+a))/pi))))^a))+y)*b)-e))+e)/z)+w)+" + "(((b+(a/((((tan((b*((((((a-(cos((cos(tan(((a+a)*3.33)))-b))/2.52))*x)/b)+3.07)^0.86)+b)))*3.95)/0.39)*y)+a)))*a)*z)"; + + const std::string mod = + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789^+-/*,;:<>=%?[]{}() #&'\"\\\t\r\n"; + + symbol_table_t symbol_table; + expression_t expression; + parser_t parser; + + T a = T(1.1 ); + T b = T(2.2 ); + T c = T(3.3 ); + T d = T(4.5 ); + T e = T(4.5 ); + T x = T(2.123456); + T y = T(3.123456); + T z = T(4.123456); + T w = T(5.123456); + + symbol_table.add_variable("a", a); + symbol_table.add_variable("b", b); + symbol_table.add_variable("c", c); + symbol_table.add_variable("d", d); + symbol_table.add_variable("e", e); + + symbol_table.add_variable("x", x); + symbol_table.add_variable("y", y); + symbol_table.add_variable("z", z); + symbol_table.add_variable("w", w); + + expression.register_symbol_table(symbol_table); + + T total = T(0); + + for (std::size_t j = 0; j < base_expression.size(); ++j) + { + std::string expression_str = base_expression; + const char old_c = base_expression[j]; + + for (std::size_t i = 0; i < mod.size(); ++i) + { + expression_str[j] = mod[i]; + + if (parser.compile(expression_str, expression)) + { + total += expression.value(); + } + } + + expression_str[j] = old_c; + } + + if (total == T(12345.6789)) { printf(" "); } + } } return true; @@ -4153,6 +4251,62 @@ } { + const std::string expression = + "for (var i := 0; i < min(x[],y[],z[]); i += 1)" + "{ z[i] := 3sin(x[i]) + 2log(y[i]); }"; + + std::vector<std::string> var_symbol_list; + std::vector<std::string> func_symbol_list; + + if (!exprtk::collect_variables(expression, var_symbol_list)) + { + printf("run_test10() - Failed to collect variables.\n"); + return false; + } + + if (!exprtk::collect_functions(expression, func_symbol_list)) + { + printf("run_test10() - Failed to collect functions.\n"); + return false; + } + + std::sort(var_symbol_list .begin(), var_symbol_list .end()); + std::sort(func_symbol_list.begin(), func_symbol_list.end()); + + std::vector<std::string> expected_var_symbol_list; + std::vector<std::string> expected_func_symbol_list; + + expected_var_symbol_list.push_back("i"); + expected_var_symbol_list.push_back("x"); + expected_var_symbol_list.push_back("y"); + expected_var_symbol_list.push_back("z"); + + expected_func_symbol_list.push_back("log"); + expected_func_symbol_list.push_back("min"); + expected_func_symbol_list.push_back("sin"); + + const bool var_result = (var_symbol_list.size() == expected_var_symbol_list.size()) && + std::equal(var_symbol_list.begin(), + var_symbol_list.end(), + expected_var_symbol_list.begin()); + if (!var_result) + { + printf("run_test10() - Failed collected variable comparison between recieved and expected variables\n"); + return false; + } + + const bool func_result = (func_symbol_list.size() == expected_func_symbol_list.size()) && + std::equal(func_symbol_list.begin(), + func_symbol_list.end(), + expected_func_symbol_list.begin()); + if (!func_result) + { + printf("run_test10() - Failed collected fuctions comparison between recieved and expected functions\n"); + return false; + } + } + + { std::string expression_list[] = { "var x; 1", @@ -5656,6 +5810,109 @@ } }; +template <typename T> +struct vecrebase_func : public exprtk::igeneric_function<T> +{ + typedef typename exprtk::igeneric_function<T>::parameter_list_t + parameter_list_t; + + typedef typename exprtk::igeneric_function<T>::generic_type + generic_type; + + typedef typename generic_type::vector_view vector_t; + + using exprtk::igeneric_function<T>::operator(); + + vecrebase_func() + : exprtk::igeneric_function<T>("V") + {} + + inline T operator()(parameter_list_t params) + { + vector_t v(params[0]); + return std::accumulate(v.begin(), v.end(), T(0)); + } +}; + +template <typename T> +struct overload_func : exprtk::igeneric_function<T> +{ + typedef typename exprtk::igeneric_function<T> igfun_t; + typedef typename igfun_t::parameter_list_t parameter_list_t; + typedef typename igfun_t::generic_type generic_type; + typedef typename generic_type::vector_view vector_t; + + using exprtk::igeneric_function<T>::operator(); + + overload_func(const std::string& param_seq_list) + : exprtk::igeneric_function<T>(param_seq_list, igfun_t::e_rtrn_overload), + current_ps_index(std::numeric_limits<std::size_t>::max()) + { + clear(); + } + + void clear() + { + current_ps_index = std::numeric_limits<std::size_t>::max(); + current_param_seq = ""; + } + + inline T operator()(const std::size_t& ps_index, + parameter_list_t parameters) + { + current_ps_index = ps_index; + determine_param_seq(parameters); + return T(1); + } + + inline T operator()(const std::size_t& ps_index, + std::string& result, + parameter_list_t parameters) + { + current_ps_index = ps_index; + determine_param_seq(parameters); + result = "string result"; + return T(1); + } + + void determine_param_seq(parameter_list_t parameters) + { + current_param_seq = ""; + + for (std::size_t i = 0; i < parameters.size(); ++i) + { + generic_type& gt = parameters[i]; + + switch (gt.type) + { + case generic_type::e_scalar : current_param_seq += "T"; + break; + + case generic_type::e_vector : current_param_seq += "V"; + break; + + case generic_type::e_string : current_param_seq += "S"; + break; + + default : continue; + } + } + } + + std::size_t current_ps_index; + std::string current_param_seq; + + struct test_result_t + { + test_result_t(const std::size_t psi, const std::string& ps) + : ps_index(psi), + param_seq(ps) + {} + + std::size_t ps_index; + std::string param_seq; + }; +}; template <typename T> inline bool run_test18() @@ -6595,6 +6852,68 @@ } { + typedef exprtk::symbol_table<T> symbol_table_t; + typedef exprtk::expression<T> expression_t; + typedef exprtk::parser<T> parser_t; + + T v0[] = { T(0), T(1), T(2), T(3), T(4) }; + T v1[] = { T(5), T(6), T(7), T(8), T(9) }; + + const std::size_t v0_size = sizeof(v0) / sizeof (T); + const std::size_t v1_size = sizeof(v1) / sizeof (T); + + exprtk::vector_view<T> v = exprtk::make_vector_view(v0, v0_size); + + vecrebase_func<T> vec_sum; + + symbol_table_t symbol_table; + symbol_table.add_vector("v",v); + symbol_table.add_function("vec_sum",vec_sum); + + expression_t expression; + expression.register_symbol_table(symbol_table); + + parser_t parser; + + const std::string expr_string = "vec_sum(v)"; + + if (!parser.compile(expr_string,expression)) + { + printf("run_test18() - Error: %s\tExpression: %s\n", + parser.error().c_str(), + expr_string.c_str()); + + return false; + } + + const T expected_result0 = std::accumulate(v0, v0 + v0_size,T(0)); + + if (expression.value() != expected_result0) + { + printf("run_test18() - Error in evaluation! (10.1) Expression: %s Expected: %5.3f Computed: %5.3f\n", + expr_string.c_str(), + expected_result0, + expression.value()); + + return false; + } + + v.rebase(v1); + + const T expected_result1 = std::accumulate(v1, v1 + v1_size,T(0)); + + if (expression.value() != expected_result1) + { + printf("run_test18() - Error in evaluation! (10.2) Expression: %s Expected: %5.3f Computed: %5.3f\n", + expr_string.c_str(), + expected_result1, + expression.value()); + + return false; + } + } + + { bool failure = false; typedef exprtk::symbol_table<T> symbol_table_t; @@ -6726,7 +7045,7 @@ if (result != T(1)) { - printf("run_test18() - Error in evaluation! (10) Expression: %s\n", + printf("run_test18() - Error in evaluation! (11) Expression: %s\n", expr_str_list[i].c_str()); failure = true; @@ -6737,6 +7056,295 @@ return false; } + { + typedef exprtk::expression<T> expression_t; + + std::string a = "a"; + std::string b = "b"; + std::string c = "c"; + std::string d = "d"; + + T x = T(1.1); + T y = T(2.2); + T z = T(3.3); + T w = T(4.4); + + overload_func<T> ovrld_func + ( + "T:T|T:TT|T:TTT|T:TTTT|" + "T:S|T:SS|T:SSS|T:SSSS|" + "T:ST|T:STS|T:STST|" + "T:TS|T:TST|T:TSTS|" + "T:TTSS|T:SSTT|T:STTS|T:TSST" + ); + + exprtk::symbol_table<T> symbol_table; + + symbol_table.add_constants(); + symbol_table.add_variable ("x",x); + symbol_table.add_variable ("y",y); + symbol_table.add_variable ("z",z); + symbol_table.add_variable ("w",w); + + symbol_table.add_stringvar("a",a); + symbol_table.add_stringvar("b",b); + symbol_table.add_stringvar("c",c); + symbol_table.add_stringvar("d",d); + + symbol_table.add_function("foo",ovrld_func); + + typedef typename overload_func<T>::test_result_t test_result_t; + typedef std::pair<std::string, typename overload_func<T>::test_result_t> test_pack_t; + + static const test_pack_t test_pack_list[] = + { + test_pack_t("foo(x)" , test_result_t( 0, "T" )), + test_pack_t("foo(x, y)" , test_result_t( 1, "TT" )), + test_pack_t("foo(x, y, z)" , test_result_t( 2, "TTT" )), + test_pack_t("foo(x, y, z, w)" , test_result_t( 3, "TTTT")), + test_pack_t("foo(x + y)" , test_result_t( 0, "T" )), + test_pack_t("foo(x + y, y + z)" , test_result_t( 1, "TT" )), + test_pack_t("foo(x + y, y + z, z + w)" , test_result_t( 2, "TTT" )), + test_pack_t("foo(x + y, y + z, z + w, w)" , test_result_t( 3, "TTTT")), + test_pack_t("foo(a)" , test_result_t( 4, "S" )), + test_pack_t("foo(a, b)" , test_result_t( 5, "SS" )), + test_pack_t("foo(a, b, c)" , test_result_t( 6, "SSS" )), + test_pack_t("foo(a, b, c, d)" , test_result_t( 7, "SSSS")), + test_pack_t("foo(a + b)" , test_result_t( 4, "S" )), + test_pack_t("foo(a + b, b + c)" , test_result_t( 5, "SS" )), + test_pack_t("foo(a + b, b + c, c + d)" , test_result_t( 6, "SSS" )), + test_pack_t("foo(a + b, b + c, c + d, d)" , test_result_t( 7, "SSSS")), + test_pack_t("foo(a, x)" , test_result_t( 8, "ST" )), + test_pack_t("foo(a, x, b)" , test_result_t( 9, "STS" )), + test_pack_t("foo(a, x, b, y)" , test_result_t(10, "STST")), + test_pack_t("foo(a + b, x + y)" , test_result_t( 8, "ST" )), + test_pack_t("foo(a + b, x + y, b + c)" , test_result_t( 9, "STS" )), + test_pack_t("foo(a + b, x + y, b + c, y + z)" , test_result_t(10, "STST")), + test_pack_t("foo(x, a)" , test_result_t(11, "TS" )), + test_pack_t("foo(x, a, y)" , test_result_t(12, "TST" )), + test_pack_t("foo(x, a, y, b)" , test_result_t(13, "TSTS")), + test_pack_t("foo(x + y, a + b)" , test_result_t(11, "TS" )), + test_pack_t("foo(x + y, a + b, y + z)" , test_result_t(12, "TST" )), + test_pack_t("foo(x + y, a + b, y + z, b + c)" , test_result_t(13, "TSTS")), + test_pack_t("foo(x, y, a, b)" , test_result_t(14, "TTSS")), + test_pack_t("foo(a, b, x, y)" , test_result_t(15, "SSTT")), + test_pack_t("foo(a, x, y, b)" , test_result_t(16, "STTS")), + test_pack_t("foo(x, a, b, y)" , test_result_t(17, "TSST")), + test_pack_t("foo(x + y, y + z, a + b, b + c)" , test_result_t(14, "TTSS")), + test_pack_t("foo(a + b, b + c, x + y, y + z)" , test_result_t(15, "SSTT")), + test_pack_t("foo(a + b, x + y, y + z, b + c)" , test_result_t(16, "STTS")), + test_pack_t("foo(x + y, a + b, b + c, y + z)" , test_result_t(17, "TSST")) + }; + + static const std::size_t test_pack_list_size = sizeof(test_pack_list) / sizeof(test_pack_t); + + std::deque<expression_t> expression_list; + + for (std::size_t i = 0; i < test_pack_list_size; ++i) + { + expression_t expression; + expression.register_symbol_table(symbol_table); + + exprtk::parser<T> parser; + + if (!parser.compile(test_pack_list[i].first, expression)) + { + printf("run_test18() - (12) Overload VarArg Error: %s Expression: %s\n", + parser.error().c_str(), + test_pack_list[i].first.c_str()); + + return false; + } + else + expression_list.push_back(expression); + } + + bool failure = false; + + for (std::size_t i = 0; i < expression_list.size(); ++i) + { + ovrld_func.clear(); + + if (T(1) != expression_list[i].value()) + { + printf("run_test18() - Error in evaluation! (12) Expression: %s\n", + test_pack_list[i].first.c_str()); + + failure = true; + } + + if (ovrld_func.current_ps_index != test_pack_list[i].second.ps_index) + { + printf("run_test18() - Error with ps_index (12) Expression: %s Expected: %d Got: %d\n", + test_pack_list[i].first.c_str(), + static_cast<int>(test_pack_list[i].second.ps_index), + static_cast<int>(ovrld_func.current_ps_index)); + + failure = true; + } + + if (ovrld_func.current_param_seq != test_pack_list[i].second.param_seq) + { + printf("run_test18() - Error with parameter seq (12) Expression: %s Expected: %s Got: %s\n", + test_pack_list[i].first.c_str(), + test_pack_list[i].second.param_seq.c_str(), + ovrld_func.current_param_seq.c_str()); + + failure = true; + } + ::fflush(stdout); + } + + if (failure) + return false; + } + + { + typedef exprtk::expression<T> expression_t; + + std::string a = "a"; + std::string b = "b"; + std::string c = "c"; + std::string d = "d"; + std::string result = ""; + + T x = T(1.1); + T y = T(2.2); + T z = T(3.3); + T w = T(4.4); + + overload_func<T> ovrld_func + ( + "S:T|S:TT|S:TTT|S:TTTT|" + "S:S|S:SS|S:SSS|S:SSSS|" + "S:ST|S:STS|S:STST|" + "S:TS|S:TST|S:TSTS|" + "S:TTSS|S:SSTT|S:STTS|S:TSST" + ); + + exprtk::symbol_table<T> symbol_table; + + symbol_table.add_constants(); + symbol_table.add_variable ("x",x); + symbol_table.add_variable ("y",y); + symbol_table.add_variable ("z",z); + symbol_table.add_variable ("w",w); + + symbol_table.add_stringvar("a",a); + symbol_table.add_stringvar("b",b); + symbol_table.add_stringvar("c",c); + symbol_table.add_stringvar("d",d); + symbol_table.add_stringvar("result",result); + + symbol_table.add_function("foo",ovrld_func); + + typedef typename overload_func<T>::test_result_t test_result_t; + typedef std::pair<std::string, typename overload_func<T>::test_result_t> test_pack_t; + + static const test_pack_t test_pack_list[] = + { + test_pack_t("result := foo(x)" , test_result_t( 0, "T" )), + test_pack_t("result := foo(x, y)" , test_result_t( 1, "TT" )), + test_pack_t("result := foo(x, y, z)" , test_result_t( 2, "TTT" )), + test_pack_t("result := foo(x, y, z, w)" , test_result_t( 3, "TTTT")), + test_pack_t("result := foo(x + y)" , test_result_t( 0, "T" )), + test_pack_t("result := foo(x + y, y + z)" , test_result_t( 1, "TT" )), + test_pack_t("result := foo(x + y, y + z, z + w)" , test_result_t( 2, "TTT" )), + test_pack_t("result := foo(x + y, y + z, z + w, w)" , test_result_t( 3, "TTTT")), + test_pack_t("result := foo(a)" , test_result_t( 4, "S" )), + test_pack_t("result := foo(a, b)" , test_result_t( 5, "SS" )), + test_pack_t("result := foo(a, b, c)" , test_result_t( 6, "SSS" )), + test_pack_t("result := foo(a, b, c, d)" , test_result_t( 7, "SSSS")), + test_pack_t("result := foo(a + b)" , test_result_t( 4, "S" )), + test_pack_t("result := foo(a + b, b + c)" , test_result_t( 5, "SS" )), + test_pack_t("result := foo(a + b, b + c, c + d)" , test_result_t( 6, "SSS" )), + test_pack_t("result := foo(a + b, b + c, c + d, d)" , test_result_t( 7, "SSSS")), + test_pack_t("result := foo(a, x)" , test_result_t( 8, "ST" )), + test_pack_t("result := foo(a, x, b)" , test_result_t( 9, "STS" )), + test_pack_t("result := foo(a, x, b, y)" , test_result_t(10, "STST")), + test_pack_t("result := foo(a + b, x + y)" , test_result_t( 8, "ST" )), + test_pack_t("result := foo(a + b, x + y, b + c)" , test_result_t( 9, "STS" )), + test_pack_t("result := foo(a + b, x + y, b + c, y + z)" , test_result_t(10, "STST")), + test_pack_t("result := foo(x, a)" , test_result_t(11, "TS" )), + test_pack_t("result := foo(x, a, y)" , test_result_t(12, "TST" )), + test_pack_t("result := foo(x, a, y, b)" , test_result_t(13, "TSTS")), + test_pack_t("result := foo(x + y, a + b)" , test_result_t(11, "TS" )), + test_pack_t("result := foo(x + y, a + b, y + z)" , test_result_t(12, "TST" )), + test_pack_t("result := foo(x + y, a + b, y + z, b + c)" , test_result_t(13, "TSTS")), + test_pack_t("result := foo(x, y, a, b)" , test_result_t(14, "TTSS")), + test_pack_t("result := foo(a, b, x, y)" , test_result_t(15, "SSTT")), + test_pack_t("result := foo(a, x, y, b)" , test_result_t(16, "STTS")), + test_pack_t("result := foo(x, a, b, y)" , test_result_t(17, "TSST")), + test_pack_t("result := foo(x + y, y + z, a + b, b + c)" , test_result_t(14, "TTSS")), + test_pack_t("result := foo(a + b, b + c, x + y, y + z)" , test_result_t(15, "SSTT")), + test_pack_t("result := foo(a + b, x + y, y + z, b + c)" , test_result_t(16, "STTS")), + test_pack_t("result := foo(x + y, a + b, b + c, y + z)" , test_result_t(17, "TSST")) + }; + + static const std::size_t test_pack_list_size = sizeof(test_pack_list) / sizeof(test_pack_t); + + std::deque<expression_t> expression_list; + + for (std::size_t i = 0; i < test_pack_list_size; ++i) + { + expression_t expression; + expression.register_symbol_table(symbol_table); + + exprtk::parser<T> parser; + + if (!parser.compile(test_pack_list[i].first, expression)) + { + printf("run_test18() - (13) Overload VarArg Error: %s Expression: %s\n", + parser.error().c_str(), + test_pack_list[i].first.c_str()); + + return false; + } + else + expression_list.push_back(expression); + } + + bool failure = false; + + for (std::size_t i = 0; i < expression_list.size(); ++i) + { + ovrld_func.clear(); + result = ""; + expression_list[i].value(); + + if (result != "string result") + { + printf("run_test18() - Error in evaluation! (13) Expression: %s\n", + test_pack_list[i].first.c_str()); + + failure = true; + } + + if (ovrld_func.current_ps_index != test_pack_list[i].second.ps_index) + { + printf("run_test18() - Error with ps_index (13) Expression: %s Expected: %d Got: %d\n", + test_pack_list[i].first.c_str(), + static_cast<int>(test_pack_list[i].second.ps_index), + static_cast<int>(ovrld_func.current_ps_index)); + + failure = true; + } + + if (ovrld_func.current_param_seq != test_pack_list[i].second.param_seq) + { + printf("run_test18() - Error with parameter seq (13) Expression: %s Expected: %s Got: %s\n", + test_pack_list[i].first.c_str(), + test_pack_list[i].second.param_seq.c_str(), + ovrld_func.current_param_seq.c_str()); + + failure = true; + } + } + + if (failure) + return false; + } + return true; } @@ -7904,6 +8512,126 @@ } } + { + T var; + std::string str; + std::vector<T> vec(10,0.0); + + typedef exprtk::symbol_table<T> symbol_table_t; + + bool result = true; + + { + symbol_table_t symbol_table; + + symbol_table.add_variable ("val",var); + symbol_table.add_stringvar("str",str); + symbol_table.add_vector ("vec",vec); + + if (symbol_table.get_variable("val") == 0 || !symbol_table.symbol_exists("val")) + { + printf("run_test20() - [3] Failed to get 'val' from symbol_table\n"); + result = false; + } + + if (symbol_table.get_stringvar("str") == 0 || !symbol_table.symbol_exists("str")) + { + printf("run_test20() - [3] Failed to get 'str' from symbol_table\n"); + result = false; + } + + if (symbol_table.get_vector("vec") == 0 || !symbol_table.symbol_exists("vec")) + { + printf("run_test20() - [3] Failed to get 'vec' from symbol_table\n"); + result = false; + } + } + + if (!result) + return result; + + { + symbol_table_t symbol_table; + + symbol_table.add_variable("val",var); + + if (symbol_table.get_variable("val") == 0 || !symbol_table.symbol_exists("val")) + { + printf("run_test20() - [4] Failed to get 'val' from symbol_table\n"); + result = false; + } + + if (symbol_table.get_stringvar("str") != 0 || symbol_table.symbol_exists("str")) + { + printf("run_test20() - [4] Failed to get 'str' from symbol_table\n"); + result = false; + } + + if (symbol_table.get_vector("vec") != 0 || symbol_table.symbol_exists("vec")) + { + printf("run_test20() - [4] Failed to get 'vec' from symbol_table\n"); + result = false; + } + } + + if (!result) + return result; + + { + symbol_table_t symbol_table; + + symbol_table.add_stringvar("str",str); + + if (symbol_table.get_stringvar("str") == 0 || !symbol_table.symbol_exists("str")) + { + printf("run_test20() - [5] Failed to get 'str' from symbol_table\n"); + result = false; + } + + if (symbol_table.get_variable("val") != 0 || symbol_table.symbol_exists("val")) + { + printf("run_test20() - [5] Failed to get 'val' from symbol_table\n"); + result = false; + } + + if (symbol_table.get_vector("vec") != 0 || symbol_table.symbol_exists("vec")) + { + printf("run_test20() - [5] Failed to get 'vec' from symbol_table\n"); + result = false; + } + } + + if (!result) + return result; + + { + symbol_table_t symbol_table; + + symbol_table.add_vector("vec",vec); + + if (symbol_table.get_vector("vec") == 0 || !symbol_table.symbol_exists("vec")) + { + printf("run_test20() - [6] Failed to get 'vec' from symbol_table\n"); + result = false; + } + + if (symbol_table.get_variable("val") != 0 || symbol_table.symbol_exists("val")) + { + printf("run_test20() - [6] Failed to get 'val' from symbol_table\n"); + result = false; + } + + if (symbol_table.get_stringvar("str") != 0 || symbol_table.symbol_exists("str")) + { + printf("run_test20() - [6] Failed to get 'str' from symbol_table\n"); + result = false; + } + } + + if (!result) + return result; + } + return true; }
diff --git a/readme.txt b/readme.txt index f3c2254..65b812f 100644 --- a/readme.txt +++ b/readme.txt
@@ -428,8 +428,8 @@ | [r0:r1] | The closed interval [r0,r1] of the specified string. | | | eg: Given a string x with a value of 'abcdefgh' then: | | | 1. x[1:4] == 'bcde' | -| | 2. x[ :5] == x[:5] == 'abcdef' | -| | 3. x[3: ] == x[3:] =='cdefgh' | +| | 2. x[ :5] == x[:10 / 2] == 'abcdef' | +| | 3. x[2 + 1: ] == x[3:] =='defgh' | | | 4. x[ : ] == x[:] == 'abcdefgh' | | | 5. x[4/2:3+2] == x[2:5] == 'cdef' | | | | @@ -706,6 +706,61 @@ the expression instance and to also allow the expression to be evaluated using the current value of the element. +Note: Any variable reference provided to a given symbol_table +instance, must have a life time at least as long as the life-time of +the symbol_table instance. In the event the variable reference is +invalidated before the symbol_table or any dependent expression +instances have been destructed, then any associated expression +evaluations or variable referencing via the symbol_table instance will +result in undefined behaviour. + +The following bit of code instantiates a symbol_table and expression +instance, then proceeds to demonstrate various ways in which +references to variables can be added to the symbol_table, and how +those references are subsequently invalidated resulting in various +forms of undefined behaviour. + + typedef exprtk::symbol_table<double> symbol_table_t; + + symbol_table_t symbol_table; + expression_t expression; + + { + double x = 123.4567; + symbol_table.add_variable("x", x); + } // Reference to variable x has been invalidated + + std::deque<double> y {1.1, 2.2, 3.3}; + + symbol_table.add_variable("y", y.back()); + + y.pop_back(); // Reference to variable y has been invalidated + + std::vector<double> z {4.4, 5.5, 6.6}; + + symbol_table.add_variable("z", z.front()); + + z.erase(z.begin()); + // Reference to variable z has been invalidated + + double* w = new double(123.456); + + symbol_table.add_variable("w", *w); + + delete w; // Reference to variable w has been invalidated + + const std::string expression_str = "x + y / z * w"; + + // Compilation of expression will succeed + parser.compile(expression_str,expression); + + expression.value(); + // Evaluation will result in undefined behaviour + + symbol_table.get_variable("x")->ref() = 135.791; + // Assignment will result in undefined behaviour + + The example below demonstrates the relationship between variables, symbol_table and expression. Note the variables are modified as they normally would in a program, and when the expression is evaluated the @@ -865,7 +920,7 @@ Generally an expression in ExprTk can be thought of as a free function similar to those found in imperative languages. This form of pseudo function will have a name, it may have a set of one or more inputs and -will return at least one value as its result. Futhermore the function +will return at least one value as its result. Furthermore the function when invoked, may cause a side-effect that changes the state of the host program. @@ -968,7 +1023,7 @@ utilizing the exact same references for variables. This obviously is not the default assumed scenario and will give rise to non-obvious behaviours when using the expressions in various contexts such as -muli-threading et al. +multi-threading et al. The prescribed method for cloning an expression is to compile it from its string form. Doing so will allow the 'user' to properly consider @@ -1260,7 +1315,7 @@ (b) Invoking a user-defined function that has side-effects The following are examples of expressions where the side-effect status -of the statements (or sub-exressions) within the expressions have been +of the statements (sub-expressions) within the expressions have been noted: +-+----------------------+------------------------------+ @@ -1814,15 +1869,16 @@ There are five types of function interface: - +---+----------------------+-------------+----------------------+ - | # | Name | Return Type | Input Types | - +---+----------------------+-------------+----------------------+ - | 1 | ifunction | Scalar | Scalar | - | 2 | ivararg_function | Scalar | Scalar | - | 3 | igeneric_function | Scalar | Scalar,Vector,String | - | 4 | igeneric_function II | String | Scalar,Vector,String | - | 5 | function_compositor | Scalar | Scalar | - +---+----------------------+-------------+----------------------+ + +---+----------------------+--------------+----------------------+ + | # | Name | Return Type | Input Types | + +---+----------------------+--------------+----------------------+ + | 1 | ifunction | Scalar | Scalar | + | 2 | ivararg_function | Scalar | Scalar | + | 3 | igeneric_function | Scalar | Scalar,Vector,String | + | 4 | igeneric_function II | String | Scalar,Vector,String | + | 5 | igeneric_function III| String/Scalar| Scalar,Vector,String | + | 6 | function_compositor | Scalar | Scalar | + +---+----------------------+--------------+----------------------+ (1) ifunction This interface supports zero to 20 input parameters of only the scalar @@ -2198,7 +2254,60 @@ (4) Scalar (4) String -(5) function_compositor +(5) igeneric_function III +In this section we will discuss an extension of the igeneric_function +interface that will allow for the overloading of a user defined custom +function, where by it can return either a scalar or string value type +depending on the input parameter sequence with which the function is +invoked. + + template <typename T> + struct foo : public exprtk::igeneric_function<T> + { + typedef typename exprtk::igeneric_function<T>::parameter_list_t + parameter_list_t; + + foo() + : exprtk::igeneric_function<T> + ( + "T:T|S:TS", + igfun_t::e_rtrn_overload + ) + {} + + // Scalar value returning invocations + inline T operator()(const std::size_t& ps_index, + parameter_list_t parameters) + { + ... + } + + // String value returning invocations + inline T operator()(const std::size_t& ps_index, + std::string& result, + parameter_list_t& parameters) + { + ... + } + }; + + +In the example above the custom user defined function "foo" can be +invoked by using either one of two input parameter sequences, which +are defined as follows: + + Sequence-0 Sequence-1 + 'T' -> T 'TS' -> S + (1) Scalar (1) Scalar + (2) String + + +The parameter sequence definitions are identical to the previously +define igeneric_function, with the exception of the inclusion of the +return type - which can only be either a scalar T or a string S. + + +(6) function_compositor The function compositor is a factory that allows one to define and construct a function using ExprTk syntax. The functions are limited to returning a single scalar value and consuming up to six parameters as @@ -2715,7 +2824,7 @@ This can become problematic, as in the default scenario it is assumed the symbol_table that is registered with the expression instance will -already posses the externally available variables, functions and +already possess the externally available variables, functions and constants needed during the compilation of the expression. In the event there are symbols in the expression that can't be mapped @@ -2838,7 +2947,7 @@ for (auto& var_name : variable_list) { - T& v = symbol_table.variable_ref(var_name); + T& v = unknown_var_symbol_table.variable_ref(var_name); v = ...; } @@ -2999,6 +3108,24 @@ Note: The primary symbol table for an expression is the first symbol table to be registered with that instance of the expression. +Note: For a successful symbol resolution using the normal USR all of +the following are required: + + (1) Only if successful shall the process method return TRUE + (2) The default_value parameter will have been set + (3) The error_message parameter will be empty + (4) usr_symbol_type input parameter field will be set to either: + (*) e_usr_variable_type + (*) e_usr_constant_type + +Note: For a successful symbol resolution using the extended USR all of +the following are required: + + (1) Only if successful shall the process method return TRUE + (2) symbol_table parameter will have had the newly resolved + variable or string added to it + (3) error_message parameter will be empty + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [SECTION 19 - ENABLING & DISABLING FEATURES] @@ -3716,7 +3843,7 @@ } } else - printf("An error occured."); + printf("An error occurred."); (b) collect_functions @@ -3740,7 +3867,7 @@ } } else - printf("An error occured."); + printf("An error occurred."); Note: When either the 'collect_variables' or 'collect_functions' free @@ -3752,10 +3879,10 @@ Note: The default interface provided for both the collect_variables and collect_functions free_functions, assumes that expressions will -only be utilising the ExprTk reserved funnctions (eg: abs, cos, min +only be utilising the ExprTk reserved functions (eg: abs, cos, min etc). When user defined functions are to be used in an expression, a symbol_table instance containing said functions can be passed to -either routine, and will be incorparated during the compilation and +either routine, and will be incorporated during the compilation and Dependent Entity Collection processes. In the following example, a user defined free function named 'foo' is registered with a symbol_table. Finally the symbol_table instance and associated @@ -3785,7 +3912,7 @@ } } else - printf("An error occured."); + printf("An error occurred."); (c) compute