C++ Mathematical Expression Library (ExprTk) https://www.partow.net/programming/exprtk/index.html
diff --git a/exprtk.hpp b/exprtk.hpp index 2da41d8..67752a2 100644 --- a/exprtk.hpp +++ b/exprtk.hpp
@@ -64,6 +64,23 @@ #define exprtk_debug(params) (void)0 #endif + #define exprtk_error_location \ + "exprtk.hpp:" + details::to_str(__LINE__) \ + + #if __GNUC__ >= 7 + + #define exprtk_disable_fallthrough_begin \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wimplicit-fallthrough\"") \ + + #define exprtk_disable_fallthrough_end \ + _Pragma ("GCC diagnostic pop") \ + + #else + #define exprtk_disable_fallthrough_begin (void)0; + #define exprtk_disable_fallthrough_end (void)0; + #endif + namespace details { typedef unsigned char uchar_t; @@ -144,8 +161,10 @@ #ifndef exprtk_disable_caseinsensitivity inline void case_normalise(std::string& s) { - std::transform - (s.begin(), s.end(), s.begin(), static_cast<int(*)(int)>(std::tolower)); + for (std::size_t i = 0; i < s.size(); ++i) + { + s[i] = static_cast<std::string::value_type>(std::tolower(s[i])); + } } inline bool imatch(const char_t c1, const char_t c2) @@ -173,7 +192,7 @@ struct ilesscompare { - inline bool operator()(const std::string& s1, const std::string& s2) const + inline bool operator() (const std::string& s1, const std::string& s2) const { const std::size_t length = std::min(s1.size(),s2.size()); @@ -208,7 +227,7 @@ struct ilesscompare { - inline bool operator()(const std::string& s1, const std::string& s2) const + inline bool operator() (const std::string& s1, const std::string& s2) const { return s1 < s2; } @@ -264,6 +283,11 @@ return result; } + inline std::string to_str(std::size_t i) + { + return to_str(static_cast<int>(i)); + } + inline bool is_hex_digit(const std::string::value_type digit) { return (('0' <= digit) && (digit <= '9')) || @@ -473,7 +497,7 @@ { for (std::size_t i = 0; i < reserved_words_size; ++i) { - if (imatch(symbol,reserved_words[i])) + if (imatch(symbol, reserved_words[i])) { return true; } @@ -486,7 +510,7 @@ { for (std::size_t i = 0; i < reserved_symbols_size; ++i) { - if (imatch(symbol,reserved_symbols[i])) + if (imatch(symbol, reserved_symbols[i])) { return true; } @@ -499,7 +523,7 @@ { for (std::size_t i = 0; i < base_function_list_size; ++i) { - if (imatch(function_name,base_function_list[i])) + if (imatch(function_name, base_function_list[i])) { return true; } @@ -512,7 +536,7 @@ { for (std::size_t i = 0; i < cntrl_struct_list_size; ++i) { - if (imatch(cntrl_strct,cntrl_struct_list[i])) + if (imatch(cntrl_strct, cntrl_struct_list[i])) { return true; } @@ -525,7 +549,7 @@ { for (std::size_t i = 0; i < logic_ops_list_size; ++i) { - if (imatch(lgc_opr,logic_ops_list[i])) + if (imatch(lgc_opr, logic_ops_list[i])) { return true; } @@ -729,23 +753,29 @@ namespace details { - struct unknown_type_tag {}; - struct real_type_tag {}; - struct complex_type_tag {}; - struct int_type_tag {}; + struct unknown_type_tag { unknown_type_tag() {} }; + struct real_type_tag { real_type_tag () {} }; + struct complex_type_tag { complex_type_tag() {} }; + struct int_type_tag { int_type_tag () {} }; template <typename T> - struct number_type { typedef unknown_type_tag type; }; + struct number_type + { + typedef unknown_type_tag type; + number_type() {} + }; - #define exprtk_register_real_type_tag(T) \ - template<> struct number_type<T> { typedef real_type_tag type; }; \ + #define exprtk_register_real_type_tag(T) \ + template<> struct number_type<T> \ + { typedef real_type_tag type; number_type() {} }; \ - #define exprtk_register_complex_type_tag(T) \ - template<> struct number_type<std::complex<T> > \ - { typedef complex_type_tag type; }; \ + #define exprtk_register_complex_type_tag(T) \ + template<> struct number_type<std::complex<T> > \ + { typedef complex_type_tag type; number_type() {} }; \ - #define exprtk_register_int_type_tag(T) \ - template<> struct number_type<T> { typedef int_type_tag type; }; \ + #define exprtk_register_int_type_tag(T) \ + template<> struct number_type<T> \ + { typedef int_type_tag type; number_type() {} }; \ exprtk_register_real_type_tag(double ) exprtk_register_real_type_tag(long double) @@ -965,7 +995,15 @@ template <typename T> inline T root_impl(const T v0, const T v1, real_type_tag) { - return std::pow(v0,T(1) / v1); + if (v1 < T(0)) + return std::numeric_limits<T>::quiet_NaN(); + + const std::size_t n = static_cast<std::size_t>(v1); + + if ((v0 < T(0)) && (0 == (n % 2))) + return std::numeric_limits<T>::quiet_NaN(); + + return std::pow(v0, T(1) / n); } template <typename T> @@ -1278,6 +1316,9 @@ template <typename T> inline T frac_impl(const T v, real_type_tag) { return (v - static_cast<long long>(v)); } template <typename T> inline T trunc_impl(const T v, real_type_tag) { return T(static_cast<long long>(v)); } + template <typename T> inline T const_pi_impl(real_type_tag) { return numeric::constant::pi; } + template <typename T> inline T const_e_impl (real_type_tag) { return numeric::constant::e; } + template <typename T> inline T abs_impl(const T v, int_type_tag) { return ((v >= T(0)) ? v : -v); } template <typename T> inline T exp_impl(const T v, int_type_tag) { return std::exp (v); } template <typename T> inline T log_impl(const T v, int_type_tag) { return std::log (v); } @@ -1332,161 +1373,161 @@ template <typename T> inline int to_int32(const T v) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return to_int32_impl(v, num_type); } template <typename T> inline long long int to_int64(const T v) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return to_int64_impl(v, num_type); } template <typename T> inline bool is_nan(const T v) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return is_nan_impl(v, num_type); } template <typename T> inline T min(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return min_impl(v0, v1, num_type); } template <typename T> inline T max(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return max_impl(v0, v1, num_type); } template <typename T> inline T equal(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return equal_impl(v0, v1, num_type); } template <typename T> inline T nequal(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return nequal_impl(v0, v1, num_type); } template <typename T> inline T modulus(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return modulus_impl(v0, v1, num_type); } template <typename T> inline T pow(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return pow_impl(v0, v1, num_type); } template <typename T> inline T logn(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return logn_impl(v0, v1, num_type); } template <typename T> inline T root(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return root_impl(v0, v1, num_type); } template <typename T> inline T roundn(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return roundn_impl(v0, v1, num_type); } template <typename T> inline T hypot(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return hypot_impl(v0, v1, num_type); } template <typename T> inline T atan2(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return atan2_impl(v0, v1, num_type); } template <typename T> inline T shr(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return shr_impl(v0, v1, num_type); } template <typename T> inline T shl(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return shl_impl(v0, v1, num_type); } template <typename T> inline T and_opr(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return and_impl(v0, v1, num_type); } template <typename T> inline T nand_opr(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return nand_impl(v0, v1, num_type); } template <typename T> inline T or_opr(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return or_impl(v0, v1, num_type); } template <typename T> inline T nor_opr(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return nor_impl(v0, v1, num_type); } template <typename T> inline T xor_opr(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return xor_impl(v0, v1, num_type); } template <typename T> inline T xnor_opr(const T v0, const T v1) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return xnor_impl(v0, v1, num_type); } template <typename T> inline bool is_integer(const T v) { - typename details::number_type<T>::type num_type; + const typename details::number_type<T>::type num_type; return is_integer_impl(v, num_type); } @@ -1526,13 +1567,13 @@ template <typename T> struct fast_exp<T, 1> { static inline T result(T v) { return v; } }; template <typename T> struct fast_exp<T, 0> { static inline T result(T ) { return T(1); } }; - #define exprtk_define_unary_function(FunctionName) \ - template <typename T> \ - inline T FunctionName (const T v) \ - { \ - typename details::number_type<T>::type num_type; \ - return FunctionName##_impl(v,num_type); \ - } \ + #define exprtk_define_unary_function(FunctionName) \ + template <typename T> \ + inline T FunctionName (const T v) \ + { \ + const typename details::number_type<T>::type num_type; \ + return FunctionName##_impl(v,num_type); \ + } \ exprtk_define_unary_function(abs ) exprtk_define_unary_function(acos ) @@ -1663,6 +1704,7 @@ if (length <= 4) { + exprtk_disable_fallthrough_begin switch (length) { #ifdef exprtk_use_lut @@ -1696,6 +1738,7 @@ #undef exprtk_process_digit } + exprtk_disable_fallthrough_end } else return_result = false; @@ -1875,7 +1918,7 @@ { int exp = 0; - if (!details::string_to_type_converter_impl_ref(++itr,end,exp)) + if (!details::string_to_type_converter_impl_ref(++itr, end, exp)) { if (end == itr) return false; @@ -1898,11 +1941,11 @@ { if (('i' == (*itr)) || ('I' == (*itr))) { - return parse_inf(itr,end,t,negative); + return parse_inf(itr, end, t, negative); } else if (('n' == (*itr)) || ('N' == (*itr))) { - return parse_nan(itr,end,t); + return parse_nan(itr, end, t); } else return false; @@ -1914,11 +1957,11 @@ { if (('i' == (*itr)) || ('I' == (*itr))) { - return parse_inf(itr,end,t,negative); + return parse_inf(itr, end, t, negative); } else if (('n' == (*itr)) || ('N' == (*itr))) { - return parse_nan(itr,end,t); + return parse_nan(itr, end, t); } else return false; @@ -1941,9 +1984,11 @@ template <typename T> inline bool string_to_real(const std::string& s, T& t) { + const typename numeric::details::number_type<T>::type num_type; + const char_t* begin = s.data(); const char_t* end = s.data() + s.size(); - typename numeric::details::number_type<T>::type num_type; + return string_to_real(begin, end, t, num_type); } @@ -2003,13 +2048,15 @@ } template <typename Iterator> - inline token& set_operator(const token_type tt, const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0)) + inline token& set_operator(const token_type tt, + const Iterator begin, const Iterator end, + const Iterator base_begin = Iterator(0)) { type = tt; value.assign(begin,end); if (base_begin) position = static_cast<std::size_t>(std::distance(base_begin,begin)); - return *this; + return (*this); } template <typename Iterator> @@ -2019,7 +2066,7 @@ value.assign(begin,end); if (base_begin) position = static_cast<std::size_t>(std::distance(base_begin,begin)); - return *this; + return (*this); } template <typename Iterator> @@ -2029,7 +2076,7 @@ value.assign(begin,end); if (base_begin) position = static_cast<std::size_t>(std::distance(base_begin,begin)); - return *this; + return (*this); } template <typename Iterator> @@ -2039,7 +2086,7 @@ value.assign(begin,end); if (base_begin) position = static_cast<std::size_t>(std::distance(base_begin,begin)); - return *this; + return (*this); } inline token& set_string(const std::string& s, const std::size_t p) @@ -2047,11 +2094,13 @@ type = e_string; value = s; position = p; - return *this; + return (*this); } template <typename Iterator> - inline token& set_error(const token_type et, const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0)) + inline token& set_error(const token_type et, + const Iterator begin, const Iterator end, + const Iterator base_begin = Iterator(0)) { if ( (e_error == et) || @@ -2071,7 +2120,7 @@ if (base_begin) position = static_cast<std::size_t>(std::distance(base_begin,begin)); - return *this; + return (*this); } static inline std::string to_str(token_type t) @@ -2177,9 +2226,7 @@ { scan_token(); - if (token_list_.empty()) - return true; - else if (token_list_.back().is_error()) + if (!token_list_.empty() && token_list_.back().is_error()) return false; } @@ -2292,6 +2339,23 @@ return (s_end_ == itr); } + inline bool is_comment_start(const char_t* itr) + { + #ifndef exprtk_disable_comments + const char_t c0 = *(itr + 0); + const char_t c1 = *(itr + 1); + + if ('#' == c0) + return true; + else if (!is_end(itr + 1)) + { + if (('/' == c0) && ('/' == c1)) return true; + if (('/' == c0) && ('*' == c1)) return true; + } + #endif + return false; + } + inline void skip_whitespace() { while (!is_end(s_itr_) && details::is_whitespace(*s_itr_)) @@ -2321,47 +2385,72 @@ return (0 != mode); } - static inline bool comment_end(const char_t c0, const char_t c1, const int mode) + static inline bool comment_end(const char_t c0, const char_t c1, int& mode) { - return ( - ((1 == mode) && ('\n' == c0)) || - ((2 == mode) && ( '*' == c0) && ('/' == c1)) - ); + if ( + ((1 == mode) && ('\n' == c0)) || + ((2 == mode) && ( '*' == c0) && ('/' == c1)) + ) + { + mode = 0; + return true; + } + else + return false; } }; int mode = 0; int increment = 0; - if (is_end(s_itr_) || is_end((s_itr_ + 1))) + if (is_end(s_itr_)) return; - else if (!test::comment_start(*s_itr_,*(s_itr_ + 1),mode,increment)) + else if (!test::comment_start(*s_itr_, *(s_itr_ + 1), mode, increment)) return; + const char_t* cmt_start = s_itr_; + s_itr_ += increment; - while (!is_end(s_itr_) && !test::comment_end(*s_itr_,*(s_itr_ + 1),mode)) + while (!is_end(s_itr_)) { - ++s_itr_; + if ((1 == mode) && test::comment_end(*s_itr_, 0, mode)) + { + ++s_itr_; + return; + } + + if ((2 == mode)) + { + if (!is_end((s_itr_ + 1)) && test::comment_end(*s_itr_, *(s_itr_ + 1), mode)) + { + s_itr_ += 2; + return; + } + } + + ++s_itr_; } - if (!is_end(s_itr_)) + if (2 == mode) { - s_itr_ += mode; - skip_whitespace(); - skip_comments(); + token_t t; + t.set_error(token::e_error, cmt_start, cmt_start + mode, base_itr_); + token_list_.push_back(t); } #endif } inline void scan_token() { - skip_whitespace(); - - skip_comments(); - - if (is_end(s_itr_)) + if (details::is_whitespace(*s_itr_)) { + skip_whitespace(); + return; + } + else if (is_comment_start(s_itr_)) + { + skip_comments(); return; } else if (details::is_operator_char(*s_itr_)) @@ -2457,11 +2546,11 @@ } if ('<' == c0) - t.set_operator(token_t::e_lt ,s_itr_, s_itr_ + 1, base_itr_); + t.set_operator(token_t::e_lt , s_itr_, s_itr_ + 1, base_itr_); else if ('>' == c0) - t.set_operator(token_t::e_gt ,s_itr_, s_itr_ + 1, base_itr_); + t.set_operator(token_t::e_gt , s_itr_, s_itr_ + 1, base_itr_); else if (';' == c0) - t.set_operator(token_t::e_eof,s_itr_, s_itr_ + 1, base_itr_); + t.set_operator(token_t::e_eof, s_itr_, s_itr_ + 1, base_itr_); else if ('&' == c0) t.set_symbol(s_itr_, s_itr_ + 1, base_itr_); else if ('|' == c0) @@ -2816,7 +2905,7 @@ const token& t0 = g.token_list_[i ]; const token& t1 = g.token_list_[i + 1]; - if (!operator()(t0,t1)) + if (!operator()(t0, t1)) { return i; } @@ -2829,7 +2918,7 @@ const token& t1 = g.token_list_[i + 1]; const token& t2 = g.token_list_[i + 2]; - if (!operator()(t0,t1,t2)) + if (!operator()(t0, t1, t2)) { return i; } @@ -2843,7 +2932,7 @@ const token& t2 = g.token_list_[i + 2]; const token& t3 = g.token_list_[i + 3]; - if (!operator()(t0,t1,t2,t3)) + if (!operator()(t0, t1, t2, t3)) { return i; } @@ -2856,22 +2945,22 @@ return (g.token_list_.size() - stride_ + 1); } - virtual bool operator()(const token&) + virtual bool operator() (const token&) { return false; } - virtual bool operator()(const token&, const token&) + virtual bool operator() (const token&, const token&) { return false; } - virtual bool operator()(const token&, const token&, const token&) + virtual bool operator() (const token&, const token&, const token&) { return false; } - virtual bool operator()(const token&, const token&, const token&, const token&) + virtual bool operator() (const token&, const token&, const token&, const token&) { return false; } @@ -3007,7 +3096,7 @@ } } - virtual bool join(const token&, const token&, token&) { return false; } + virtual bool join(const token&, const token&, token&) { return false; } virtual bool join(const token&, const token&, const token&, token&) { return false; } private: @@ -3280,7 +3369,7 @@ return true; } - // '- -' --> '-' + // '- -' --> '+' else if ((t0.type == lexer::token::e_sub) && (t1.type == lexer::token::e_sub)) { /* @@ -3357,7 +3446,7 @@ error_token_.clear(); } - bool operator()(const lexer::token& t) + bool operator() (const lexer::token& t) { if ( !t.value.empty() && @@ -3368,7 +3457,7 @@ { details::char_t c = t.value[0]; - if (t.type == lexer::token::e_lbracket) stack_.push(std::make_pair(')',t.position)); + if (t.type == lexer::token::e_lbracket ) stack_.push(std::make_pair(')',t.position)); else if (t.type == lexer::token::e_lcrlbracket) stack_.push(std::make_pair('}',t.position)); else if (t.type == lexer::token::e_lsqrbracket) stack_.push(std::make_pair(']',t.position)); else if (exprtk::details::is_right_bracket(c)) @@ -3424,7 +3513,7 @@ current_index_ = 0; } - bool operator()(const lexer::token& t) + bool operator() (const lexer::token& t) { if (token::e_number == t.type) { @@ -3475,7 +3564,7 @@ bool remove(const std::string& target_symbol) { - replace_map_t::iterator itr = replace_map_.find(target_symbol); + const replace_map_t::iterator itr = replace_map_.find(target_symbol); if (replace_map_.end() == itr) return false; @@ -3489,7 +3578,7 @@ const std::string& replace_symbol, const lexer::token::token_type token_type = lexer::token::e_symbol) { - replace_map_t::iterator itr = replace_map_.find(target_symbol); + const replace_map_t::iterator itr = replace_map_.find(target_symbol); if (replace_map_.end() != itr) { @@ -3515,7 +3604,7 @@ if (replace_map_.empty()) return false; - replace_map_t::iterator itr = replace_map_.find(t.value); + const replace_map_t::iterator itr = replace_map_.find(t.value); if (replace_map_.end() != itr) { @@ -3550,7 +3639,6 @@ 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_string ,lexer::token::e_ternary); add_invalid_set1(lexer::token::e_assign ); add_invalid_set1(lexer::token::e_shr ); add_invalid_set1(lexer::token::e_shl ); @@ -3576,7 +3664,7 @@ return error_list_.empty(); } - bool operator()(const lexer::token& t0, const lexer::token& t1) + bool operator() (const lexer::token& t0, const lexer::token& t1) { set_t::value_type p = std::make_pair(t0.type,t1.type); @@ -3709,7 +3797,7 @@ inline bool register_scanner(lexer::token_scanner* scanner) { if (token_scanner_list.end() != std::find(token_scanner_list.begin(), - token_scanner_list.end(), + token_scanner_list.end (), scanner)) { return false; @@ -3723,7 +3811,7 @@ inline bool register_modifier(lexer::token_modifier* modifier) { if (token_modifier_list.end() != std::find(token_modifier_list.begin(), - token_modifier_list.end(), + token_modifier_list.end (), modifier)) { return false; @@ -3737,7 +3825,7 @@ inline bool register_joiner(lexer::token_joiner* joiner) { if (token_joiner_list.end() != std::find(token_joiner_list.begin(), - token_joiner_list.end(), + token_joiner_list.end (), joiner)) { return false; @@ -3751,7 +3839,7 @@ inline bool register_inserter(lexer::token_inserter* inserter) { if (token_inserter_list.end() != std::find(token_inserter_list.begin(), - token_inserter_list.end(), + token_inserter_list.end (), inserter)) { return false; @@ -4096,8 +4184,8 @@ enum store_type { e_unknown, - e_scalar, - e_vector, + e_scalar , + e_vector , e_string }; @@ -4177,6 +4265,11 @@ data_(reinterpret_cast<value_t*>(ts_.data)) {} + type_view(const type_store_t& ts) + : ts_(const_cast<type_store_t&>(ts)), + data_(reinterpret_cast<value_t*>(ts_.data)) + {} + inline std::size_t size() const { return ts_.size; @@ -4225,12 +4318,12 @@ : v_(*reinterpret_cast<value_t*>(const_cast<type_store_t&>(ts).data)) {} - inline value_t& operator()() + inline value_t& operator() () { return v_; } - inline const value_t& operator()() const + inline const value_t& operator() () const { return v_; } @@ -4456,7 +4549,7 @@ { details(const std::size_t& vsize, const unsigned int loop_batch_size = global_loop_batch_size) - : batch_size(loop_batch_size), + : batch_size(loop_batch_size ), remainder (vsize % batch_size), upper_bound(static_cast<int>(vsize - (remainder ? loop_batch_size : 0))) {} @@ -4522,7 +4615,7 @@ { dump_ptr("~control_block() data",data); delete[] data; - data = 0; + data = reinterpret_cast<data_t>(0); } } @@ -4531,12 +4624,12 @@ if (dsize) { if (0 == data_ptr) - return new control_block(dsize); + return (new control_block(dsize)); else - return new control_block(dsize, data_ptr, dstrct); + return (new control_block(dsize, data_ptr, dstrct)); } else - return new control_block; + return (new control_block); } static inline void destroy(control_block*& cntrl_blck) @@ -4617,7 +4710,7 @@ } } - return *this; + return (*this); } inline data_t data() @@ -5173,10 +5266,17 @@ return; node_allocator.free(node); - node = 0; + node = reinterpret_cast<expression_node<T>*>(0); } } + template <typename T> + inline void destroy_node(expression_node<T>*& node) + { + delete node; + node = reinterpret_cast<expression_node<T>*>(0); + } + template <typename Type> class vector_holder { @@ -5190,7 +5290,7 @@ { public: - virtual ~vector_holder_base(){} + virtual ~vector_holder_base() {} inline value_ptr operator[](const std::size_t& index) const { @@ -5360,7 +5460,7 @@ void set_ref(value_ptr* ref) { - return vector_holder_base_->set_ref(ref); + vector_holder_base_->set_ref(ref); } bool rebaseable() const @@ -5407,8 +5507,7 @@ { if (branch_ && branch_deletable_) { - delete branch_; - branch_ = 0; + destroy_node(branch_); } } @@ -5472,7 +5571,7 @@ private: literal_node(literal_node<T>&) {} - literal_node<T>& operator=(literal_node<T>&) { return *this; } + literal_node<T>& operator=(literal_node<T>&) { return (*this); } const T value_; }; @@ -5602,8 +5701,7 @@ { if (branch_ && branch_deletable_) { - delete branch_; - branch_ = 0; + destroy_node(branch_); } } @@ -5696,8 +5794,7 @@ { if (branch[i].first && branch[i].second) { - delete branch[i].first; - branch[i].first = 0; + destroy_node(branch[i].first); } } } @@ -5711,8 +5808,7 @@ { if (branch[i].first && branch[i].second) { - delete branch[i].first; - branch[i].first = 0; + destroy_node(branch[i].first); } } } @@ -5940,9 +6036,20 @@ ~conditional_node() { - if (test_ && test_deletable_ ) delete test_; - if (consequent_ && consequent_deletable_ ) delete consequent_; - if (alternative_ && alternative_deletable_) delete alternative_; + if (test_ && test_deletable_) + { + destroy_node(test_); + } + + if (consequent_ && consequent_deletable_ ) + { + destroy_node(consequent_); + } + + if (alternative_ && alternative_deletable_) + { + destroy_node(alternative_); + } } inline T value() const @@ -5986,8 +6093,15 @@ ~cons_conditional_node() { - if (test_ && test_deletable_ ) delete test_; - if (consequent_ && consequent_deletable_) delete consequent_; + if (test_ && test_deletable_) + { + destroy_node(test_); + } + + if (consequent_ && consequent_deletable_) + { + destroy_node(consequent_); + } } inline T value() const @@ -6043,7 +6157,7 @@ { if (return_deletable_) { - delete return_; + destroy_node(return_); } } @@ -6104,12 +6218,12 @@ { if (condition_ && condition_deletable_) { - delete condition_; + destroy_node(condition_); } if (loop_body_ && loop_body_deletable_) { - delete loop_body_; + destroy_node(loop_body_); } } @@ -6156,12 +6270,12 @@ { if (condition_ && condition_deletable_) { - delete condition_; + destroy_node(condition_); } if (loop_body_ && loop_body_deletable_) { - delete loop_body_; + destroy_node(loop_body_); } } @@ -6203,9 +6317,9 @@ expression_ptr incrementor, expression_ptr loop_body) : initialiser_(initialiser), - condition_ (condition), + condition_ (condition ), incrementor_(incrementor), - loop_body_ (loop_body), + loop_body_ (loop_body ), initialiser_deletable_(branch_deletable(initialiser_)), condition_deletable_ (branch_deletable(condition_ )), incrementor_deletable_(branch_deletable(incrementor_)), @@ -6216,22 +6330,22 @@ { if (initialiser_ && initialiser_deletable_) { - delete initialiser_; + destroy_node(initialiser_); } if (condition_ && condition_deletable_) { - delete condition_; + destroy_node(condition_); } if (incrementor_ && incrementor_deletable_) { - delete incrementor_; + destroy_node(incrementor_); } if (loop_body_ && loop_body_deletable_) { - delete loop_body_; + destroy_node(loop_body_); } } @@ -6297,12 +6411,12 @@ { if (condition_ && condition_deletable_) { - delete condition_; + destroy_node(condition_); } if (loop_body_ && loop_body_deletable_) { - delete loop_body_; + destroy_node(loop_body_); } } @@ -6358,12 +6472,12 @@ { if (condition_ && condition_deletable_) { - delete condition_; + destroy_node(condition_); } if (loop_body_ && loop_body_deletable_) { - delete loop_body_; + destroy_node(loop_body_); } } @@ -6427,22 +6541,22 @@ { if (initialiser_ && initialiser_deletable_) { - delete initialiser_; + destroy_node(initialiser_); } if (condition_ && condition_deletable_) { - delete condition_; + destroy_node(condition_); } if (incrementor_ && incrementor_deletable_) { - delete incrementor_; + destroy_node(incrementor_); } if (loop_body_ && loop_body_deletable_) { - delete loop_body_; + destroy_node(loop_body_); } } @@ -6548,8 +6662,7 @@ { if (arg_list_[i] && delete_branch_[i]) { - delete arg_list_[i]; - arg_list_[i] = 0; + destroy_node(arg_list_[i]); } } } @@ -6646,8 +6759,7 @@ { if (arg_list_[i] && delete_branch_[i]) { - delete arg_list_[i]; - arg_list_[i] = 0; + destroy_node(arg_list_[i]); } } } @@ -6783,8 +6895,7 @@ !is_string_node (n0_e.second) ) { - delete n0_e.second; - n0_e.second = expression_node_ptr(0); + destroy_node(n0_e.second); } } @@ -6797,8 +6908,7 @@ !is_string_node (n1_e.second) ) { - delete n1_e.second; - n1_e.second = expression_node_ptr(0); + destroy_node(n1_e.second); } } } @@ -6815,7 +6925,7 @@ (!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; @@ -7016,7 +7126,7 @@ { if (index_ && index_deletable_) { - delete index_; + destroy_node(index_); } } @@ -7077,7 +7187,7 @@ { if (index_ && index_deletable_) { - delete index_; + destroy_node(index_); } } @@ -7188,7 +7298,7 @@ { if (branch_deletable(initialiser_list_[i])) { - delete initialiser_list_[i]; + destroy_node(initialiser_list_[i]); } } } @@ -7277,7 +7387,7 @@ typedef ivariable<T>* ivariable_ptr; swap_generic_node(expression_ptr var0, expression_ptr var1) - : binary_node<T>(details::e_swap,var0,var1), + : binary_node<T>(details::e_swap, var0, var1), var0_(dynamic_cast<ivariable_ptr>(var0)), var1_(dynamic_cast<ivariable_ptr>(var1)) {} @@ -7311,7 +7421,7 @@ swap_vecvec_node(expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(details::e_swap,branch0,branch1), + : binary_node<T>(details::e_swap, branch0, branch1), vec0_node_ptr_(0), vec1_node_ptr_(0), vec_size_ (0), @@ -7696,8 +7806,7 @@ if (branch_ && branch_deletable_) { - delete branch_; - branch_ = 0; + destroy_node(branch_); } } @@ -7793,7 +7902,7 @@ string_concat_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), initialised_(false), str0_base_ptr_ (0), str1_base_ptr_ (0), @@ -7930,7 +8039,7 @@ typedef irange_t* irange_ptr; swap_string_node(expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(details::e_swap,branch0,branch1), + : binary_node<T>(details::e_swap, branch0, branch1), initialised_(false), str0_node_ptr_(0), str1_node_ptr_(0) @@ -8012,7 +8121,7 @@ swap_genstrings_node(expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(details::e_default,branch0,branch1), + : binary_node<T>(details::e_default, branch0, branch1), str0_base_ptr_ (0), str1_base_ptr_ (0), str0_range_ptr_(0), @@ -8108,6 +8217,7 @@ int i = 0; + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -8124,6 +8234,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -8209,8 +8320,7 @@ { if (branch_ && branch_deletable_) { - delete branch_; - branch_ = 0; + destroy_node(branch_); } } @@ -8269,7 +8379,7 @@ assignment_string_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), initialised_(false), str0_base_ptr_ (0), str1_base_ptr_ (0), @@ -8315,7 +8425,7 @@ range_t& range = (*str1_range_ptr_); - if (range(r0,r1,str1_base_ptr_->size())) + if (range(r0, r1, str1_base_ptr_->size())) { AssignmentProcess::execute(str0_node_ptr_->ref(), str1_base_ptr_->base() + r0, @@ -8385,7 +8495,7 @@ assignment_string_range_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), initialised_(false), str0_base_ptr_ (0), str1_base_ptr_ (0), @@ -8446,8 +8556,8 @@ range_t& range1 = (*str1_range_ptr_); if ( - range0(s0_r0,s0_r1,str0_base_ptr_->size()) && - range1(s1_r0,s1_r1,str1_base_ptr_->size()) + range0(s0_r0, s0_r1, str0_base_ptr_->size()) && + range1(s1_r0, s1_r1, str1_base_ptr_->size()) ) { std::size_t size = std::min((s0_r1 - s0_r0),(s1_r1 - s1_r0)) + 1; @@ -8676,7 +8786,7 @@ cons_conditional_str_node(expression_ptr test, expression_ptr consequent) - : binary_node<T>(details::e_default,consequent,test), + : binary_node<T>(details::e_default, consequent, test), initialised_(false), str0_base_ptr_ (0), str0_range_ptr_(0), @@ -8845,16 +8955,14 @@ { if (final_node_ && final_deletable_) { - delete final_node_; - final_node_ = 0; + destroy_node(final_node_); } for (std::size_t i = 0; i < arg_list_.size(); ++i) { if (arg_list_[i] && delete_branch_[i]) { - delete arg_list_[i]; - arg_list_[i] = 0; + destroy_node(arg_list_[i]); } } } @@ -9145,7 +9253,7 @@ expression_ptr branch0, expression_ptr branch1, expression_ptr branch2) - : trinary_node<T>(opr,branch0,branch1,branch2) + : trinary_node<T>(opr, branch0, branch1, branch2) {} inline T value() const @@ -9154,7 +9262,7 @@ const T y = trinary_node<T>::branch_[1].first->value(); const T z = trinary_node<T>::branch_[2].first->value(); - return SpecialFunction::process(x,y,z); + return SpecialFunction::process(x, y, z); } }; @@ -9170,7 +9278,7 @@ expression_ptr branch1, expression_ptr branch2, expression_ptr branch3) - : quaternary_node<T>(opr,branch0,branch1,branch2,branch3) + : quaternary_node<T>(opr, branch0, branch1, branch2, branch3) {} inline T value() const @@ -9180,7 +9288,7 @@ const T z = quaternary_node<T>::branch_[2].first->value(); const T w = quaternary_node<T>::branch_[3].first->value(); - return SpecialFunction::process(x,y,z,w); + return SpecialFunction::process(x, y, z, w); } }; @@ -9199,7 +9307,7 @@ inline T value() const { - return SpecialFunction::process(v0_,v1_,v2_); + return SpecialFunction::process(v0_, v1_, v2_); } inline typename expression_node<T>::node_type type() const @@ -9233,7 +9341,7 @@ inline T value() const { - return SpecialFunction::process(v0_,v1_,v2_,v3_); + return SpecialFunction::process(v0_, v1_, v2_, v3_); } inline typename expression_node<T>::node_type type() const @@ -9263,7 +9371,7 @@ template <typename,typename> class Sequence> vararg_node(const Sequence<expression_ptr,Allocator>& arg_list) { - arg_list_.resize(arg_list.size()); + arg_list_ .resize(arg_list.size()); delete_branch_.resize(arg_list.size()); for (std::size_t i = 0; i < arg_list.size(); ++i) @@ -9288,8 +9396,7 @@ { if (arg_list_[i] && delete_branch_[i]) { - delete arg_list_[i]; - arg_list_[i] = 0; + destroy_node(arg_list_[i]); } } } @@ -9383,7 +9490,7 @@ { if (v_ && v_deletable_) { - delete v_; + destroy_node(v_); } } @@ -9420,7 +9527,7 @@ assignment_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), var_node_ptr_(0) { if (is_variable_node(binary_node<T>::branch_[0].first)) @@ -9458,7 +9565,7 @@ assignment_vec_elem_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), vec_node_ptr_(0) { if (is_vector_elem_node(binary_node<T>::branch_[0].first)) @@ -9496,7 +9603,7 @@ assignment_rebasevec_elem_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), rbvec_node_ptr_(0) { if (is_rebasevector_elem_node(binary_node<T>::branch_[0].first)) @@ -9534,7 +9641,7 @@ assignment_rebasevec_celem_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), rbvec_node_ptr_(0) { if (is_rebasevector_celem_node(binary_node<T>::branch_[0].first)) @@ -9575,7 +9682,7 @@ assignment_vec_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), vec_node_ptr_(0) { if (is_vector_node(binary_node<T>::branch_[0].first)) @@ -9615,6 +9722,7 @@ vec += lud.batch_size; } + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -9631,6 +9739,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -9690,7 +9799,7 @@ assignment_vecvec_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), vec0_node_ptr_(0), vec1_node_ptr_(0), initialised_(false), @@ -9763,6 +9872,7 @@ vec1 += lud.batch_size; } + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -9779,6 +9889,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -9838,7 +9949,7 @@ assignment_op_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), var_node_ptr_(0) { if (is_variable_node(binary_node<T>::branch_[0].first)) @@ -9875,7 +9986,7 @@ assignment_vec_elem_op_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), vec_node_ptr_(0) { if (is_vector_elem_node(binary_node<T>::branch_[0].first)) @@ -9912,7 +10023,7 @@ assignment_rebasevec_elem_op_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), rbvec_node_ptr_(0) { if (is_rebasevector_elem_node(binary_node<T>::branch_[0].first)) @@ -9949,7 +10060,7 @@ assignment_rebasevec_celem_op_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), rbvec_node_ptr_(0) { if (is_rebasevector_celem_node(binary_node<T>::branch_[0].first)) @@ -9989,7 +10100,7 @@ assignment_vec_op_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), vec_node_ptr_(0) { if (is_vector_node(binary_node<T>::branch_[0].first)) @@ -10029,6 +10140,7 @@ vec += lud.batch_size; } + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -10045,6 +10157,8 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end + #undef exprtk_loop #undef case_stmt @@ -10109,7 +10223,7 @@ assignment_vecvec_op_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), vec0_node_ptr_(0), vec1_node_ptr_(0), initialised_(false) @@ -10176,6 +10290,7 @@ int i = 0; + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -10192,6 +10307,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -10259,7 +10375,7 @@ vec_binop_vecvec_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), vec0_node_ptr_(0), vec1_node_ptr_(0), temp_ (0), @@ -10361,6 +10477,7 @@ int i = 0; + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -10377,6 +10494,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -10441,7 +10559,7 @@ vec_binop_vecval_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), vec0_node_ptr_(0), temp_ (0), temp_vec_node_(0) @@ -10516,6 +10634,7 @@ int i = 0; + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -10532,6 +10651,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -10594,7 +10714,7 @@ vec_binop_valvec_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), vec1_node_ptr_(0), temp_ (0), temp_vec_node_(0) @@ -10669,6 +10789,7 @@ int i = 0; + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -10685,6 +10806,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -10745,7 +10867,7 @@ typedef vec_data_store<T> vds_t; unary_vector_node(const operator_type& opr, expression_ptr branch0) - : unary_node<T>(opr,branch0), + : unary_node<T>(opr, branch0), vec0_node_ptr_(0), temp_ (0), temp_vec_node_(0) @@ -10819,6 +10941,7 @@ int i = 0; + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -10835,6 +10958,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -10893,7 +11017,7 @@ scand_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1) + : binary_node<T>(opr, branch0, branch1) {} inline T value() const @@ -10917,7 +11041,7 @@ scor_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1) + : binary_node<T>(opr, branch0, branch1) {} inline T value() const @@ -11280,8 +11404,7 @@ { if (arg_list_[i] && !details::is_variable_node(arg_list_[i])) { - delete arg_list_[i]; - arg_list_[i] = 0; + destroy_node(arg_list_[i]); } } } @@ -11707,7 +11830,7 @@ typedef type_store<T> generic_type; typedef typename generic_type::parameter_list parameter_list_t; - inline virtual T operator()(parameter_list_t) + inline virtual T operator() (parameter_list_t) { return std::numeric_limits<T>::quiet_NaN(); } @@ -11767,9 +11890,9 @@ typedef results_context<T> results_context_t; return_envelope_node(expression_ptr body, results_context_t& rc) - : results_context_(&rc), + : results_context_(&rc ), return_invoked_ (false), - body_ (body), + body_ (body ), body_deletable_ (branch_deletable(body_)) {} @@ -11777,7 +11900,7 @@ { if (body_ && body_deletable_) { - delete body_; + destroy_node(body_); } } @@ -12761,6 +12884,7 @@ T result = T(0); int i = 0; + exprtk_disable_fallthrough_begin switch (vec_size) { #define case_stmt(N) \ @@ -12777,6 +12901,7 @@ case_stmt( 4) case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef case_stmt @@ -12811,6 +12936,7 @@ int i = 0; + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -12827,6 +12953,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -12858,6 +12985,7 @@ T result = T(1); int i = 0; + exprtk_disable_fallthrough_begin switch (vec_size) { #define case_stmt(N) \ @@ -12874,6 +13002,7 @@ case_stmt( 4) case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef case_stmt @@ -12908,6 +13037,7 @@ int i = 0; + exprtk_disable_fallthrough_begin switch (lud.remainder) { #define case_stmt(N) \ @@ -12924,6 +13054,7 @@ case_stmt( 3) case_stmt( 2) case_stmt( 1) } + exprtk_disable_fallthrough_end #undef exprtk_loop #undef case_stmt @@ -13237,9 +13368,9 @@ ufunc_t uf0, ufunc_t uf1, bfunc_t bf) : v0_(var0), v1_(var1), - u0_(uf0), - u1_(uf1), - f_ (bf) + u0_(uf0 ), + u1_(uf1 ), + f_ (bf ) {} inline T value() const @@ -13311,8 +13442,7 @@ { if (branch_ && branch_deletable_) { - delete branch_; - branch_ = 0; + destroy_node(branch_); } } @@ -13648,13 +13778,15 @@ T0 p0, T1 p1, bfunc_t p2) { - return allocator.template allocate_type<node_type,T0,T1,bfunc_t&>(p0,p1,p2); + return allocator + .template allocate_type<node_type,T0,T1,bfunc_t&> + (p0, p1, p2); } private: T0oT1(T0oT1<T,T0,T1>&) {} - T0oT1<T,T0,T1>& operator=(T0oT1<T,T0,T1>&) { return *this; } + T0oT1<T,T0,T1>& operator=(T0oT1<T,T0,T1>&) { return (*this); } T0 t0_; T1 t1_; @@ -13734,13 +13866,15 @@ template <typename Allocator> 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>(p0,p1,p2,p3,p4); + return allocator + .template allocate_type<node_type,T0,T1,T2,bfunc_t,bfunc_t> + (p0, p1, p2, p3, p4); } private: T0oT1oT2(node_type&) {} - node_type& operator=(node_type&) { return *this; } + node_type& operator=(node_type&) { return (*this); } T0 t0_; T1 t1_; @@ -13776,7 +13910,7 @@ inline T value() const { - return ProcessMode::process(t0_,t1_,t2_,t3_,f0_,f1_,f2_); + return ProcessMode::process(t0_, t1_, t2_, t3_, f0_, f1_, f2_); } inline T0 t0() const @@ -13829,13 +13963,15 @@ T0 p0, T1 p1, T2 p2, T3 p3, bfunc_t p4, bfunc_t p5, bfunc_t p6) { - return allocator.template allocate_type<node_type,T0,T1,T2,T3,bfunc_t,bfunc_t>(p0,p1,p2,p3,p4,p5,p6); + return allocator + .template allocate_type<node_type,T0,T1,T2,T3,bfunc_t,bfunc_t> + (p0, p1, p2, p3, p4, p5, p6); } private: T0oT1oT2oT3(node_type&) {} - node_type& operator=(node_type&) { return *this; } + node_type& operator=(node_type&) { return (*this); } T0 t0_; T1 t1_; @@ -13876,7 +14012,7 @@ inline T value() const { - return f_(t0_,t1_,t2_); + return f_(t0_, t1_, t2_); } inline T0 t0() const @@ -13912,13 +14048,15 @@ template <typename Allocator> 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>(p0,p1,p2,p3); + return allocator + .template allocate_type<node_type,T0,T1,T2,tfunc_t> + (p0, p1, p2, p3); } private: T0oT1oT2_sf3(node_type&) {} - node_type& operator=(node_type&) { return *this; } + node_type& operator=(node_type&) { return (*this); } T0 t0_; T1 t1_; @@ -13970,7 +14108,7 @@ inline T value() const { - return SF3Operation::process(t0_,t1_,t2_); + return SF3Operation::process(t0_, t1_, t2_); } T0 t0() const @@ -14001,13 +14139,15 @@ template <typename Allocator> static inline expression_node<T>* allocate(Allocator& allocator, T0 p0, T1 p1, T2 p2) { - return allocator.template allocate_type<node_type,T0,T1,T2>(p0,p1,p2); + return allocator + .template allocate_type<node_type,T0,T1,T2> + (p0, p1, p2); } private: T0oT1oT2_sf3ext(node_type&) {} - node_type& operator=(node_type&) { return *this; } + node_type& operator=(node_type&) { return (*this); } T0 t0_; T1 t1_; @@ -14059,7 +14199,7 @@ inline T value() const { - return f_(t0_,t1_,t2_,t3_); + return f_(t0_, t1_, t2_, t3_); } inline T0 t0() const @@ -14100,13 +14240,15 @@ template <typename Allocator> 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>(p0,p1,p2,p3,p4); + return allocator + .template allocate_type<node_type,T0,T1,T2,T3,qfunc_t> + (p0, p1, p2, p3, p4); } private: T0oT1oT2oT3_sf4(node_type&) {} - node_type& operator=(node_type&) { return *this; } + node_type& operator=(node_type&) { return (*this); } T0 t0_; T1 t1_; @@ -14145,7 +14287,7 @@ inline T value() const { - return SF4Operation::process(t0_,t1_,t2_,t3_); + return SF4Operation::process(t0_, t1_, t2_, t3_); } inline T0 t0() const @@ -14181,13 +14323,15 @@ template <typename Allocator> 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>(p0,p1,p2,p3); + return allocator + .template allocate_type<node_type,T0,T1,T2,T3> + (p0, p1, p2, p3); } private: T0oT1oT2oT3_sf4ext(node_type&) {} - node_type& operator=(node_type&) { return *this; } + node_type& operator=(node_type&) { return (*this); } T0 t0_; T1 t1_; @@ -14667,8 +14811,8 @@ // string-range op string node explicit str_xrox_node(SType0 p0, SType1 p1, RangePack rp0) - : s0_(p0), - s1_(p1), + : s0_ (p0 ), + s1_ (p1 ), rp0_(rp0) {} @@ -14874,7 +15018,7 @@ str_sogens_node(const operator_type& opr, expression_ptr branch0, expression_ptr branch1) - : binary_node<T>(opr,branch0,branch1), + : binary_node<T>(opr, branch0, branch1), str0_base_ptr_ (0), str1_base_ptr_ (0), str0_range_ptr_(0), @@ -15342,7 +15486,7 @@ template <typename node_type> inline expression_node<typename node_type::value_type>* allocate() const { - return new node_type(); + return (new node_type()); } template <typename node_type, @@ -15351,89 +15495,89 @@ 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); + return (new node_type(seq)); } template <typename node_type, typename T1> inline expression_node<typename node_type::value_type>* allocate(T1& t1) const { - return new node_type(t1); + return (new node_type(t1)); } template <typename node_type, typename T1> inline expression_node<typename node_type::value_type>* allocate_c(const T1& t1) const { - return new node_type(t1); + return (new node_type(t1)); } template <typename node_type, typename T1, typename T2> inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2) const { - return new node_type(t1,t2); + return (new node_type(t1,t2)); } template <typename node_type, typename T1, typename T2> inline expression_node<typename node_type::value_type>* allocate_cr(const T1& t1, T2& t2) const { - return new node_type(t1,t2); + return (new node_type(t1,t2)); } template <typename node_type, typename T1, typename T2> inline expression_node<typename node_type::value_type>* allocate_rc(T1& t1, const T2& t2) const { - return new node_type(t1,t2); + return (new node_type(t1,t2)); } template <typename node_type, typename T1, typename T2> inline expression_node<typename node_type::value_type>* allocate_rr(T1& t1, T2& t2) const { - return new node_type(t1,t2); + return (new node_type(t1,t2)); } template <typename node_type, typename T1, typename T2> inline expression_node<typename node_type::value_type>* allocate_tt(T1 t1, T2 t2) const { - return new node_type(t1,t2); + return (new node_type(t1,t2)); } template <typename node_type, typename T1, typename T2, typename T3> inline expression_node<typename node_type::value_type>* allocate_ttt(T1 t1, T2 t2, T3 t3) const { - return new node_type(t1,t2,t3); + return (new node_type(t1,t2,t3)); } template <typename node_type, typename T1, typename T2, typename T3, typename T4> inline expression_node<typename node_type::value_type>* allocate_tttt(T1 t1, T2 t2, T3 t3, T4 t4) const { - return new node_type(t1,t2,t3,t4); + return (new node_type(t1,t2,t3,t4)); } template <typename node_type, typename T1, typename T2, typename T3> inline expression_node<typename node_type::value_type>* allocate_rrr(T1& t1, T2& t2, T3& t3) const { - return new node_type(t1,t2,t3); + return (new node_type(t1,t2,t3)); } template <typename node_type, typename T1, typename T2, typename T3, typename T4> inline expression_node<typename node_type::value_type>* allocate_rrrr(T1& t1, T2& t2, T3& t3, T4& t4) const { - return new node_type(t1,t2,t3,t4); + return (new node_type(t1,t2,t3,t4)); } template <typename node_type, typename T1, typename T2, typename T3, typename T4, typename T5> inline expression_node<typename node_type::value_type>* allocate_rrrrr(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) const { - return new node_type(t1,t2,t3,t4,t5); + return (new node_type(t1,t2,t3,t4,t5)); } template <typename node_type, @@ -15441,7 +15585,7 @@ inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2, const T3& t3) const { - return new node_type(t1,t2,t3); + return (new node_type(t1,t2,t3)); } template <typename node_type, @@ -15450,7 +15594,7 @@ inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2, const T3& t3, const T4& t4) const { - return new node_type(t1,t2,t3,t4); + return (new node_type(t1,t2,t3,t4)); } template <typename node_type, @@ -15460,7 +15604,7 @@ const T3& t3, const T4& t4, const T5& t5) const { - return new node_type(t1,t2,t3,t4,t5); + return (new node_type(t1,t2,t3,t4,t5)); } template <typename node_type, @@ -15470,7 +15614,7 @@ const T3& t3, const T4& t4, const T5& t5, const T6& t6) const { - return new node_type(t1,t2,t3,t4,t5,t6); + return (new node_type(t1,t2,t3,t4,t5,t6)); } template <typename node_type, @@ -15482,7 +15626,7 @@ const T5& t5, const T6& t6, const T7& t7) const { - return new node_type(t1,t2,t3,t4,t5,t6,t7); + return (new node_type(t1,t2,t3,t4,t5,t6,t7)); } template <typename node_type, @@ -15495,7 +15639,7 @@ const T5& t5, const T6& t6, const T7& t7, const T8& t8) const { - return new node_type(t1,t2,t3,t4,t5,t6,t7,t8); + return (new node_type(t1,t2,t3,t4,t5,t6,t7,t8)); } template <typename node_type, @@ -15509,7 +15653,7 @@ const T7& t7, const T8& t8, const T9& t9) const { - return new node_type(t1,t2,t3,t4,t5,t6,t7,t8,t9); + return (new node_type(t1,t2,t3,t4,t5,t6,t7,t8,t9)); } template <typename node_type, @@ -15524,14 +15668,14 @@ const T7& t7, const T8& t8, const T9& t9, const T10& t10) const { - return new node_type(t1,t2,t3,t4,t5,t6,t7,t8,t9,t10); + return (new node_type(t1,t2,t3,t4,t5,t6,t7,t8,t9,t10)); } template <typename node_type, typename T1, typename T2, typename T3> inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2, T3 t3) const { - return new node_type(t1,t2,t3); + return (new node_type(t1,t2,t3)); } template <typename node_type, @@ -15540,7 +15684,7 @@ inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2, T3 t3, T4 t4) const { - return new node_type(t1,t2,t3,t4); + return (new node_type(t1,t2,t3,t4)); } template <typename node_type, @@ -15551,7 +15695,18 @@ T3 t3, T4 t4, T5 t5) const { - return new node_type(t1,t2,t3,t4,t5); + return (new node_type(t1,t2,t3,t4,t5)); + } + + template <typename node_type, + typename T1, typename T2, + typename T3, typename T4, + typename T5, typename T6> + inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2, + T3 t3, T4 t4, + T5 t5, T6 t6) const + { + return (new node_type(t1,t2,t3,t4,t5,t6)); } template <typename node_type, @@ -15563,7 +15718,7 @@ T5 t5, T6 t6, T7 t7) const { - return new node_type(t1,t2,t3,t4,t5,t6,t7); + return (new node_type(t1,t2,t3,t4,t5,t6,t7)); } template <typename T> @@ -15736,77 +15891,77 @@ return std::numeric_limits<T>::quiet_NaN(); \ } \ - inline virtual T operator()() + inline virtual T operator() () empty_method_body - inline virtual T operator()(const T&) + inline virtual T operator() (const T&) empty_method_body - inline virtual T operator()(const T&,const T&) + inline virtual T operator() (const T&,const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, - const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, - const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, - const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, - const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, - const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, - const T&, const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + const T&, const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, - const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, - const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body - inline virtual T operator()(const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, - const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) + inline virtual T operator() (const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, + const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&, const T&) empty_method_body #undef empty_method_body @@ -15822,7 +15977,7 @@ virtual ~ivararg_function() {} - inline virtual T operator()(const std::vector<T>&) + inline virtual T operator() (const std::vector<T>&) { exprtk_debug(("ivararg_function::operator() - Operator has not been overridden.\n")); return std::numeric_limits<T>::quiet_NaN(); @@ -15859,19 +16014,19 @@ } \ // f(i_0,i_1,....,i_N) --> Scalar - inline virtual T operator()(parameter_list_t) + inline virtual T operator() (parameter_list_t) igeneric_function_empty_body(1) // f(i_0,i_1,....,i_N) --> String - inline virtual T operator()(std::string&, parameter_list_t) + inline virtual T operator() (std::string&, parameter_list_t) igeneric_function_empty_body(2) // f(psi,i_0,i_1,....,i_N) --> Scalar - inline virtual T operator()(const std::size_t&, parameter_list_t) + inline virtual T operator() (const std::size_t&, parameter_list_t) igeneric_function_empty_body(3) // f(psi,i_0,i_1,....,i_N) --> String - inline virtual T operator()(const std::size_t&, std::string&, parameter_list_t) + inline virtual T operator() (const std::size_t&, std::string&, parameter_list_t) igeneric_function_empty_body(4) std::string parameter_sequence; @@ -15886,6 +16041,7 @@ { public: + typedef T (*ff00_functor)(); typedef T (*ff01_functor)(T); typedef T (*ff02_functor)(T,T); typedef T (*ff03_functor)(T,T,T); @@ -15904,12 +16060,22 @@ protected: + struct freefunc00 : public exprtk::ifunction<T> + { + using exprtk::ifunction<T>::operator(); + + freefunc00(ff00_functor ff) : exprtk::ifunction<T>(0), f(ff) {} + inline T operator() () + { return f(); } + ff00_functor f; + }; + struct freefunc01 : public exprtk::ifunction<T> { using exprtk::ifunction<T>::operator(); freefunc01(ff01_functor ff) : exprtk::ifunction<T>(1), f(ff) {} - inline T operator()(const T& v0) + inline T operator() (const T& v0) { return f(v0); } ff01_functor f; }; @@ -15919,7 +16085,7 @@ using exprtk::ifunction<T>::operator(); freefunc02(ff02_functor ff) : exprtk::ifunction<T>(2), f(ff) {} - inline T operator()(const T& v0, const T& v1) + inline T operator() (const T& v0, const T& v1) { return f(v0, v1); } ff02_functor f; }; @@ -15929,7 +16095,7 @@ using exprtk::ifunction<T>::operator(); freefunc03(ff03_functor ff) : exprtk::ifunction<T>(3), f(ff) {} - inline T operator()(const T& v0, const T& v1, const T& v2) + inline T operator() (const T& v0, const T& v1, const T& v2) { return f(v0, v1, v2); } ff03_functor f; }; @@ -15939,7 +16105,7 @@ using exprtk::ifunction<T>::operator(); 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) + inline T operator() (const T& v0, const T& v1, const T& v2, const T& v3) { return f(v0, v1, v2, v3); } ff04_functor f; }; @@ -15949,7 +16115,7 @@ using exprtk::ifunction<T>::operator(); 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) + 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; }; @@ -15959,7 +16125,7 @@ using exprtk::ifunction<T>::operator(); 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) + 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; }; @@ -15969,8 +16135,8 @@ using exprtk::ifunction<T>::operator(); 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) + 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); } ff07_functor f; }; @@ -15980,8 +16146,8 @@ using exprtk::ifunction<T>::operator(); 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) + 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); } ff08_functor f; }; @@ -15991,8 +16157,8 @@ using exprtk::ifunction<T>::operator(); 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) + 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); } ff09_functor f; }; @@ -16002,8 +16168,8 @@ using exprtk::ifunction<T>::operator(); 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) + 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); } ff10_functor f; }; @@ -16013,8 +16179,8 @@ using exprtk::ifunction<T>::operator(); 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) + 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); } ff11_functor f; }; @@ -16024,9 +16190,9 @@ using exprtk::ifunction<T>::operator(); 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) + 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) { return f(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11); } ff12_functor f; }; @@ -16036,9 +16202,9 @@ using exprtk::ifunction<T>::operator(); 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) + 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) { return f(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12); } ff13_functor f; }; @@ -16048,9 +16214,9 @@ using exprtk::ifunction<T>::operator(); 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) + 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) { return f(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13); } ff14_functor f; }; @@ -16060,9 +16226,9 @@ using exprtk::ifunction<T>::operator(); 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) + 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) { return f(v00, v01, v02, v03, v04, v05, v06, v07, v08, v09, v10, v11, v12, v13, v14); } ff15_functor f; }; @@ -16133,7 +16299,7 @@ return false; else { - tm_const_itr_t itr = map.find(symbol_name); + const tm_const_itr_t itr = map.find(symbol_name); if (map.end() == itr) return false; @@ -16156,7 +16322,7 @@ } } - tm_itr_t itr = map.find(symbol_name); + const tm_itr_t itr = map.find(symbol_name); if (map.end() == itr) { @@ -16266,7 +16432,7 @@ } }; - tm_itr_t itr = map.find(symbol_name); + const tm_itr_t itr = map.find(symbol_name); if (map.end() == itr) { @@ -16279,7 +16445,7 @@ inline type_ptr get(const std::string& symbol_name) const { - tm_const_itr_t itr = map.find(symbol_name); + const tm_const_itr_t itr = map.find(symbol_name); if (map.end() == itr) return reinterpret_cast<type_ptr>(0); @@ -16327,7 +16493,7 @@ inline bool remove(const std::string& symbol_name, const bool delete_node = true) { - tm_itr_t itr = map.find(symbol_name); + const tm_itr_t itr = map.find(symbol_name); if (map.end() != itr) { @@ -16367,7 +16533,7 @@ static RawType null_type = init_type::set(RawType()); - tm_const_itr_t itr = map.find(symbol_name); + const tm_const_itr_t itr = map.find(symbol_name); if (map.end() == itr) return null_type; @@ -16392,7 +16558,7 @@ if (delete_node) { tm_itr_t itr = map.begin(); - tm_itr_t end = map.end(); + tm_itr_t end = map.end (); while (end != itr) { @@ -16416,7 +16582,7 @@ if (!map.empty()) { tm_const_itr_t itr = map.begin(); - tm_const_itr_t end = map.end(); + tm_const_itr_t end = map.end (); while (end != itr) { @@ -16438,7 +16604,7 @@ if (!map.empty()) { tm_const_itr_t itr = map.begin(); - tm_const_itr_t end = map.end(); + tm_const_itr_t end = map.end (); while (end != itr) { @@ -16510,6 +16676,17 @@ return (reserved_symbol_table_.end() != reserved_symbol_table_.find(symbol)); } + static inline st_data* create() + { + return (new st_data); + } + + static inline void destroy(st_data*& sd) + { + delete sd; + sd = reinterpret_cast<st_data*>(0); + } + std::list<T> local_symbol_list_; std::list<std::string> local_stringvar_list_; std::set<std::string> reserved_symbol_table_; @@ -16518,7 +16695,7 @@ control_block() : ref_count(1), - data_(new st_data) + data_(st_data::create()) {} control_block(st_data* data) @@ -16530,14 +16707,13 @@ { if (data_ && (0 == ref_count)) { - delete data_; - data_ = 0; + st_data::destroy(data_); } } static inline control_block* create() { - return new control_block; + return (new control_block); } template <typename SymTab> @@ -16593,7 +16769,7 @@ control_block_->ref_count++; } - return *this; + return (*this); } inline bool operator==(const symbol_table<T>& st) @@ -16922,11 +17098,11 @@ inline bool add_function(const std::string& function_name, ff##NN##_functor function) \ { \ if (!valid()) \ - return false; \ - else if (!valid_symbol(function_name)) \ - return false; \ - else if (symbol_exists(function_name)) \ - return false; \ + { return false; } \ + if (!valid_symbol(function_name)) \ + { return false; } \ + if (symbol_exists(function_name)) \ + { return false; } \ \ exprtk::ifunction<T>* ifunc = new freefunc##NN(function); \ \ @@ -16935,14 +17111,14 @@ return add_function(function_name,(*local_data().free_function_list_.back())); \ } \ - exprtk_define_freefunction(01) exprtk_define_freefunction(02) - exprtk_define_freefunction(03) exprtk_define_freefunction(04) - exprtk_define_freefunction(05) exprtk_define_freefunction(06) - exprtk_define_freefunction(07) exprtk_define_freefunction(08) - exprtk_define_freefunction(09) exprtk_define_freefunction(10) - exprtk_define_freefunction(11) exprtk_define_freefunction(12) - exprtk_define_freefunction(13) exprtk_define_freefunction(14) - exprtk_define_freefunction(15) + exprtk_define_freefunction(00) exprtk_define_freefunction(01) + exprtk_define_freefunction(02) exprtk_define_freefunction(03) + exprtk_define_freefunction(04) exprtk_define_freefunction(05) + exprtk_define_freefunction(06) exprtk_define_freefunction(07) + exprtk_define_freefunction(08) exprtk_define_freefunction(09) + exprtk_define_freefunction(10) exprtk_define_freefunction(11) + exprtk_define_freefunction(12) exprtk_define_freefunction(13) + exprtk_define_freefunction(14) exprtk_define_freefunction(15) #undef exprtk_define_freefunction @@ -17009,6 +17185,8 @@ return false; else if (symbol_exists(vector_name)) return false; + else if (0 == v_size) + return false; else return local_data().vector_store.add(vector_name,v,v_size); } @@ -17022,6 +17200,8 @@ return false; else if (symbol_exists(vector_name)) return false; + else if (0 == v.size()) + return false; else return local_data().vector_store.add(vector_name,v); } @@ -17034,6 +17214,8 @@ return false; else if (symbol_exists(vector_name)) return false; + else if (0 == v.size()) + return false; else return local_data().vector_store.add(vector_name,v); } @@ -17084,12 +17266,13 @@ { return add_pi () && add_epsilon () && - add_infinity(); + add_infinity() ; } inline bool add_pi() { - static const T local_pi = T(details::numeric::constant::pi); + const typename details::numeric::details::number_type<T>::type num_type; + static const T local_pi = details::numeric::details::const_pi_impl<T>(num_type); return add_constant("pi",local_pi); } @@ -17471,8 +17654,7 @@ { if (expr && details::branch_deletable(expr)) { - delete expr; - expr = reinterpret_cast<expression_ptr>(0); + destroy_node(expr); } if (!local_data_list.empty()) @@ -17547,7 +17729,7 @@ } expression(const expression<T>& e) - : control_block_(e.control_block_), + : control_block_ (e.control_block_ ), symbol_table_list_(e.symbol_table_list_) { control_block_->ref_count++; @@ -17595,7 +17777,7 @@ { control_block::destroy(control_block_); - return *this; + return (*this); } ~expression() @@ -17608,7 +17790,7 @@ return control_block_->expr->value(); } - inline T operator()() const + inline T operator() () const { return value(); } @@ -17835,27 +18017,35 @@ lexer::token token; error_mode mode; std::string diagnostic; + std::string src_location; std::string error_line; std::size_t line_no; std::size_t column_no; }; - inline type make_error(error_mode mode, const std::string& diagnostic = "") + inline type make_error(error_mode mode, + const std::string& diagnostic = "", + const std::string& src_location = "") { type t; - t.mode = mode; - t.token.type = lexer::token::e_error; - t.diagnostic = diagnostic; + t.mode = mode; + t.token.type = lexer::token::e_error; + t.diagnostic = diagnostic; + t.src_location = src_location; exprtk_debug(("%s\n",diagnostic .c_str())); return t; } - inline type make_error(error_mode mode, const lexer::token& tk, const std::string& diagnostic = "") + inline type make_error(error_mode mode, + const lexer::token& tk, + const std::string& diagnostic = "", + const std::string& src_location = "") { type t; t.mode = mode; t.token = tk; t.diagnostic = diagnostic; + t.src_location = src_location; exprtk_debug(("%s\n",diagnostic .c_str())); return t; } @@ -18012,6 +18202,7 @@ typedef details::scor_node<T> scor_node_t; typedef lexer::token token_t; typedef expression_node_t* expression_node_ptr; + typedef expression<T> expression_t; typedef symbol_table<T> symbol_table_t; typedef typename expression<T>::symtab_list_t symbol_table_list_t; typedef details::vector_holder<T>* vector_holder_ptr; @@ -18321,7 +18512,7 @@ se.active && se.var_node && details::is_variable_node(se.var_node) - ) + ) { variable_node_ptr vn = reinterpret_cast<variable_node_ptr>(se.var_node); @@ -19163,43 +19354,43 @@ settings_store& enable_all_base_functions() { disabled_func_set_.clear(); - return *this; + return (*this); } settings_store& enable_all_control_structures() { disabled_ctrl_set_.clear(); - return *this; + return (*this); } settings_store& enable_all_logic_ops() { disabled_logic_set_.clear(); - return *this; + return (*this); } settings_store& enable_all_arithmetic_ops() { disabled_arithmetic_set_.clear(); - return *this; + return (*this); } settings_store& enable_all_assignment_ops() { disabled_assignment_set_.clear(); - return *this; + return (*this); } settings_store& enable_all_inequality_ops() { disabled_inequality_set_.clear(); - return *this; + return (*this); } settings_store& enable_local_vardef() { disable_vardef_ = false; - return *this; + return (*this); } settings_store& disable_all_base_functions() @@ -19208,7 +19399,7 @@ details::base_function_list + details::base_function_list_size, std::insert_iterator<disabled_entity_set_t> (disabled_func_set_, disabled_func_set_.begin())); - return *this; + return (*this); } settings_store& disable_all_control_structures() @@ -19217,7 +19408,7 @@ details::cntrl_struct_list + details::cntrl_struct_list_size, std::insert_iterator<disabled_entity_set_t> (disabled_ctrl_set_, disabled_ctrl_set_.begin())); - return *this; + return (*this); } settings_store& disable_all_logic_ops() @@ -19226,7 +19417,7 @@ details::logic_ops_list + details::logic_ops_list_size, std::insert_iterator<disabled_entity_set_t> (disabled_logic_set_, disabled_logic_set_.begin())); - return *this; + return (*this); } settings_store& disable_all_arithmetic_ops() @@ -19235,7 +19426,7 @@ details::arithmetic_ops_list + details::arithmetic_ops_list_size, std::insert_iterator<disabled_entity_set_t> (disabled_arithmetic_set_, disabled_arithmetic_set_.begin())); - return *this; + return (*this); } settings_store& disable_all_assignment_ops() @@ -19244,7 +19435,7 @@ details::assignment_ops_list + details::assignment_ops_list_size, std::insert_iterator<disabled_entity_set_t> (disabled_assignment_set_, disabled_assignment_set_.begin())); - return *this; + return (*this); } settings_store& disable_all_inequality_ops() @@ -19253,13 +19444,13 @@ details::inequality_ops_list + details::inequality_ops_list_size, std::insert_iterator<disabled_entity_set_t> (disabled_inequality_set_, disabled_inequality_set_.begin())); - return *this; + return (*this); } settings_store& disable_local_vardef() { disable_vardef_ = true; - return *this; + return (*this); } bool replacer_enabled () const { return enable_replacer_; } @@ -19388,7 +19579,7 @@ disabled_func_set_.insert(details::base_function_list[bf - 1]); } - return *this; + return (*this); } settings_store& disable_control_structure(settings_control_structs ctrl_struct) @@ -19401,7 +19592,7 @@ disabled_ctrl_set_.insert(details::cntrl_struct_list[ctrl_struct - 1]); } - return *this; + return (*this); } settings_store& disable_logic_operation(settings_logic_opr logic) @@ -19414,7 +19605,7 @@ disabled_logic_set_.insert(details::logic_ops_list[logic - 1]); } - return *this; + return (*this); } settings_store& disable_arithmetic_operation(settings_arithmetic_opr arithmetic) @@ -19427,7 +19618,7 @@ disabled_arithmetic_set_.insert(details::arithmetic_ops_list[arithmetic - 1]); } - return *this; + return (*this); } settings_store& disable_assignment_operation(settings_assignment_opr assignment) @@ -19440,7 +19631,7 @@ disabled_assignment_set_.insert(details::assignment_ops_list[assignment - 1]); } - return *this; + return (*this); } settings_store& disable_inequality_operation(settings_inequality_opr inequality) @@ -19453,7 +19644,7 @@ disabled_inequality_set_.insert(details::inequality_ops_list[inequality - 1]); } - return *this; + return (*this); } settings_store& enable_base_function(settings_base_funcs bf) @@ -19463,7 +19654,7 @@ (static_cast<std::size_t>(bf) < (details::base_function_list_size + 1)) ) { - des_itr_t itr = disabled_func_set_.find(details::base_function_list[bf - 1]); + const des_itr_t itr = disabled_func_set_.find(details::base_function_list[bf - 1]); if (disabled_func_set_.end() != itr) { @@ -19471,7 +19662,7 @@ } } - return *this; + return (*this); } settings_store& enable_control_structure(settings_control_structs ctrl_struct) @@ -19481,7 +19672,7 @@ (static_cast<std::size_t>(ctrl_struct) < (details::cntrl_struct_list_size + 1)) ) { - des_itr_t itr = disabled_ctrl_set_.find(details::cntrl_struct_list[ctrl_struct - 1]); + const des_itr_t itr = disabled_ctrl_set_.find(details::cntrl_struct_list[ctrl_struct - 1]); if (disabled_ctrl_set_.end() != itr) { @@ -19489,7 +19680,7 @@ } } - return *this; + return (*this); } settings_store& enable_logic_operation(settings_logic_opr logic) @@ -19499,7 +19690,7 @@ (static_cast<std::size_t>(logic) < (details::logic_ops_list_size + 1)) ) { - des_itr_t itr = disabled_logic_set_.find(details::logic_ops_list[logic - 1]); + const des_itr_t itr = disabled_logic_set_.find(details::logic_ops_list[logic - 1]); if (disabled_logic_set_.end() != itr) { @@ -19507,7 +19698,7 @@ } } - return *this; + return (*this); } settings_store& enable_arithmetic_operation(settings_arithmetic_opr arithmetic) @@ -19517,7 +19708,7 @@ (static_cast<std::size_t>(arithmetic) < (details::arithmetic_ops_list_size + 1)) ) { - des_itr_t itr = disabled_arithmetic_set_.find(details::arithmetic_ops_list[arithmetic - 1]); + const des_itr_t itr = disabled_arithmetic_set_.find(details::arithmetic_ops_list[arithmetic - 1]); if (disabled_arithmetic_set_.end() != itr) { @@ -19525,7 +19716,7 @@ } } - return *this; + return (*this); } settings_store& enable_assignment_operation(settings_assignment_opr assignment) @@ -19535,7 +19726,7 @@ (static_cast<std::size_t>(assignment) < (details::assignment_ops_list_size + 1)) ) { - des_itr_t itr = disabled_assignment_set_.find(details::assignment_ops_list[assignment - 1]); + const des_itr_t itr = disabled_assignment_set_.find(details::assignment_ops_list[assignment - 1]); if (disabled_assignment_set_.end() != itr) { @@ -19543,7 +19734,7 @@ } } - return *this; + return (*this); } settings_store& enable_inequality_operation(settings_inequality_opr inequality) @@ -19553,7 +19744,7 @@ (static_cast<std::size_t>(inequality) < (details::inequality_ops_list_size + 1)) ) { - des_itr_t itr = disabled_inequality_set_.find(details::inequality_ops_list[inequality - 1]); + const des_itr_t itr = disabled_inequality_set_.find(details::inequality_ops_list[inequality - 1]); if (disabled_inequality_set_.end() != itr) { @@ -19561,7 +19752,7 @@ } } - return *this; + return (*this); } private: @@ -19769,7 +19960,8 @@ { set_error( make_error(parser_error::e_syntax, - "ERR000 - Empty expression!")); + "ERR000 - Empty expression!", + exprtk_error_location)); return false; } @@ -19784,7 +19976,8 @@ { set_error( make_error(parser_error::e_syntax, - "ERR001 - Empty expression!")); + "ERR001 - Empty expression!", + exprtk_error_location)); return false; } @@ -19830,7 +20023,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR002 - Invalid expression encountered")); + "ERR002 - Invalid expression encountered", + exprtk_error_location)); } dec_.clear (); @@ -19839,13 +20033,24 @@ if ((0 != e) && branch_deletable(e)) { - delete e; + destroy_node(e); } return false; } } + inline expression_t compile(const std::string& expression_string, symbol_table_t& symtab) + { + expression_t expr; + + expr.register_symbol_table(symtab); + + compile(expression_string,expr); + + return expr; + } + void process_lexer_errors() { for (std::size_t i = 0; i < lexer().size(); ++i) @@ -19877,7 +20082,8 @@ set_error( make_error(parser_error::e_lexer, lexer()[i], - diagnostic + ": " + lexer()[i].value)); + diagnostic + ": " + lexer()[i].value, + exprtk_error_location)); } } } @@ -19918,7 +20124,8 @@ set_error( make_error(parser_error::e_token, bracket_checker_ptr->error_token(), - "ERR004 - Mismatched brackets: '" + bracket_checker_ptr->error_token().value + "'")); + "ERR004 - Mismatched brackets: '" + bracket_checker_ptr->error_token().value + "'", + exprtk_error_location)); } else if (0 != (numeric_checker_ptr = dynamic_cast<lexer::helper::numeric_checker*>(helper_assembly_.error_token_scanner))) { @@ -19929,7 +20136,8 @@ set_error( make_error(parser_error::e_token, error_token, - "ERR005 - Invalid numeric token: '" + error_token.value + "'")); + "ERR005 - Invalid numeric token: '" + error_token.value + "'", + exprtk_error_location)); } if (numeric_checker_ptr->error_count()) @@ -19948,7 +20156,8 @@ error_token.first, "ERR006 - Invalid token sequence: '" + error_token.first.value + "' and '" + - error_token.second.value + "'")); + error_token.second.value + "'", + exprtk_error_location)); } if (sequence_validator_ptr->error_count()) @@ -20118,7 +20327,7 @@ expression_node_ptr result = error_node(); - scoped_vec_delete<expression_node_t> sdd(*this,arg_list); + scoped_vec_delete<expression_node_t> sdd((*this),arg_list); lexer::token begin_token; lexer::token end_token; @@ -20138,7 +20347,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR007 - Invalid expression encountered")); + "ERR007 - Invalid expression encountered", + exprtk_error_location)); } return error_node(); @@ -20278,6 +20488,7 @@ static const std::string s_ilike = "ilike"; static const std::string s_and1 = "&"; static const std::string s_or1 = "|"; + static const std::string s_not = "not"; if (details::imatch(current_token().value,s_and)) { @@ -20342,6 +20553,10 @@ current_state.set(e_level04, e_level04, details::e_ilike); break; } + else if (details::imatch(current_token().value,s_not)) + { + break; + } } break_loop = true; @@ -20369,7 +20584,8 @@ set_error( make_error(parser_error::e_syntax, prev_token, - "ERR008 - Invalid arithmetic operation '" + details::to_str(current_state.operation) + "'")); + "ERR008 - Invalid arithmetic operation '" + details::to_str(current_state.operation) + "'", + exprtk_error_location)); return error_node(); } @@ -20380,7 +20596,8 @@ set_error( make_error(parser_error::e_syntax, prev_token, - "ERR009 - Invalid inequality operation '" + details::to_str(current_state.operation) + "'")); + "ERR009 - Invalid inequality operation '" + details::to_str(current_state.operation) + "'", + exprtk_error_location)); return error_node(); } @@ -20391,7 +20608,8 @@ set_error( make_error(parser_error::e_syntax, prev_token, - "ERR010 - Invalid assignment operation '" + details::to_str(current_state.operation) + "'")); + "ERR010 - Invalid assignment operation '" + details::to_str(current_state.operation) + "'", + exprtk_error_location)); return error_node(); } @@ -20409,7 +20627,8 @@ set_error( make_error(parser_error::e_syntax, prev_token, - "ERR011 - Return statements cannot be part of sub-expressions")); + "ERR011 - Return statements cannot be part of sub-expressions", + exprtk_error_location)); return error_node(); } @@ -20431,7 +20650,8 @@ prev_token, !synthesis_error_.empty() ? synthesis_error_ : - "ERR012 - General parsing error at token: '" + prev_token.value + "'")); + "ERR012 - General parsing error at token: '" + prev_token.value + "'", + exprtk_error_location)); } free_node(node_allocator_,expression); @@ -20499,7 +20719,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR013 - Failed to find variable node in symbol table")); + "ERR013 - Failed to find variable node in symbol table", + exprtk_error_location)); free_node(node_allocator_,node); @@ -20678,7 +20899,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR014 - Invalid number of parameters for function: '" + function_name + "'")); + "ERR014 - Invalid number of parameters for function: '" + function_name + "'", + exprtk_error_location)); return error_node(); } @@ -20691,7 +20913,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR015 - Failed to generate call to function: '" + function_name + "'")); + "ERR015 - Failed to generate call to function: '" + function_name + "'", + exprtk_error_location)); return error_node(); } @@ -20709,7 +20932,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR016 - Expecting ifunction '" + function_name + "' to have non-zero parameter count")); + "ERR016 - Expecting ifunction '" + function_name + "' to have non-zero parameter count", + exprtk_error_location)); return error_node(); } @@ -20722,7 +20946,7 @@ std::fill_n(branch, NumberofParameters, reinterpret_cast<expression_node_ptr>(0)); - scoped_delete<expression_node_t,NumberofParameters> sd(*this,branch); + scoped_delete<expression_node_t,NumberofParameters> sd((*this),branch); next_token(); @@ -20731,7 +20955,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR017 - Expecting argument list for function: '" + function_name + "'")); + "ERR017 - Expecting argument list for function: '" + function_name + "'", + exprtk_error_location)); return error_node(); } @@ -20745,7 +20970,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR018 - Failed to parse argument " + details::to_str(i) + " for function: '" + function_name + "'")); + "ERR018 - Failed to parse argument " + details::to_str(i) + " for function: '" + function_name + "'", + exprtk_error_location)); return error_node(); } @@ -20756,7 +20982,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR019 - Invalid number of arguments for function: '" + function_name + "'")); + "ERR019 - Invalid number of arguments for function: '" + function_name + "'", + exprtk_error_location)); return error_node(); } @@ -20768,7 +20995,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR020 - Invalid number of arguments for function: '" + function_name + "'")); + "ERR020 - Invalid number of arguments for function: '" + function_name + "'", + exprtk_error_location)); return error_node(); } @@ -20796,7 +21024,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR021 - Expecting '()' to proceed call to function: '" + function_name + "'")); + "ERR021 - Expecting '()' to proceed call to function: '" + function_name + "'", + exprtk_error_location)); free_node(node_allocator_,result); @@ -20807,11 +21036,11 @@ } template <std::size_t MaxNumberofParameters> - inline std::size_t parse_base_function_call(expression_node_ptr (¶m_list)[MaxNumberofParameters]) + inline std::size_t parse_base_function_call(expression_node_ptr (¶m_list)[MaxNumberofParameters], const std::string& function_name = "") { std::fill_n(param_list, MaxNumberofParameters, reinterpret_cast<expression_node_ptr>(0)); - scoped_delete<expression_node_t,MaxNumberofParameters> sd(*this,param_list); + scoped_delete<expression_node_t,MaxNumberofParameters> sd((*this),param_list); next_token(); @@ -20820,7 +21049,20 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR022 - Expected a '(' at start of function call, instead got: '" + current_token().value + "'")); + "ERR022 - Expected a '(' at start of function call to '" + function_name + + "', instead got: '" + current_token().value + "'", + exprtk_error_location)); + + return 0; + } + + if (token_is(token_t::e_rbracket, e_hold)) + { + set_error( + make_error(parser_error::e_syntax, + current_token(), + "ERR023 - Expected at least one input parameter for function call '" + function_name + "'", + exprtk_error_location)); return 0; } @@ -20834,7 +21076,10 @@ if (0 == param_list[param_index]) return 0; else if (token_is(token_t::e_rbracket)) + { + sd.delete_ptr = false; break; + } else if (token_is(token_t::e_comma)) continue; else @@ -20842,13 +21087,23 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR023 - Expected a ',' between function input parameters, instead got: '" + current_token().value + "'")); + "ERR024 - Expected a ',' between function input parameters, instead got: '" + current_token().value + "'", + exprtk_error_location)); return 0; } } - sd.delete_ptr = false; + if (sd.delete_ptr) + { + set_error( + make_error(parser_error::e_syntax, + current_token(), + "ERR025 - Invalid number of input parameters passed to function '" + function_name + "'", + exprtk_error_location)); + + return 0; + } return (param_index + 1); } @@ -20857,7 +21112,8 @@ { typedef std::pair<base_ops_map_t::iterator,base_ops_map_t::iterator> map_range_t; - const std::string operation_name = current_token().value; + const std::string operation_name = current_token().value; + const token_t diagnostic_token = current_token(); map_range_t itr_range = base_ops_map_.equal_range(operation_name); @@ -20865,8 +21121,9 @@ { set_error( make_error(parser_error::e_syntax, - current_token(), - "ERR024 - No entry found for base operation: " + operation_name)); + diagnostic_token, + "ERR026 - No entry found for base operation: " + operation_name, + exprtk_error_location)); return error_node(); } @@ -20874,13 +21131,9 @@ static const std::size_t MaxNumberofParameters = 4; expression_node_ptr param_list[MaxNumberofParameters] = {0}; - const std::size_t parameter_count = parse_base_function_call(param_list); + const std::size_t parameter_count = parse_base_function_call(param_list, operation_name); - if (0 == parameter_count) - { - return error_node(); - } - else if (parameter_count <= MaxNumberofParameters) + if ((parameter_count > 0) && (parameter_count <= MaxNumberofParameters)) { for (base_ops_map_t::iterator itr = itr_range.first; itr != itr_range.second; ++itr) { @@ -20910,13 +21163,14 @@ for (std::size_t i = 0; i < MaxNumberofParameters; ++i) { - free_node(node_allocator_,param_list[i]); + free_node(node_allocator_, param_list[i]); } set_error( make_error(parser_error::e_syntax, - current_token(), - "ERR025 - Invalid number of parameters for call to function: '" + operation_name + "'")); + diagnostic_token, + "ERR027 - Invalid number of input parameters for call to function: '" + operation_name + "'", + exprtk_error_location)); return error_node(); } @@ -20935,7 +21189,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR026 - Expected ',' between if-statement condition and consequent")); + "ERR028 - Expected ',' between if-statement condition and consequent", + exprtk_error_location)); result = false; } else if (0 == (consequent = parse_expression())) @@ -20943,7 +21198,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR027 - Failed to parse consequent for if-statement")); + "ERR029 - Failed to parse consequent for if-statement", + exprtk_error_location)); result = false; } else if (!token_is(token_t::e_comma)) @@ -20951,7 +21207,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR028 - Expected ',' between if-statement consequent and alternative")); + "ERR030 - Expected ',' between if-statement consequent and alternative", + exprtk_error_location)); result = false; } else if (0 == (alternative = parse_expression())) @@ -20959,7 +21216,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR029 - Failed to parse alternative for if-statement")); + "ERR031 - Failed to parse alternative for if-statement", + exprtk_error_location)); result = false; } else if (!token_is(token_t::e_rbracket)) @@ -20967,7 +21225,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR030 - Expected ')' at the end of if-statement")); + "ERR032 - Expected ')' at the end of if-statement", + exprtk_error_location)); result = false; } @@ -20988,7 +21247,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR031 - Return types of ternary if-statement differ")); + "ERR033 - Return types of ternary if-statement differ", + exprtk_error_location)); result = false; } @@ -21022,7 +21282,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR032 - Failed to parse body of consequent for if-statement")); + "ERR034 - Failed to parse body of consequent for if-statement", + exprtk_error_location)); + result = false; } } @@ -21043,7 +21305,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR033 - Expected ';' at the end of the consequent for if-statement")); + "ERR035 - Expected ';' at the end of the consequent for if-statement", + exprtk_error_location)); + result = false; } } @@ -21052,7 +21316,9 @@ 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; } } @@ -21070,7 +21336,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR035 - Failed to parse body of the 'else' for if-statement")); + "ERR037 - Failed to parse body of the 'else' for if-statement", + exprtk_error_location)); + result = false; } } @@ -21081,7 +21349,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR036 - Failed to parse body of if-else statement")); + "ERR038 - Failed to parse body of if-else statement", + exprtk_error_location)); + result = false; } } @@ -21092,7 +21362,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR037 - Expected ';' at the end of the 'else-if' for the if-statement")); + "ERR039 - Expected ';' at the end of the 'else-if' for the if-statement", + exprtk_error_location)); + result = false; } } @@ -21101,7 +21373,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR038 - Failed to parse body of the 'else' for if-statement")); + "ERR040 - Failed to parse body of the 'else' for if-statement", + exprtk_error_location)); + result = false; } } @@ -21124,7 +21398,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR039 - Return types of ternary if-statement differ")); + "ERR041 - Return types of ternary if-statement differ", + exprtk_error_location)); result = false; } @@ -21155,7 +21430,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR040 - Expected '(' at start of if-statement, instead got: '" + current_token().value + "'")); + "ERR042 - Expected '(' at start of if-statement, instead got: '" + current_token().value + "'", + exprtk_error_location)); return error_node(); } @@ -21164,7 +21440,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR041 - Failed to parse condition for if-statement")); + "ERR043 - Failed to parse condition for if-statement", + exprtk_error_location)); return error_node(); } @@ -21195,7 +21472,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR042 - Invalid if-statement")); + "ERR044 - Invalid if-statement", + exprtk_error_location)); free_node(node_allocator_,condition); @@ -21215,7 +21493,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR043 - Encountered invalid condition branch for ternary if-statement")); + "ERR045 - Encountered invalid condition branch for ternary if-statement", + exprtk_error_location)); return error_node(); } @@ -21224,7 +21503,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR044 - Expected '?' after condition of ternary if-statement")); + "ERR046 - Expected '?' after condition of ternary if-statement", + exprtk_error_location)); result = false; } @@ -21233,7 +21513,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR045 - Failed to parse consequent for ternary if-statement")); + "ERR047 - Failed to parse consequent for ternary if-statement", + exprtk_error_location)); result = false; } @@ -21242,7 +21523,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR046 - Expected ':' between ternary if-statement consequent and alternative")); + "ERR048 - Expected ':' between ternary if-statement consequent and alternative", + exprtk_error_location)); result = false; } @@ -21251,7 +21533,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR047 - Failed to parse alternative for ternary if-statement")); + "ERR049 - Failed to parse alternative for ternary if-statement", + exprtk_error_location)); result = false; } @@ -21273,7 +21556,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR048 - Return types of ternary if-statement differ")); + "ERR050 - Return types of ternary if-statement differ", + exprtk_error_location)); result = false; } @@ -21309,7 +21593,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR049 - Expected '(' at start of while-loop condition statement")); + "ERR051 - Expected '(' at start of while-loop condition statement", + exprtk_error_location)); return error_node(); } @@ -21318,7 +21603,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR050 - Failed to parse condition for while-loop")); + "ERR052 - Failed to parse condition for while-loop", + exprtk_error_location)); return error_node(); } @@ -21327,7 +21613,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR051 - Expected ')' at end of while-loop condition statement")); + "ERR053 - Expected ')' at end of while-loop condition statement", + exprtk_error_location)); + result = false; } @@ -21340,7 +21628,7 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR052 - Failed to parse body of while-loop")); + "ERR054 - Failed to parse body of while-loop")); result = false; } else if (0 == (result_node = expression_generator_.while_loop(condition, @@ -21350,7 +21638,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR053 - Failed to synthesize while-loop")); + "ERR055 - Failed to synthesize while-loop", + exprtk_error_location)); + result = false; } } @@ -21379,7 +21669,7 @@ std::vector<expression_node_ptr> arg_list; std::vector<bool> side_effect_list; - scoped_vec_delete<expression_node_t> sdd(*this,arg_list); + scoped_vec_delete<expression_node_t> sdd((*this),arg_list); brkcnt_list_.push_front(false); @@ -21424,7 +21714,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR054 - Expected '" + token_t::to_str(seperator) + "' in body of repeat until loop")); + "ERR056 - Expected '" + token_t::to_str(seperator) + "' in body of repeat until loop", + exprtk_error_location)); return error_node(); } @@ -21447,7 +21738,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR055 - Failed to parse body of repeat until loop")); + "ERR057 - Failed to parse body of repeat until loop", + exprtk_error_location)); return error_node(); } @@ -21460,7 +21752,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR056 - Expected '(' before condition statement of repeat until loop")); + "ERR058 - Expected '(' before condition statement of repeat until loop", + exprtk_error_location)); free_node(node_allocator_,branch); @@ -21473,7 +21766,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR057 - Failed to parse condition for repeat until loop")); + "ERR059 - Failed to parse condition for repeat until loop", + exprtk_error_location)); free_node(node_allocator_,branch); @@ -21484,7 +21778,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR058 - Expected ')' after condition of repeat until loop")); + "ERR060 - Expected ')' after condition of repeat until loop", + exprtk_error_location)); free_node(node_allocator_, branch); free_node(node_allocator_, condition); @@ -21504,7 +21799,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR059 - Failed to synthesize repeat until loop")); + "ERR061 - Failed to synthesize repeat until loop", + exprtk_error_location)); free_node(node_allocator_,condition); @@ -21539,7 +21835,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR060 - Expected '(' at start of for-loop")); + "ERR062 - Expected '(' at start of for-loop", + exprtk_error_location)); return error_node(); } @@ -21558,7 +21855,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR061 - Expected a variable at the start of initialiser section of for-loop")); + "ERR063 - Expected a variable at the start of initialiser section of for-loop", + exprtk_error_location)); return error_node(); } @@ -21567,7 +21865,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR062 - Expected variable assignment of initialiser section of for-loop")); + "ERR064 - Expected variable assignment of initialiser section of for-loop", + exprtk_error_location)); return error_node(); } @@ -21581,7 +21880,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR063 - For-loop variable '" + loop_counter_symbol+ "' is being shadowed by a previous declaration")); + "ERR065 - For-loop variable '" + loop_counter_symbol+ "' is being shadowed by a previous declaration", + exprtk_error_location)); return error_node(); } @@ -21612,7 +21912,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR064 - Failed to add new local variable '" + loop_counter_symbol + "' to SEM")); + "ERR066 - Failed to add new local variable '" + loop_counter_symbol + "' to SEM", + exprtk_error_location)); sem_.free_element(nse); @@ -21633,7 +21934,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR065 - Failed to parse initialiser of for-loop")); + "ERR067 - Failed to parse initialiser of for-loop", + exprtk_error_location)); + result = false; } else if (!token_is(token_t::e_eof)) @@ -21641,7 +21944,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR066 - Expected ';' after initialiser of for-loop")); + "ERR068 - Expected ';' after initialiser of for-loop", + exprtk_error_location)); + result = false; } } @@ -21653,7 +21958,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR067 - Failed to parse condition of for-loop")); + "ERR069 - Failed to parse condition of for-loop", + exprtk_error_location)); + result = false; } else if (!token_is(token_t::e_eof)) @@ -21661,7 +21968,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR068 - Expected ';' after condition section of for-loop")); + "ERR070 - Expected ';' after condition section of for-loop", + exprtk_error_location)); + result = false; } } @@ -21673,7 +21982,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR069 - Failed to parse incrementor of for-loop")); + "ERR071 - Failed to parse incrementor of for-loop", + exprtk_error_location)); + result = false; } else if (!token_is(token_t::e_rbracket)) @@ -21681,7 +21992,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR070 - Expected ')' after incrementor section of for-loop")); + "ERR072 - Expected ')' after incrementor section of for-loop", + exprtk_error_location)); + result = false; } } @@ -21695,7 +22008,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR071 - Failed to parse body of for-loop")); + "ERR073 - Failed to parse body of for-loop", + exprtk_error_location)); + result = false; } } @@ -21745,12 +22060,13 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR072 - Expected keyword 'switch'")); + "ERR074 - Expected keyword 'switch'", + exprtk_error_location)); return error_node(); } - scoped_vec_delete<expression_node_t> svd(*this,arg_list); + scoped_vec_delete<expression_node_t> svd((*this),arg_list); next_token(); @@ -21759,7 +22075,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR073 - Expected '{' for call to switch statement")); + "ERR075 - Expected '{' for call to switch statement", + exprtk_error_location)); return error_node(); } @@ -21771,7 +22088,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR074 - Expected either a 'case' or 'default' statement")); + "ERR076 - Expected either a 'case' or 'default' statement", + exprtk_error_location)); return error_node(); } @@ -21787,7 +22105,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR075 - Expected ':' for case of switch statement")); + "ERR077 - Expected ':' for case of switch statement", + exprtk_error_location)); return error_node(); } @@ -21801,7 +22120,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR076 - Expected ';' at end of case for switch statement")); + "ERR078 - Expected ';' at end of case for switch statement", + exprtk_error_location)); return error_node(); } @@ -21826,7 +22146,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR077 - Expected ':' for default of switch statement")); + "ERR079 - Expected ':' for default of switch statement", + exprtk_error_location)); return error_node(); } @@ -21847,7 +22168,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR078 - Expected ';' at end of default for switch statement")); + "ERR080 - Expected ';' at end of default for switch statement", + exprtk_error_location)); return error_node(); } @@ -21862,7 +22184,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR079 - Expected '}' at end of switch statement")); + "ERR081 - Expected '}' at end of switch statement", + exprtk_error_location)); return error_node(); } @@ -21884,12 +22207,13 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR080 - Expected token '[*]'")); + "ERR082 - Expected token '[*]'", + exprtk_error_location)); return error_node(); } - scoped_vec_delete<expression_node_t> svd(*this,arg_list); + scoped_vec_delete<expression_node_t> svd((*this),arg_list); next_token(); @@ -21898,7 +22222,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR081 - Expected '{' for call to [*] statement")); + "ERR083 - Expected '{' for call to [*] statement", + exprtk_error_location)); return error_node(); } @@ -21910,7 +22235,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR082 - Expected a 'case' statement for multi-switch")); + "ERR084 - Expected a 'case' statement for multi-switch", + exprtk_error_location)); return error_node(); } @@ -21927,7 +22253,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR083 - Expected ':' for case of [*] statement")); + "ERR085 - Expected ':' for case of [*] statement", + exprtk_error_location)); return error_node(); } @@ -21942,7 +22269,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR084 - Expected ';' at end of case for [*] statement")); + "ERR086 - Expected ';' at end of case for [*] statement", + exprtk_error_location)); return error_node(); } @@ -21970,7 +22298,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR085 - Expected '}' at end of [*] statement")); + "ERR087 - Expected '}' at end of [*] statement", + exprtk_error_location)); return error_node(); } @@ -22011,12 +22340,13 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR086 - Unsupported vararg function: " + symbol)); + "ERR088 - Unsupported vararg function: " + symbol, + exprtk_error_location)); return error_node(); } - scoped_vec_delete<expression_node_t> sdd(*this,arg_list); + scoped_vec_delete<expression_node_t> sdd((*this),arg_list); lodge_symbol(symbol,e_st_function); @@ -22027,7 +22357,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR087 - Expected '(' for call to vararg function: " + symbol)); + "ERR089 - Expected '(' for call to vararg function: " + symbol, + exprtk_error_location)); return error_node(); } @@ -22048,7 +22379,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR088 - Expected ',' for call to vararg function: " + symbol)); + "ERR090 - Expected ',' for call to vararg function: " + symbol, + exprtk_error_location)); return error_node(); } @@ -22068,7 +22400,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR089 - Expected '[' as start of string range definition")); + "ERR091 - Expected '[' as start of string range definition", + exprtk_error_location)); free_node(node_allocator_,expression); @@ -22095,7 +22428,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR090 - Failed to generate string range node")); + "ERR092 - Failed to generate string range node", + exprtk_error_location)); free_node(node_allocator_,expression); } @@ -22230,8 +22564,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR091 - Expected '" + token_t::to_str(close_bracket) + "' for call to multi-sequence" + - ((!source.empty()) ? std::string(" section of " + source): ""))); + "ERR093 - Expected '" + token_t::to_str(close_bracket) + "' for call to multi-sequence" + + ((!source.empty()) ? std::string(" section of " + source): ""), + exprtk_error_location)); return error_node(); } @@ -22246,7 +22581,7 @@ expression_node_ptr result = error_node(); - scoped_vec_delete<expression_node_t> sdd(*this,arg_list); + scoped_vec_delete<expression_node_t> sdd((*this),arg_list); scope_handler sh(*this); @@ -22276,7 +22611,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR092 - Expected '" + details::to_str(seperator) + "' for call to multi-sequence section of " + source)); + "ERR094 - Expected '" + details::to_str(seperator) + "' for call to multi-sequence section of " + source, + exprtk_error_location)); return error_node(); } @@ -22309,7 +22645,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR093 - Expected '[' for start of range")); + "ERR095 - Expected '[' for start of range", + exprtk_error_location)); return false; } @@ -22329,7 +22666,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR094 - Failed parse begin section of range")); + "ERR096 - Failed parse begin section of range", + exprtk_error_location)); return false; @@ -22352,7 +22690,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR095 - Range lower bound less than zero! Constraint: r0 >= 0")); + "ERR097 - Range lower bound less than zero! Constraint: r0 >= 0", + exprtk_error_location)); return false; } @@ -22368,9 +22707,11 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR096 - Expected ':' for break in range")); + "ERR098 - Expected ':' for break in range", + exprtk_error_location)); rp.free(); + return false; } } @@ -22389,9 +22730,11 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR097 - Failed parse end section of range")); + "ERR099 - Failed parse end section of range", + exprtk_error_location)); rp.free(); + return false; } @@ -22413,7 +22756,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR098 - Range upper bound less than zero! Constraint: r1 >= 0")); + "ERR100 - Range upper bound less than zero! Constraint: r1 >= 0", + exprtk_error_location)); return false; } @@ -22429,9 +22773,11 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR099 - Expected ']' for start of range")); + "ERR101 - Expected ']' for start of range", + exprtk_error_location)); rp.free(); + return false; } } @@ -22448,7 +22794,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR100 - Invalid range, Constraint: r0 <= r1")); + "ERR102 - Invalid range, Constraint: r0 <= r1", + exprtk_error_location)); return false; } @@ -22472,7 +22819,6 @@ expression_node_ptr result = error_node(); strvar_node_t const_str_node = static_cast<strvar_node_t>(0); - bool is_const_string = false; scope_element& se = sem_.get_active_element(symbol); @@ -22489,16 +22835,15 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR101 - Unknown string symbol")); + "ERR103 - Unknown string symbol", + exprtk_error_location)); return error_node(); } result = symtab_store_.get_stringvar(symbol); - is_const_string = symtab_store_.is_constant_string(symbol); - - if (is_const_string) + if (symtab_store_.is_constant_string(symbol)) { const_str_node = static_cast<strvar_node_t>(result); result = expression_generator_(const_str_node->str()); @@ -22604,9 +22949,10 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR102 - Overflow in range for string: '" + const_str + "'[" + + "ERR104 - 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)) : "?") + "]")); + (rp.n1_c.first ? details::to_str(static_cast<int>(rp.n1_c.second)) : "?") + "]", + exprtk_error_location)); return error_node(); } @@ -22647,7 +22993,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR103 - Symbol '" + symbol+ " not a vector")); + "ERR105 - Symbol '" + symbol+ " not a vector", + exprtk_error_location)); return error_node(); } @@ -22672,7 +23019,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR104 - Failed to parse index for vector: '" + symbol + "'")); + "ERR106 - Failed to parse index for vector: '" + symbol + "'", + exprtk_error_location)); return error_node(); } @@ -22681,7 +23029,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR105 - Expected ']' for index of vector: '" + symbol + "'")); + "ERR107 - Expected ']' for index of vector: '" + symbol + "'", + exprtk_error_location)); free_node(node_allocator_,index_expr); @@ -22699,8 +23048,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR106 - Index of " + details::to_str(index) + " out of range for " - "vector '" + symbol + "' of size " + details::to_str(vec_size))); + "ERR108 - Index of " + details::to_str(index) + " out of range for " + "vector '" + symbol + "' of size " + details::to_str(vec_size), + exprtk_error_location)); free_node(node_allocator_,index_expr); @@ -22717,7 +23067,7 @@ expression_node_ptr result = error_node(); - scoped_vec_delete<expression_node_t> sdd(*this,arg_list); + scoped_vec_delete<expression_node_t> sdd((*this),arg_list); next_token(); @@ -22730,8 +23080,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR107 - Zero parameter call to vararg function: " - + vararg_function_name + " not allowed")); + "ERR109 - Zero parameter call to vararg function: " + + vararg_function_name + " not allowed", + exprtk_error_location)); return error_node(); } @@ -22754,8 +23105,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR108 - Expected ',' for call to vararg function: " - + vararg_function_name)); + "ERR110 - Expected ',' for call to vararg function: " + + vararg_function_name, + exprtk_error_location)); return error_node(); } @@ -22767,8 +23119,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR109 - Zero parameter call to vararg function: " - + vararg_function_name + " not allowed")); + "ERR111 - Zero parameter call to vararg function: " + + vararg_function_name + " not allowed", + exprtk_error_location)); return error_node(); } @@ -22778,9 +23131,10 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR110 - Invalid number of parameters to call to vararg function: " + "ERR112 - 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")); + + details::to_str(static_cast<int>(vararg_function->min_num_args())) + " parameters", + exprtk_error_location)); return error_node(); } @@ -22789,9 +23143,10 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR111 - Invalid number of parameters to call to vararg function: " + "ERR113 - 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")); + + details::to_str(static_cast<int>(vararg_function->max_num_args())) + " parameters", + exprtk_error_location)); return error_node(); } @@ -22851,8 +23206,9 @@ set_error( make_error(parser_error::e_syntax, parser_.current_token(), - "ERR112 - Failed parameter type check for function '" + function_name_ + "', " - "Expected '" + param_seq_list_[0] + "' call set: '" + param_seq +"'")); + "ERR114 - Failed parameter type check for function '" + function_name_ + "', " + "Expected '" + param_seq_list_[0] + "' call set: '" + param_seq +"'", + exprtk_error_location)); } else { @@ -22871,8 +23227,9 @@ set_error( make_error(parser_error::e_syntax, parser_.current_token(), - "ERR113 - Failed parameter type check for function '" + function_name_ + "', " - "Best match: '" + param_seq_list_[max_diff_index] + "' call set: '" + param_seq +"'")); + "ERR115 - Failed parameter type check for function '" + function_name_ + "', " + "Best match: '" + param_seq_list_[max_diff_index] + "' call set: '" + param_seq +"'", + exprtk_error_location)); } return false; @@ -22955,8 +23312,9 @@ set_error( make_error(parser_error::e_syntax, parser_.current_token(), - "ERR114 - Invalid parameter sequence of '" + err_param_seq + - "' for function: " + function_name_)); + "ERR116 - Invalid parameter sequence of '" + err_param_seq + + "' for function: " + function_name_, + exprtk_error_location)); return; } @@ -22976,8 +23334,9 @@ set_error( make_error(parser_error::e_syntax, parser_.current_token(), - "ERR115 - Invalid parameter sequence of '" + err_param_seq + - "' for function: " + function_name_)); + "ERR117 - Invalid parameter sequence of '" + err_param_seq + + "' for function: " + function_name_, + exprtk_error_location)); return; } } @@ -22996,20 +23355,21 @@ { std::vector<expression_node_ptr> arg_list; - scoped_vec_delete<expression_node_t> sdd(*this,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); + type_checker tc((*this), function_name, function->parameter_sequence); if (tc.invalid()) { set_error( make_error(parser_error::e_syntax, current_token(), - "ERR116 - Type checker instantiation failure for generic function: " + function_name)); + "ERR118 - Type checker instantiation failure for generic function: " + function_name, + exprtk_error_location)); return error_node(); } @@ -23023,8 +23383,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR117 - Mismatch in zero parameter condition for generic function: " - + function_name)); + "ERR119 - Mismatch in zero parameter condition for generic function: " + + function_name, + exprtk_error_location)); return error_node(); } @@ -23041,8 +23402,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR118 - Zero parameter call to generic function: " - + function_name + " not allowed")); + "ERR120 - Zero parameter call to generic function: " + + function_name + " not allowed", + exprtk_error_location)); return error_node(); } @@ -23072,7 +23434,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR119 - Expected ',' for call to generic function: " + function_name)); + "ERR121 - Expected ',' for call to generic function: " + function_name, + exprtk_error_location)); return error_node(); } @@ -23088,8 +23451,9 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR120 - Zero parameter call to generic function: " - + function_name + " not allowed")); + "ERR122 - Zero parameter call to generic function: " + + function_name + " not allowed", + exprtk_error_location)); return error_node(); } @@ -23104,7 +23468,8 @@ 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(); } @@ -23128,13 +23493,13 @@ { std::vector<expression_node_ptr> arg_list; - scoped_vec_delete<expression_node_t> sdd(*this,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); + type_checker tc((*this), function_name, function->parameter_sequence); if ( (!function->parameter_sequence.empty()) && @@ -23171,7 +23536,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR122 - Expected ',' for call to string function: " + function_name)); + "ERR124 - Expected ',' for call to string function: " + function_name, + exprtk_error_location)); return error_node(); } @@ -23186,7 +23552,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR123 - Expected ',' for call to string function: " + function_name)); + "ERR125 - Expected ',' for call to string function: " + function_name, + exprtk_error_location)); return error_node(); } @@ -23225,7 +23592,8 @@ p.set_error( make_error(parser_error::e_syntax, p.current_token(), - "ERR124 - Expected '(' for special function")); + "ERR126 - Expected '(' for special function", + exprtk_error_location)); return error_node(); } @@ -23245,7 +23613,8 @@ p.set_error( make_error(parser_error::e_syntax, p.current_token(), - "ERR125 - Expected ',' before next parameter of special function")); + "ERR127 - Expected ',' before next parameter of special function", + exprtk_error_location)); return p.error_node(); } @@ -23274,7 +23643,8 @@ set_error( make_error(parser_error::e_token, current_token(), - "ERR126 - Invalid special function[1]: " + current_token().value)); + "ERR128 - Invalid special function[1]: " + current_token().value, + exprtk_error_location)); return error_node(); } @@ -23287,7 +23657,8 @@ set_error( make_error(parser_error::e_token, current_token(), - "ERR127 - Invalid special function[2]: " + current_token().value)); + "ERR129 - Invalid special function[2]: " + current_token().value, + exprtk_error_location)); return error_node(); } @@ -23298,8 +23669,8 @@ switch (NumberOfParameters) { - case 3 : return parse_special_function_impl<T,3>::process(*this,opt_type); - case 4 : return parse_special_function_impl<T,4>::process(*this,opt_type); + case 3 : return parse_special_function_impl<T,3>::process((*this),opt_type); + case 4 : return parse_special_function_impl<T,4>::process((*this),opt_type); default : return error_node(); } } @@ -23318,7 +23689,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR128 - Break call within a break call is not allowed")); + "ERR130 - Break call within a break call is not allowed", + exprtk_error_location)); return error_node(); } @@ -23340,7 +23712,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR129 - Failed to parse return expression for 'break' statement")); + "ERR131 - Failed to parse return expression for 'break' statement", + exprtk_error_location)); return error_node(); } @@ -23349,7 +23722,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR130 - Expected ']' at the completion of break's return expression")); + "ERR132 - Expected ']' at the completion of break's return expression", + exprtk_error_location)); free_node(node_allocator_,return_expr); @@ -23366,7 +23740,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR131 - Invalid use of 'break', allowed only in the scope of a loop")); + "ERR133 - Invalid use of 'break', allowed only in the scope of a loop", + exprtk_error_location)); } return error_node(); @@ -23388,7 +23763,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR132 - Invalid use of 'continue', allowed only in the scope of a loop")); + "ERR134 - Invalid use of 'continue', allowed only in the scope of a loop", + exprtk_error_location)); return error_node(); } @@ -23404,7 +23780,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR133 - Expected '[' as part of vector size definition")); + "ERR135 - Expected '[' as part of vector size definition", + exprtk_error_location)); return error_node(); } @@ -23413,7 +23790,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR134 - Failed to determine size of vector '" + vec_name + "'")); + "ERR136 - Failed to determine size of vector '" + vec_name + "'", + exprtk_error_location)); return error_node(); } @@ -23424,7 +23802,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR135 - Expected a literal number as size of vector '" + vec_name + "'")); + "ERR137 - Expected a literal number as size of vector '" + vec_name + "'", + exprtk_error_location)); return error_node(); } @@ -23442,15 +23821,16 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR136 - Invalid vector size. Must be an integer greater than zero, size: " + - details::to_str(details::numeric::to_int32(vector_size)))); + "ERR138 - Invalid vector size. Must be an integer greater than zero, size: " + + details::to_str(details::numeric::to_int32(vector_size)), + exprtk_error_location)); return error_node(); } std::vector<expression_node_ptr> vec_initilizer_list; - scoped_vec_delete<expression_node_t> svd(*this,vec_initilizer_list); + scoped_vec_delete<expression_node_t> svd((*this),vec_initilizer_list); bool single_value_initialiser = false; bool vec_to_vec_initialiser = false; @@ -23461,7 +23841,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR137 - Expected ']' as part of vector size definition")); + "ERR139 - Expected ']' as part of vector size definition", + exprtk_error_location)); return error_node(); } @@ -23472,7 +23853,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR138 - Expected ':=' as part of vector definition")); + "ERR140 - Expected ':=' as part of vector definition", + exprtk_error_location)); return error_node(); } @@ -23485,7 +23867,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR139 - Failed to parse single vector initialiser")); + "ERR141 - Failed to parse single vector initialiser", + exprtk_error_location)); return error_node(); } @@ -23497,7 +23880,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR140 - Expected ']' to close single value vector initialiser")); + "ERR142 - Expected ']' to close single value vector initialiser", + exprtk_error_location)); return error_node(); } @@ -23543,7 +23927,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR141 - Expected '{' as part of vector initialiser list")); + "ERR143 - Expected '{' as part of vector initialiser list", + exprtk_error_location)); return error_node(); } @@ -23562,7 +23947,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR142 - Expected '{' as part of vector initialiser list")); + "ERR144 - Expected '{' as part of vector initialiser list", + exprtk_error_location)); return error_node(); } @@ -23579,7 +23965,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR143 - Expected ',' between vector initialisers")); + "ERR145 - Expected ',' between vector initialisers", + exprtk_error_location)); return error_node(); } @@ -23600,7 +23987,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR144 - Expected ';' at end of vector definition")); + "ERR146 - Expected ';' at end of vector definition", + exprtk_error_location)); return error_node(); } @@ -23611,7 +23999,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR145 - Initialiser list larger than the number of elements in the vector: '" + vec_name + "'")); + "ERR147 - Initialiser list larger than the number of elements in the vector: '" + vec_name + "'", + exprtk_error_location)); return error_node(); } @@ -23630,7 +24019,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR146 - Illegal redefinition of local vector: '" + vec_name + "'")); + "ERR148 - Illegal redefinition of local vector: '" + vec_name + "'", + exprtk_error_location)); return error_node(); } @@ -23663,7 +24053,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR147 - Failed to add new local vector '" + vec_name + "' to SEM")); + "ERR149 - Failed to add new local vector '" + vec_name + "' to SEM", + exprtk_error_location)); sem_.free_element(nse); @@ -23717,7 +24108,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR148 - Illegal redefinition of local variable: '" + str_name + "'")); + "ERR150 - Illegal redefinition of local variable: '" + str_name + "'", + exprtk_error_location)); free_node(node_allocator_,initialisation_expression); @@ -23748,7 +24140,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR149 - Failed to add new local string variable '" + str_name + "' to SEM")); + "ERR151 - Failed to add new local string variable '" + str_name + "' to SEM", + exprtk_error_location)); free_node(node_allocator_,initialisation_expression); @@ -23793,7 +24186,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR150 - Illegal variable definition")); + "ERR152 - Illegal variable definition", + exprtk_error_location)); return error_node(); } @@ -23813,7 +24207,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR151 - Expected a symbol for variable definition")); + "ERR153 - Expected a symbol for variable definition", + exprtk_error_location)); return error_node(); } @@ -23822,7 +24217,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR152 - Illegal redefinition of reserved keyword: '" + var_name + "'")); + "ERR154 - Illegal redefinition of reserved keyword: '" + var_name + "'", + exprtk_error_location)); return error_node(); } @@ -23831,7 +24227,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR153 - Illegal redefinition of variable '" + var_name + "'")); + "ERR155 - Illegal redefinition of variable '" + var_name + "'", + exprtk_error_location)); return error_node(); } @@ -23840,7 +24237,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR154 - Illegal redefinition of local variable: '" + var_name + "'")); + "ERR156 - Illegal redefinition of local variable: '" + var_name + "'", + exprtk_error_location)); return error_node(); } @@ -23859,7 +24257,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR155 - Failed to parse initialisation expression")); + "ERR157 - Failed to parse initialisation expression", + exprtk_error_location)); return error_node(); } @@ -23876,7 +24275,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR156 - Expected ';' after variable definition")); + "ERR158 - Expected ';' after variable definition", + exprtk_error_location)); free_node(node_allocator_,initialisation_expression); @@ -23903,7 +24303,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR157 - Illegal redefinition of local variable: '" + var_name + "'")); + "ERR159 - Illegal redefinition of local variable: '" + var_name + "'", + exprtk_error_location)); free_node(node_allocator_, initialisation_expression); @@ -23934,7 +24335,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR158 - Failed to add new local variable '" + var_name + "' to SEM")); + "ERR160 - Failed to add new local variable '" + var_name + "' to SEM", + exprtk_error_location)); free_node(node_allocator_, initialisation_expression); @@ -23970,7 +24372,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR159 - Expected a '{}' for uninitialised var definition")); + "ERR161 - Expected a '{}' for uninitialised var definition", + exprtk_error_location)); return error_node(); } @@ -23979,7 +24382,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR160 - Expected ';' after uninitialised variable definition")); + "ERR162 - Expected ';' after uninitialised variable definition", + exprtk_error_location)); return error_node(); } @@ -23995,7 +24399,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR161 - Illegal redefinition of local variable: '" + var_name + "'")); + "ERR163 - Illegal redefinition of local variable: '" + var_name + "'", + exprtk_error_location)); return error_node(); } @@ -24024,7 +24429,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR162 - Failed to add new local variable '" + var_name + "' to SEM")); + "ERR164 - Failed to add new local variable '" + var_name + "' to SEM", + exprtk_error_location)); sem_.free_element(nse); @@ -24056,7 +24462,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR163 - Expected '(' at start of swap statement")); + "ERR165 - Expected '(' at start of swap statement", + exprtk_error_location)); return error_node(); } @@ -24074,7 +24481,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR164 - Expected a symbol for variable or vector element definition")); + "ERR166 - Expected a symbol for variable or vector element definition", + exprtk_error_location)); return error_node(); } @@ -24085,7 +24493,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR165 - First parameter to swap is an invalid vector element: '" + var0_name + "'")); + "ERR167 - First parameter to swap is an invalid vector element: '" + var0_name + "'", + exprtk_error_location)); return error_node(); } @@ -24117,7 +24526,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR166 - First parameter to swap is an invalid variable: '" + var0_name + "'")); + "ERR168 - First parameter to swap is an invalid variable: '" + var0_name + "'", + exprtk_error_location)); return error_node(); } @@ -24130,7 +24540,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR167 - Expected ',' between parameters to swap")); + "ERR169 - Expected ',' between parameters to swap", + exprtk_error_location)); if (variable0_generated) { @@ -24147,7 +24558,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR168 - Expected a symbol for variable or vector element definition")); + "ERR170 - Expected a symbol for variable or vector element definition", + exprtk_error_location)); if (variable0_generated) { @@ -24163,7 +24575,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR169 - Second parameter to swap is an invalid vector element: '" + var1_name + "'")); + "ERR171 - Second parameter to swap is an invalid vector element: '" + var1_name + "'", + exprtk_error_location)); if (variable0_generated) { @@ -24200,7 +24613,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR170 - Second parameter to swap is an invalid variable: '" + var1_name + "'")); + "ERR172 - Second parameter to swap is an invalid variable: '" + var1_name + "'", + exprtk_error_location)); if (variable0_generated) { @@ -24218,7 +24632,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR171 - Expected ')' at end of swap statement")); + "ERR173 - Expected ')' at end of swap statement", + exprtk_error_location)); if (variable0_generated) { @@ -24274,7 +24689,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR172 - Return call within a return call is not allowed")); + "ERR174 - Return call within a return call is not allowed", + exprtk_error_location)); return error_node(); } @@ -24283,7 +24699,7 @@ std::vector<expression_node_ptr> arg_list; - scoped_vec_delete<expression_node_t> sdd(*this,arg_list); + scoped_vec_delete<expression_node_t> sdd((*this),arg_list); if (!details::imatch(current_token().value,"return")) { @@ -24297,7 +24713,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR173 - Expected '[' at start of return statement")); + "ERR175 - Expected '[' at start of return statement", + exprtk_error_location)); return error_node(); } @@ -24319,7 +24736,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR174 - Expected ',' between values during call to return")); + "ERR176 - Expected ',' between values during call to return", + exprtk_error_location)); return error_node(); } @@ -24330,7 +24748,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR175 - Zero parameter return statement not allowed")); + "ERR177 - Zero parameter return statement not allowed", + exprtk_error_location)); return error_node(); } @@ -24344,7 +24763,8 @@ set_error( make_error(parser_error::e_syntax, prev_token, - "ERR176 - Invalid ']' found during return call")); + "ERR178 - Invalid ']' found during return call", + exprtk_error_location)); return error_node(); } @@ -24396,7 +24816,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR177 - Invalid sequence of variable '"+ symbol + "' and bracket")); + "ERR179 - Invalid sequence of variable '"+ symbol + "' and bracket", + exprtk_error_location)); return false; } @@ -24443,7 +24864,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR178 - Invalid sequence of brackets")); + "ERR180 - Invalid sequence of brackets", + exprtk_error_location)); return false; } @@ -24539,7 +24961,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR179 - Failed to generate node for function: '" + symbol + "'")); + "ERR181 - Failed to generate node for function: '" + symbol + "'", + exprtk_error_location)); return error_node(); } @@ -24564,7 +24987,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR180 - Failed to generate node for vararg function: '" + symbol + "'")); + "ERR182 - Failed to generate node for vararg function: '" + symbol + "'", + exprtk_error_location)); return error_node(); } @@ -24589,7 +25013,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR181 - Failed to generate node for generic function: '" + symbol + "'")); + "ERR183 - Failed to generate node for generic function: '" + symbol + "'", + exprtk_error_location)); return error_node(); } @@ -24615,7 +25040,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR182 - Failed to generate node for string function: '" + symbol + "'")); + "ERR184 - Failed to generate node for string function: '" + symbol + "'", + exprtk_error_location)); return error_node(); } @@ -24640,7 +25066,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR183 - Invalid use of reserved symbol '" + symbol + "'")); + "ERR185 - Invalid use of reserved symbol '" + symbol + "'", + exprtk_error_location)); return error_node(); } @@ -24702,8 +25129,9 @@ set_error( make_error(parser_error::e_symtab, current_token(), - "ERR184 - Failed to create variable: '" + symbol + "'" + - (error_message.empty() ? "" : " - " + error_message))); + "ERR186 - Failed to create variable: '" + symbol + "'" + + (error_message.empty() ? "" : " - " + error_message), + exprtk_error_location)); } else if (unknown_symbol_resolver::e_usrmode_extended == unknown_symbol_resolver_->mode) @@ -24721,8 +25149,9 @@ set_error( make_error(parser_error::e_symtab, current_token(), - "ERR185 - Failed to resolve symbol: '" + symbol + "'" + - (error_message.empty() ? "" : " - " + error_message))); + "ERR187 - Failed to resolve symbol: '" + symbol + "'" + + (error_message.empty() ? "" : " - " + error_message), + exprtk_error_location)); } return error_node(); @@ -24732,7 +25161,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR186 - Undefined symbol: '" + symbol + "'")); + "ERR188 - Undefined symbol: '" + symbol + "'", + exprtk_error_location)); return error_node(); } @@ -24838,7 +25268,8 @@ set_error( make_error(parser_error::e_symtab, current_token(), - "ERR187 - Variable or function detected, yet symbol-table is invalid, Symbol: " + current_token().value)); + "ERR189 - Variable or function detected, yet symbol-table is invalid, Symbol: " + current_token().value, + exprtk_error_location)); return error_node(); } @@ -24855,6 +25286,18 @@ if (details::string_to_real(current_token().value, numeric_value)) { expression_node_ptr literal_exp = expression_generator_(numeric_value); + + if (0 == literal_exp) + { + set_error( + make_error(parser_error::e_numeric, + current_token(), + "ERR190 - Failed generate node for scalar: '" + current_token().value + "'", + exprtk_error_location)); + + return error_node(); + } + next_token(); branch = literal_exp; } @@ -24863,7 +25306,8 @@ set_error( make_error(parser_error::e_numeric, current_token(), - "ERR188 - Failed to convert '" + current_token().value + "' to a number")); + "ERR191 - Failed to convert '" + current_token().value + "' to a number", + exprtk_error_location)); return error_node(); } @@ -24889,7 +25333,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR189 - Expected ')' instead of: '" + current_token().value + "'")); + "ERR192 - Expected ')' instead of: '" + current_token().value + "'", + exprtk_error_location)); free_node(node_allocator_,branch); @@ -24913,7 +25358,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR190 - Expected ']' instead of: '" + current_token().value + "'")); + "ERR193 - Expected ']' instead of: '" + current_token().value + "'", + exprtk_error_location)); free_node(node_allocator_,branch); @@ -24937,7 +25383,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR191 - Expected '}' instead of: '" + current_token().value + "'")); + "ERR194 - Expected '}' instead of: '" + current_token().value + "'", + exprtk_error_location)); free_node(node_allocator_,branch); @@ -24976,7 +25423,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR192 - Premature end of expression[1]")); + "ERR195 - Premature end of expression[1]", + exprtk_error_location)); return error_node(); } @@ -24985,7 +25433,8 @@ set_error( make_error(parser_error::e_syntax, current_token(), - "ERR193 - Premature end of expression[2]")); + "ERR196 - Premature end of expression[2]", + exprtk_error_location)); return error_node(); } @@ -25163,28 +25612,28 @@ return (*inv_binary_op_map_).find(bop)->second; } - inline expression_node_ptr operator()(const Type& v) const + inline expression_node_ptr operator() (const Type& v) const { return node_allocator_->allocate<literal_node_t>(v); } #ifndef exprtk_disable_string_capabilities - inline expression_node_ptr operator()(const std::string& s) const + inline expression_node_ptr operator() (const std::string& s) const { return node_allocator_->allocate<string_literal_node_t>(s); } - inline expression_node_ptr operator()(std::string& s, range_t& rp) const + inline expression_node_ptr operator() (std::string& s, range_t& rp) const { return node_allocator_->allocate_rr<string_range_node_t>(s,rp); } - inline expression_node_ptr operator()(const std::string& s, range_t& rp) const + inline expression_node_ptr operator() (const std::string& s, range_t& rp) const { return node_allocator_->allocate_tt<const_string_range_node_t>(s,rp); } - inline expression_node_ptr operator()(expression_node_ptr branch, range_t& rp) const + inline expression_node_ptr operator() (expression_node_ptr branch, range_t& rp) const { if (is_generally_string_node(branch)) return node_allocator_->allocate_tt<generic_string_range_node_t>(branch,rp); @@ -25265,22 +25714,36 @@ return true; } - inline expression_node_ptr operator()(const details::operator_type& operation, expression_node_ptr (&branch)[1]) + inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr (&branch)[1]) { if (0 == branch[0]) + { return error_node(); + } else if (details::is_null_node(branch[0])) + { return branch[0]; + } else if (details::is_break_node(branch[0])) + { return error_node(); + } else if (details::is_continue_node(branch[0])) + { return error_node(); + } else if (details::is_constant_node(branch[0])) + { return synthesize_expression<unary_node_t,1>(operation,branch); + } else if (unary_optimisable(operation) && details::is_variable_node(branch[0])) + { return synthesize_uv_expression(operation,branch); + } else if (unary_optimisable(operation) && details::is_ivector_node(branch[0])) + { return synthesize_uvec_expression(operation,branch); + } else return synthesize_unary_expression(operation,branch); } @@ -25325,24 +25788,24 @@ { switch (operation) { - case details::e_add : return "+"; - case details::e_sub : return "-"; - case details::e_mul : return "*"; - case details::e_div : return "/"; - case details::e_mod : return "%"; - case details::e_pow : return "^"; - case details::e_lt : return "<"; - case details::e_lte : return "<="; - case details::e_gt : return ">"; - case details::e_gte : return ">="; - case details::e_eq : return "=="; - case details::e_ne : return "!="; - case details::e_and : return "and"; - case details::e_nand : return "nand"; - case details::e_or : return "or"; - case details::e_nor : return "nor"; - case details::e_xor : return "xor"; - case details::e_xnor : return "xnor"; + case details::e_add : return "+" ; + case details::e_sub : return "-" ; + case details::e_mul : return "*" ; + case details::e_div : return "/" ; + case details::e_mod : return "%" ; + case details::e_pow : return "^" ; + case details::e_lt : return "<" ; + case details::e_lte : return "<=" ; + case details::e_gt : return ">" ; + case details::e_gte : return ">=" ; + case details::e_eq : return "==" ; + case details::e_ne : return "!=" ; + case details::e_and : return "and" ; + case details::e_nand : return "nand" ; + case details::e_or : return "or" ; + case details::e_nor : return "nor" ; + case details::e_xor : return "xor" ; + case details::e_xnor : return "xnor" ; default : return "UNKNOWN"; } } @@ -25693,42 +26156,70 @@ ); } - inline expression_node_ptr operator()(const details::operator_type& operation, expression_node_ptr (&branch)[2]) + inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr (&branch)[2]) { if ((0 == branch[0]) || (0 == branch[1])) + { return error_node(); + } else if (is_invalid_string_op(operation,branch)) + { return error_node(); + } else if (is_invalid_assignment_op(operation,branch)) + { return error_node(); + } else if (is_invalid_break_continue_op(branch)) + { return error_node(); + } else if (details::e_assign == operation) - return synthesize_assignment_expression(operation,branch); + { + return synthesize_assignment_expression(operation, branch); + } else if (details::e_swap == operation) + { return synthesize_swap_expression(branch); + } else if (is_assignment_operation(operation)) - return synthesize_assignment_operation_expression(operation,branch); - else if (is_vector_eqineq_logic_operation(operation,branch)) - return synthesize_veceqineqlogic_operation_expression(operation,branch); - else if (is_vector_arithmetic_operation(operation,branch)) - return synthesize_vecarithmetic_operation_expression(operation,branch); + { + return synthesize_assignment_operation_expression(operation, branch); + } + else if (is_vector_eqineq_logic_operation(operation, branch)) + { + return synthesize_veceqineqlogic_operation_expression(operation, branch); + } + else if (is_vector_arithmetic_operation(operation, branch)) + { + return synthesize_vecarithmetic_operation_expression(operation, branch); + } else if (is_shortcircuit_expression(operation)) - return synthesize_shortcircuit_expression(operation,branch); - else if (is_string_operation(operation,branch)) - return synthesize_string_expression(operation,branch); + { + return synthesize_shortcircuit_expression(operation, branch); + } + else if (is_string_operation(operation, branch)) + { + return synthesize_string_expression(operation, branch); + } else if (is_null_present(branch)) + { return synthesize_null_expression(operation, branch); + } #ifndef exprtk_disable_cardinal_pow_optimisation else if (is_constpow_operation(operation, branch)) + { return cardinal_pow_optimisation(branch); + } #endif expression_node_ptr result = error_node(); #ifndef exprtk_disable_enhanced_features - if (synthesize_expression(operation,branch,result)) + if (synthesize_expression(operation, branch, result)) + { return result; + } else #endif @@ -25742,36 +26233,54 @@ */ result = error_node(); - if (cocob_optimisable(operation,branch)) - result = synthesize_cocob_expression::process(*this,operation,branch); - else if (coboc_optimisable(operation,branch) && (0 == result)) - result = synthesize_coboc_expression::process(*this,operation,branch); + if (cocob_optimisable(operation, branch)) + { + result = synthesize_cocob_expression::process((*this), operation, branch); + } + else if (coboc_optimisable(operation, branch) && (0 == result)) + { + result = synthesize_coboc_expression::process((*this), operation, branch); + } if (result) return result; } - if (uvouv_optimisable(operation,branch)) - return synthesize_uvouv_expression(operation,branch); - else if (vob_optimisable(operation,branch)) - return synthesize_vob_expression::process(*this,operation,branch); - else if (bov_optimisable(operation,branch)) - return synthesize_bov_expression::process(*this,operation,branch); - else if (cob_optimisable(operation,branch)) - return synthesize_cob_expression::process(*this,operation,branch); - else if (boc_optimisable(operation,branch)) - return synthesize_boc_expression::process(*this,operation,branch); + if (uvouv_optimisable(operation, branch)) + { + return synthesize_uvouv_expression(operation, branch); + } + else if (vob_optimisable(operation, branch)) + { + return synthesize_vob_expression::process((*this), operation, branch); + } + else if (bov_optimisable(operation, branch)) + { + return synthesize_bov_expression::process((*this), operation, branch); + } + else if (cob_optimisable(operation, branch)) + { + return synthesize_cob_expression::process((*this), operation, branch); + } + else if (boc_optimisable(operation, branch)) + { + return synthesize_boc_expression::process((*this), operation, branch); + } #ifndef exprtk_disable_enhanced_features - else if (cov_optimisable(operation,branch)) - return synthesize_cov_expression::process(*this,operation,branch); + else if (cov_optimisable(operation, branch)) + { + return synthesize_cov_expression::process((*this), operation, branch); + } #endif - else if (binext_optimisable(operation,branch)) - return synthesize_binary_ext_expression::process(*this,operation,branch); + else if (binext_optimisable(operation, branch)) + { + return synthesize_binary_ext_expression::process((*this), operation, branch); + } else - return synthesize_expression<binary_node_t,2>(operation,branch); + return synthesize_expression<binary_node_t,2>(operation, branch); } - inline expression_node_ptr operator()(const details::operator_type& operation, expression_node_ptr (&branch)[3]) + inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr (&branch)[3]) { if ( (0 == branch[0]) || @@ -25783,26 +26292,30 @@ return error_node(); } - else if (is_invalid_string_op(operation,branch)) + else if (is_invalid_string_op(operation, branch)) + { return error_node(); - else if (is_string_operation(operation,branch)) - return synthesize_string_expression(operation,branch); + } + else if (is_string_operation(operation, branch)) + { + return synthesize_string_expression(operation, branch); + } else - return synthesize_expression<trinary_node_t,3>(operation,branch); + return synthesize_expression<trinary_node_t,3>(operation, branch); } - inline expression_node_ptr operator()(const details::operator_type& operation, expression_node_ptr (&branch)[4]) + inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr (&branch)[4]) { return synthesize_expression<quaternary_node_t,4>(operation,branch); } - inline expression_node_ptr operator()(const details::operator_type& operation, expression_node_ptr b0) + inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr b0) { expression_node_ptr branch[1] = { b0 }; 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(); @@ -26119,6 +26632,7 @@ static inline T process(const arg_list_t& arg) { case_stmt(0) + return arg.back()->value(); } }; @@ -26128,6 +26642,7 @@ static inline T process(const arg_list_t& arg) { case_stmt(0) case_stmt(1) + return arg.back()->value(); } }; @@ -26138,6 +26653,7 @@ { case_stmt(0) case_stmt(1) case_stmt(2) + return arg.back()->value(); } }; @@ -26148,6 +26664,7 @@ { case_stmt(0) case_stmt(1) case_stmt(2) case_stmt(3) + return arg.back()->value(); } }; @@ -26159,6 +26676,7 @@ case_stmt(0) case_stmt(1) case_stmt(2) case_stmt(3) case_stmt(4) + return arg.back()->value(); } }; @@ -26170,6 +26688,7 @@ case_stmt(0) case_stmt(1) case_stmt(2) case_stmt(3) case_stmt(4) case_stmt(5) + return arg.back()->value(); } }; @@ -26182,6 +26701,7 @@ case_stmt(2) case_stmt(3) case_stmt(4) case_stmt(5) case_stmt(6) + return arg.back()->value(); } }; @@ -26364,7 +26884,7 @@ default : return error_node(); } - T v = temp_node->value(); + const T v = temp_node->value(); details::free_node(*node_allocator_,temp_node); @@ -26467,7 +26987,8 @@ default : return error_node(); } - T v = temp_node->value(); + const T v = temp_node->value(); + details::free_node(*node_allocator_,temp_node); return node_allocator_->allocate<literal_node_t>(v); @@ -26566,7 +27087,8 @@ default : return error_node(); } - T v = temp_node->value(); + const T v = temp_node->value(); + details::free_node(*node_allocator_,temp_node); return node_allocator_->allocate<literal_node_t>(v); @@ -26740,7 +27262,7 @@ is_constant_foldable(arg_list) ) { - Type v = result->value(); + const Type v = result->value(); details::free_node(*node_allocator_,result); result = node_allocator_->allocate<literal_node_t>(v); } @@ -26782,13 +27304,17 @@ ) { genfunc_node_ptr->init_branches(); - Type v = result->value(); + + const Type v = result->value(); + details::free_node(*node_allocator_,result); + return node_allocator_->allocate<literal_node_t>(v); } else if (genfunc_node_ptr->init_branches()) { parser_->state_.activate_side_effect("generic_function_call()"); + return result; } else @@ -26833,7 +27359,7 @@ { strfunc_node_ptr->init_branches(); - Type v = result->value(); + const Type v = result->value(); details::free_node(*node_allocator_,result); @@ -26847,7 +27373,7 @@ } else { - details::free_node(*node_allocator_,result); + details::free_node (*node_allocator_,result ); details::free_all_nodes(*node_allocator_,arg_list); return error_node(); @@ -26879,7 +27405,7 @@ } else { - details::free_node(*node_allocator_,result); + details::free_node (*node_allocator_,result ); details::free_all_nodes(*node_allocator_,arg_list); return error_node(); @@ -27085,13 +27611,13 @@ { lodge_assignment(e_st_string,branch[0]); - return synthesize_expression<assignment_string_node_t,2>(operation,branch); + return synthesize_expression<assignment_string_node_t,2>(operation, branch); } else if (details::is_string_range_node(branch[0])) { lodge_assignment(e_st_string,branch[0]); - return synthesize_expression<assignment_string_range_node_t,2>(operation,branch); + return synthesize_expression<assignment_string_range_node_t,2>(operation, branch); } #endif else if (details::is_vector_node(branch[0])) @@ -27099,9 +27625,9 @@ lodge_assignment(e_st_vector,branch[0]); if (details::is_ivector_node(branch[1])) - return synthesize_expression<assignment_vecvec_node_t,2>(operation,branch); + return synthesize_expression<assignment_vecvec_node_t,2>(operation, branch); else - return synthesize_expression<assignment_vec_node_t,2>(operation,branch); + return synthesize_expression<assignment_vec_node_t,2>(operation, branch); } else { @@ -27387,8 +27913,8 @@ const bool v0_is_ivar = details::is_ivariable_node(branch[0]); const bool v1_is_ivar = details::is_ivariable_node(branch[1]); - const bool v0_is_ivec = details::is_ivector_node(branch[0]); - const bool v1_is_ivec = details::is_ivector_node(branch[1]); + const bool v0_is_ivec = details::is_ivector_node (branch[0]); + const bool v1_is_ivec = details::is_ivector_node (branch[1]); #ifndef exprtk_disable_string_capabilities const bool v0_is_str = details::is_generally_string_node(branch[0]); @@ -27482,9 +28008,13 @@ return result; } else if (details::e_scand == operation) - return synthesize_expression<scand_node_t,2>(operation,branch); + { + return synthesize_expression<scand_node_t,2>(operation, branch); + } else if (details::e_scor == operation) - return synthesize_expression<scor_node_t,2>(operation,branch); + { + return synthesize_expression<scor_node_t,2>(operation, branch); + } else return error_node(); } @@ -27749,7 +28279,7 @@ #define case_stmt(op0,op1) \ case op0 : return expr_gen.node_allocator_-> \ template allocate<typename details::binary_ext_node<Type,op1<Type> > > \ - (branch[0],branch[1]); \ + (branch[0], branch[1]); \ basic_opr_switch_statements extended_opr_switch_statements @@ -27908,7 +28438,7 @@ #define case_stmt(op0,op1) \ case op0 : return expr_gen.node_allocator_-> \ template allocate_cr<typename details::bov_node<Type,op1<Type> > > \ - (branch[0],v); \ + (branch[0], v); \ basic_opr_switch_statements extended_opr_switch_statements @@ -28042,7 +28572,7 @@ #define case_stmt(op0,op1) \ case op0 : return expr_gen.node_allocator_-> \ template allocate_tt<typename details::cob_node<Type,op1<Type> > > \ - (c, branch[1]); \ + (c, branch[1]); \ basic_opr_switch_statements extended_opr_switch_statements @@ -28106,7 +28636,7 @@ else if (operation == details::e_div) { details::boc_base_node<Type>* bocnode = static_cast<details::boc_base_node<Type>*>(branch[0]); - details::operator_type boc_opr = bocnode->operation(); + details::operator_type boc_opr = bocnode->operation(); if ( (details::e_div == boc_opr) || @@ -28127,7 +28657,7 @@ { // (v ^ c0) ^ c1 --> v ^(c0 * c1) details::boc_base_node<Type>* bocnode = static_cast<details::boc_base_node<Type>*>(branch[0]); - details::operator_type boc_opr = bocnode->operation(); + details::operator_type boc_opr = bocnode->operation(); if (details::e_pow == boc_opr) { @@ -28202,16 +28732,19 @@ else if (std::equal_to<T>()(T(0),c) && (details::e_add == operation)) { free_node(*expr_gen.node_allocator_, branch[1]); + return branch[0]; } else if (std::equal_to<T>()(T(1),c) && (details::e_mul == operation)) { free_node(*expr_gen.node_allocator_, branch[1]); + return branch[0]; } else if (std::equal_to<T>()(T(1),c) && (details::e_div == operation)) { free_node(*expr_gen.node_allocator_, branch[1]); + return branch[0]; } @@ -28253,7 +28786,7 @@ template allocate_tt<typename details::cob_node<Type,details::div_op<Type> > > (cobnode->c() / c, cobnode->move_branch(0)); - free_node(*expr_gen.node_allocator_,branch[0]); + free_node(*expr_gen.node_allocator_, branch[0]); } } @@ -28267,6 +28800,7 @@ else if (details::is_cob_node(branch[1])) { details::cob_base_node<Type>* cobnode = static_cast<details::cob_base_node<Type>*>(branch[1]); + const Type c = static_cast<details::literal_node<Type>*>(branch[0])->value(); if (std::equal_to<T>()(T(0),c) && (details::e_mul == operation)) @@ -28286,11 +28820,13 @@ else if (std::equal_to<T>()(T(0),c) && (details::e_add == operation)) { free_node(*expr_gen.node_allocator_, branch[0]); + return branch[1]; } else if (std::equal_to<T>()(T(1),c) && (details::e_mul == operation)) { free_node(*expr_gen.node_allocator_, branch[0]); + return branch[1]; } @@ -28444,6 +28980,7 @@ else if (details::is_boc_node(branch[1])) { details::boc_base_node<Type>* bocnode = static_cast<details::boc_base_node<Type>*>(branch[1]); + const Type c = static_cast<details::literal_node<Type>*>(branch[0])->value(); if (details::e_add == bocnode->operation()) @@ -28536,11 +29073,11 @@ const std::string node_id = branch_to_id(branch); - typename synthesize_map_t::iterator itr = synthesize_map_.find(node_id); + const typename synthesize_map_t::iterator itr = synthesize_map_.find(node_id); if (synthesize_map_.end() != itr) { - result = itr->second(*this, operation, branch); + result = itr->second((*this), operation, branch); return true; } @@ -28579,7 +29116,7 @@ expression_node_ptr (&branch)[2]) { const Type c = static_cast<details::literal_node<Type>*> (branch[0])->value(); - const Type& v = static_cast<details::variable_node<Type>*>(branch[1])->ref(); + const Type& v = static_cast<details::variable_node<Type>*>(branch[1])->ref (); details::free_node(*(expr_gen.node_allocator_),branch[0]); @@ -28613,7 +29150,7 @@ const details::operator_type& operation, expression_node_ptr (&branch)[2]) { - const Type& v = static_cast<details::variable_node<Type>*>(branch[0])->ref(); + const Type& v = static_cast<details::variable_node<Type>*>(branch[0])->ref (); const Type c = static_cast<details::literal_node<Type>*> (branch[1])->value(); details::free_node(*(expr_gen.node_allocator_), branch[1]); @@ -28662,7 +29199,7 @@ { #define case_stmt(op) \ case details::e_sf##op : return details::T0oT1oT2_sf3ext<T,T0,T1,T2,details::sf##op##_op<Type> >:: \ - allocate(*(expr_gen.node_allocator_),t0,t1,t2); \ + allocate(*(expr_gen.node_allocator_), t0, t1, t2); \ case_stmt(00) case_stmt(01) case_stmt(02) case_stmt(03) case_stmt(04) case_stmt(05) case_stmt(06) case_stmt(07) @@ -29404,7 +29941,7 @@ exprtk_debug(("(c0 + v) + c1 --> (cov) (c0 + c1) + v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1,v); + template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1, v); } // (c0 + v) - c1 --> (cov) (c0 - c1) + v else if ((details::e_add == o0) && (details::e_sub == o1)) @@ -29412,7 +29949,7 @@ exprtk_debug(("(c0 + v) - c1 --> (cov) (c0 - c1) + v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1,v); + template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1, v); } // (c0 - v) + c1 --> (cov) (c0 + c1) - v else if ((details::e_sub == o0) && (details::e_add == o1)) @@ -29420,7 +29957,7 @@ exprtk_debug(("(c0 - v) + c1 --> (cov) (c0 + c1) - v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1,v); + template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1, v); } // (c0 - v) - c1 --> (cov) (c0 - c1) - v else if ((details::e_sub == o0) && (details::e_sub == o1)) @@ -29428,7 +29965,7 @@ exprtk_debug(("(c0 - v) - c1 --> (cov) (c0 - c1) - v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1,v); + template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1, v); } // (c0 * v) * c1 --> (cov) (c0 * c1) * v else if ((details::e_mul == o0) && (details::e_mul == o1)) @@ -29436,7 +29973,7 @@ exprtk_debug(("(c0 * v) * c1 --> (cov) (c0 * c1) * v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1,v); + template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1, v); } // (c0 * v) / c1 --> (cov) (c0 / c1) * v else if ((details::e_mul == o0) && (details::e_div == o1)) @@ -29444,7 +29981,7 @@ exprtk_debug(("(c0 * v) / c1 --> (cov) (c0 / c1) * v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1,v); + template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1, v); } // (c0 / v) * c1 --> (cov) (c0 * c1) / v else if ((details::e_div == o0) && (details::e_mul == o1)) @@ -29452,7 +29989,7 @@ exprtk_debug(("(c0 / v) * c1 --> (cov) (c0 * c1) / v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1,v); + template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1, v); } // (c0 / v) / c1 --> (cov) (c0 / c1) / v else if ((details::e_div == o0) && (details::e_div == o1)) @@ -29460,7 +29997,7 @@ exprtk_debug(("(c0 / v) / c1 --> (cov) (c0 / c1) / v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1,v); + template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1, v); } } @@ -29518,7 +30055,7 @@ exprtk_debug(("(c0) + (v + c1) --> (cov) (c0 + c1) + v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1,v); + template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1, v); } // (c0) + (v - c1) --> (cov) (c0 - c1) + v else if ((details::e_add == o0) && (details::e_sub == o1)) @@ -29526,7 +30063,7 @@ exprtk_debug(("(c0) + (v - c1) --> (cov) (c0 - c1) + v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1,v); + template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1, v); } // (c0) - (v + c1) --> (cov) (c0 - c1) - v else if ((details::e_sub == o0) && (details::e_add == o1)) @@ -29534,7 +30071,7 @@ exprtk_debug(("(c0) - (v + c1) --> (cov) (c0 - c1) - v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1,v); + template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1, v); } // (c0) - (v - c1) --> (cov) (c0 + c1) - v else if ((details::e_sub == o0) && (details::e_sub == o1)) @@ -29542,7 +30079,7 @@ exprtk_debug(("(c0) - (v - c1) --> (cov) (c0 + c1) - v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1,v); + template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1, v); } // (c0) * (v * c1) --> (voc) v * (c0 * c1) else if ((details::e_mul == o0) && (details::e_mul == o1)) @@ -29550,7 +30087,7 @@ exprtk_debug(("(c0) * (v * c1) --> (voc) v * (c0 * c1)\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1,v); + template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1, v); } // (c0) * (v / c1) --> (cov) (c0 / c1) * v else if ((details::e_mul == o0) && (details::e_div == o1)) @@ -29558,7 +30095,7 @@ exprtk_debug(("(c0) * (v / c1) --> (cov) (c0 / c1) * v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1,v); + template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1, v); } // (c0) / (v * c1) --> (cov) (c0 / c1) / v else if ((details::e_div == o0) && (details::e_mul == o1)) @@ -29566,7 +30103,7 @@ exprtk_debug(("(c0) / (v * c1) --> (cov) (c0 / c1) / v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1,v); + template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1, v); } // (c0) / (v / c1) --> (cov) (c0 * c1) / v else if ((details::e_div == o0) && (details::e_div == o1)) @@ -29574,7 +30111,7 @@ exprtk_debug(("(c0) / (v / c1) --> (cov) (c0 * c1) / v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1,v); + template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1, v); } } @@ -29642,7 +30179,7 @@ exprtk_debug(("(c0) + (c1 + v) --> (cov) (c0 + c1) + v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1,v); + template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 + c1, v); } // (c0) + (c1 - v) --> (cov) (c0 + c1) - v else if ((details::e_add == o0) && (details::e_sub == o1)) @@ -29650,7 +30187,7 @@ exprtk_debug(("(c0) + (c1 - v) --> (cov) (c0 + c1) - v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1,v); + template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 + c1, v); } // (c0) - (c1 + v) --> (cov) (c0 - c1) - v else if ((details::e_sub == o0) && (details::e_add == o1)) @@ -29658,7 +30195,7 @@ exprtk_debug(("(c0) - (c1 + v) --> (cov) (c0 - c1) - v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1,v); + template allocate_cr<typename details::cov_node<Type,details::sub_op<Type> > >(c0 - c1, v); } // (c0) - (c1 - v) --> (cov) (c0 - c1) + v else if ((details::e_sub == o0) && (details::e_sub == o1)) @@ -29666,7 +30203,7 @@ exprtk_debug(("(c0) - (c1 - v) --> (cov) (c0 - c1) + v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1,v); + template allocate_cr<typename details::cov_node<Type,details::add_op<Type> > >(c0 - c1, v); } // (c0) * (c1 * v) --> (cov) (c0 * c1) * v else if ((details::e_mul == o0) && (details::e_mul == o1)) @@ -29674,7 +30211,7 @@ exprtk_debug(("(c0) * (c1 * v) --> (cov) (c0 * c1) * v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1,v); + template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 * c1, v); } // (c0) * (c1 / v) --> (cov) (c0 * c1) / v else if ((details::e_mul == o0) && (details::e_div == o1)) @@ -29682,7 +30219,7 @@ exprtk_debug(("(c0) * (c1 / v) --> (cov) (c0 * c1) / v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1,v); + template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 * c1, v); } // (c0) / (c1 * v) --> (cov) (c0 / c1) / v else if ((details::e_div == o0) && (details::e_mul == o1)) @@ -29690,7 +30227,7 @@ exprtk_debug(("(c0) / (c1 * v) --> (cov) (c0 / c1) / v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1,v); + template allocate_cr<typename details::cov_node<Type,details::div_op<Type> > >(c0 / c1, v); } // (c0) / (c1 / v) --> (cov) (c0 / c1) * v else if ((details::e_div == o0) && (details::e_div == o1)) @@ -29698,7 +30235,7 @@ exprtk_debug(("(c0) / (c1 / v) --> (cov) (c0 / c1) * v\n")); return expr_gen.node_allocator_-> - template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1,v); + template allocate_cr<typename details::cov_node<Type,details::mul_op<Type> > >(c0 / c1, v); } } @@ -29755,7 +30292,7 @@ exprtk_debug(("(v + c0) + c1 --> (voc) v + (c0 + c1)\n")); return expr_gen.node_allocator_-> - template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(v,c0 + c1); + template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(v, c0 + c1); } // (v + c0) - c1 --> (voc) v + (c0 - c1) else if ((details::e_add == o0) && (details::e_sub == o1)) @@ -29763,7 +30300,7 @@ exprtk_debug(("(v + c0) - c1 --> (voc) v + (c0 - c1)\n")); return expr_gen.node_allocator_-> - template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(v,c0 - c1); + template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(v, c0 - c1); } // (v - c0) + c1 --> (voc) v - (c0 + c1) else if ((details::e_sub == o0) && (details::e_add == o1)) @@ -29771,7 +30308,7 @@ exprtk_debug(("(v - c0) + c1 --> (voc) v - (c0 + c1)\n")); return expr_gen.node_allocator_-> - template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(v,c1 - c0); + template allocate_rc<typename details::voc_node<Type,details::add_op<Type> > >(v, c1 - c0); } // (v - c0) - c1 --> (voc) v - (c0 + c1) else if ((details::e_sub == o0) && (details::e_sub == o1)) @@ -29779,7 +30316,7 @@ exprtk_debug(("(v - c0) - c1 --> (voc) v - (c0 + c1)\n")); return expr_gen.node_allocator_-> - template allocate_rc<typename details::voc_node<Type,details::sub_op<Type> > >(v,c0 + c1); + template allocate_rc<typename details::voc_node<Type,details::sub_op<Type> > >(v, c0 + c1); } // (v * c0) * c1 --> (voc) v * (c0 * c1) else if ((details::e_mul == o0) && (details::e_mul == o1)) @@ -29787,7 +30324,7 @@ exprtk_debug(("(v * c0) * c1 --> (voc) v * (c0 * c1)\n")); return expr_gen.node_allocator_-> - template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(v,c0 * c1); + template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(v, c0 * c1); } // (v * c0) / c1 --> (voc) v * (c0 / c1) else if ((details::e_mul == o0) && (details::e_div == o1)) @@ -29795,7 +30332,7 @@ exprtk_debug(("(v * c0) / c1 --> (voc) v * (c0 / c1)\n")); return expr_gen.node_allocator_-> - template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(v,c0 / c1); + template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(v, c0 / c1); } // (v / c0) * c1 --> (voc) v * (c1 / c0) else if ((details::e_div == o0) && (details::e_mul == o1)) @@ -29803,7 +30340,7 @@ exprtk_debug(("(v / c0) * c1 --> (voc) v * (c1 / c0)\n")); return expr_gen.node_allocator_-> - template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(v,c1 / c0); + template allocate_rc<typename details::voc_node<Type,details::mul_op<Type> > >(v, c1 / c0); } // (v / c0) / c1 --> (voc) v / (c0 * c1) else if ((details::e_div == o0) && (details::e_div == o1)) @@ -29811,7 +30348,7 @@ exprtk_debug(("(v / c0) / c1 --> (voc) v / (c0 * c1)\n")); return expr_gen.node_allocator_-> - template allocate_rc<typename details::voc_node<Type,details::div_op<Type> > >(v,c0 * c1); + template allocate_rc<typename details::voc_node<Type,details::div_op<Type> > >(v, c0 * c1); } // (v ^ c0) ^ c1 --> (voc) v ^ (c0 * c1) else if ((details::e_pow == o0) && (details::e_pow == o1)) @@ -29819,7 +30356,7 @@ exprtk_debug(("(v ^ c0) ^ c1 --> (voc) v ^ (c0 * c1)\n")); return expr_gen.node_allocator_-> - template allocate_rc<typename details::voc_node<Type,details::pow_op<Type> > >(v,c0 * c1); + template allocate_rc<typename details::voc_node<Type,details::pow_op<Type> > >(v, c0 * c1); } } @@ -33090,28 +33627,28 @@ case details::e_add : result = (*this)(details::e_neg, node_allocator_-> allocate_rr<typename details:: - vov_node<Type,details::add_op<Type> > >(v0,v1)); + vov_node<Type,details::add_op<Type> > >(v0, v1)); exprtk_debug(("(-v0 + -v1) --> -(v0 + v1)\n")); break; // (-v0 - -v1) --> (v1 - v0) case details::e_sub : result = node_allocator_-> allocate_rr<typename details:: - vov_node<Type,details::sub_op<Type> > >(v1,v0); + vov_node<Type,details::sub_op<Type> > >(v1, v0); exprtk_debug(("(-v0 - -v1) --> (v1 - v0)\n")); break; // (-v0 * -v1) --> (v0 * v1) case details::e_mul : result = node_allocator_-> allocate_rr<typename details:: - vov_node<Type,details::mul_op<Type> > >(v0,v1); + vov_node<Type,details::mul_op<Type> > >(v0, v1); exprtk_debug(("(-v0 * -v1) --> (v0 * v1)\n")); break; // (-v0 / -v1) --> (v0 / v1) case details::e_div : result = node_allocator_-> allocate_rr<typename details:: - vov_node<Type,details::div_op<Type> > >(v0,v1); + vov_node<Type,details::div_op<Type> > >(v0, v1); exprtk_debug(("(-v0 / -v1) --> (v0 / v1)\n")); break; @@ -33122,7 +33659,7 @@ if (0 == result) { result = node_allocator_-> - allocate_rrrrr<typename details::uvouv_node<Type> >(v0,v1,u0,u1,f); + allocate_rrrrr<typename details::uvouv_node<Type> >(v0, v1, u0, u1, f); } details::free_all_nodes(*node_allocator_,branch); @@ -33156,7 +33693,7 @@ #define case_stmt(op0,op1) \ case op0 : return node_allocator_-> \ allocate_ttt<typename details::str_xrox_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \ - (s0,s1,rp0); \ + (s0, s1, rp0); \ string_opr_switch_statements #undef case_stmt @@ -33174,7 +33711,7 @@ #define case_stmt(op0,op1) \ case op0 : return node_allocator_-> \ allocate_ttt<typename details::str_xoxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \ - (s0,s1,rp1); \ + (s0, s1, rp1); \ string_opr_switch_statements #undef case_stmt @@ -33192,7 +33729,7 @@ #define case_stmt(op0,op1) \ case op0 : return node_allocator_-> \ allocate_tttt<typename details::str_xroxr_node<Type,T0,T1,range_t,op1<Type> >,T0,T1> \ - (s0,s1,rp0,rp1); \ + (s0, s1, rp0, rp1); \ string_opr_switch_statements #undef case_stmt @@ -33205,9 +33742,9 @@ { switch (opr) { - #define case_stmt(op0,op1) \ - case op0 : return node_allocator_-> \ - allocate_tt<typename details::sos_node<Type,T0,T1,op1<Type> >,T0,T1>(s0,s1); \ + #define case_stmt(op0,op1) \ + case op0 : return node_allocator_-> \ + allocate_tt<typename details::sos_node<Type,T0,T1,op1<Type> >,T0,T1>(s0, s1); \ string_opr_switch_statements #undef case_stmt @@ -33220,7 +33757,7 @@ std::string& s0 = static_cast<details::stringvar_node<Type>*>(branch[0])->ref(); std::string& s1 = static_cast<details::stringvar_node<Type>*>(branch[1])->ref(); - return synthesize_sos_expression_impl<std::string&,std::string&>(opr,s0,s1); + return synthesize_sos_expression_impl<std::string&,std::string&>(opr, s0, s1); } inline expression_node_ptr synthesize_sros_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33233,7 +33770,7 @@ free_node(*node_allocator_,branch[0]); - return synthesize_str_xrox_expression_impl<std::string&,std::string&>(opr,s0,s1,rp0); + return synthesize_str_xrox_expression_impl<std::string&,std::string&>(opr, s0, s1, rp0); } inline expression_node_ptr synthesize_sosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33246,7 +33783,7 @@ free_node(*node_allocator_,branch[1]); - return synthesize_str_xoxr_expression_impl<std::string&,std::string&>(opr,s0,s1,rp1); + return synthesize_str_xoxr_expression_impl<std::string&,std::string&>(opr, s0, s1, rp1); } inline expression_node_ptr synthesize_socsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33259,7 +33796,7 @@ free_node(*node_allocator_,branch[1]); - return synthesize_str_xoxr_expression_impl<std::string&, const std::string>(opr,s0,s1,rp1); + return synthesize_str_xoxr_expression_impl<std::string&, const std::string>(opr, s0, s1, rp1); } inline expression_node_ptr synthesize_srosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33275,7 +33812,7 @@ details::free_node(*node_allocator_,branch[0]); details::free_node(*node_allocator_,branch[1]); - return synthesize_str_xroxr_expression_impl<std::string&,std::string&>(opr,s0,s1,rp0,rp1); + return synthesize_str_xroxr_expression_impl<std::string&,std::string&>(opr, s0, s1, rp0, rp1); } inline expression_node_ptr synthesize_socs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33285,7 +33822,7 @@ details::free_node(*node_allocator_,branch[1]); - return synthesize_sos_expression_impl<std::string&, const std::string>(opr,s0,s1); + return synthesize_sos_expression_impl<std::string&, const std::string>(opr, s0, s1); } inline expression_node_ptr synthesize_csos_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33295,7 +33832,7 @@ details::free_node(*node_allocator_,branch[0]); - return synthesize_sos_expression_impl<const std::string,std::string&>(opr,s0,s1); + return synthesize_sos_expression_impl<const std::string,std::string&>(opr, s0, s1); } inline expression_node_ptr synthesize_csosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33309,7 +33846,7 @@ details::free_node(*node_allocator_,branch[0]); details::free_node(*node_allocator_,branch[1]); - return synthesize_str_xoxr_expression_impl<const std::string,std::string&>(opr,s0,s1,rp1); + return synthesize_str_xoxr_expression_impl<const std::string,std::string&>(opr, s0, s1, rp1); } inline expression_node_ptr synthesize_srocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33323,7 +33860,7 @@ details::free_node(*node_allocator_,branch[0]); details::free_node(*node_allocator_,branch[1]); - return synthesize_str_xrox_expression_impl<std::string&, const std::string>(opr,s0,s1,rp0); + return synthesize_str_xrox_expression_impl<std::string&, const std::string>(opr, s0, s1, rp0); } inline expression_node_ptr synthesize_srocsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33339,7 +33876,7 @@ details::free_node(*node_allocator_,branch[0]); details::free_node(*node_allocator_,branch[1]); - return synthesize_str_xroxr_expression_impl<std::string&, const std::string>(opr,s0,s1,rp0,rp1); + return synthesize_str_xroxr_expression_impl<std::string&, const std::string>(opr, s0, s1, rp0, rp1); } inline expression_node_ptr synthesize_csocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33352,16 +33889,19 @@ if (details::e_add == opr) result = node_allocator_->allocate_c<details::string_literal_node<Type> >(s0 + s1); else if (details::e_in == opr) - result = node_allocator_->allocate_c<details::literal_node<Type> >(details::in_op<Type>::process(s0,s1)); + result = node_allocator_->allocate_c<details::literal_node<Type> >(details::in_op <Type>::process(s0,s1)); else if (details::e_like == opr) - result = node_allocator_->allocate_c<details::literal_node<Type> >(details::like_op<Type>::process(s0,s1)); + result = node_allocator_->allocate_c<details::literal_node<Type> >(details::like_op <Type>::process(s0,s1)); else if (details::e_ilike == opr) result = node_allocator_->allocate_c<details::literal_node<Type> >(details::ilike_op<Type>::process(s0,s1)); else { - expression_node_ptr temp = synthesize_sos_expression_impl<const std::string, const std::string>(opr,s0,s1); - Type v = temp->value(); + expression_node_ptr temp = synthesize_sos_expression_impl<const std::string, const std::string>(opr, s0, s1); + + const Type v = temp->value(); + details::free_node(*node_allocator_,temp); + result = node_allocator_->allocate<literal_node_t>(v); } @@ -33381,7 +33921,7 @@ free_node(*node_allocator_,branch[0]); free_node(*node_allocator_,branch[1]); - return synthesize_str_xoxr_expression_impl<const std::string, const std::string>(opr,s0,s1,rp1); + return synthesize_str_xoxr_expression_impl<const std::string, const std::string>(opr, s0, s1, rp1); } inline expression_node_ptr synthesize_csros_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33394,7 +33934,7 @@ free_node(*node_allocator_,branch[0]); - return synthesize_str_xrox_expression_impl<const std::string,std::string&>(opr,s0,s1,rp0); + return synthesize_str_xrox_expression_impl<const std::string,std::string&>(opr, s0, s1, rp0); } inline expression_node_ptr synthesize_csrosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33410,7 +33950,7 @@ free_node(*node_allocator_,branch[0]); free_node(*node_allocator_,branch[1]); - return synthesize_str_xroxr_expression_impl<const std::string,std::string&>(opr,s0,s1,rp0,rp1); + return synthesize_str_xroxr_expression_impl<const std::string,std::string&>(opr, s0, s1, rp0, rp1); } inline expression_node_ptr synthesize_csrocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33423,7 +33963,7 @@ details::free_all_nodes(*node_allocator_,branch); - return synthesize_str_xrox_expression_impl<const std::string,std::string>(opr,s0,s1,rp0); + return synthesize_str_xrox_expression_impl<const std::string,std::string>(opr, s0, s1, rp0); } inline expression_node_ptr synthesize_csrocsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33438,7 +33978,7 @@ details::free_all_nodes(*node_allocator_,branch); - return synthesize_str_xroxr_expression_impl<const std::string, const std::string>(opr,s0,s1,rp0,rp1); + return synthesize_str_xroxr_expression_impl<const std::string, const std::string>(opr, s0, s1, rp0, rp1); } inline expression_node_ptr synthesize_strogen_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2]) @@ -33448,7 +33988,7 @@ #define case_stmt(op0,op1) \ case op0 : return node_allocator_-> \ allocate_ttt<typename details::str_sogens_node<Type,op1<Type> > > \ - (opr,branch[0],branch[1]); \ + (opr, branch[0], branch[1]); \ string_opr_switch_statements #undef case_stmt @@ -33565,7 +34105,8 @@ const std::string s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str(); const std::string s2 = static_cast<details::string_literal_node<Type>*>(branch[2])->str(); - Type v = (((s0 <= s1) && (s1 <= s2)) ? Type(1) : Type(0)); + const Type v = (((s0 <= s1) && (s1 <= s2)) ? Type(1) : Type(0)); + details::free_all_nodes(*node_allocator_,branch); return node_allocator_->allocate_c<details::literal_node<Type> >(v); @@ -33763,7 +34304,11 @@ (details::e_like == operation) || (details::e_ilike == operation) ) + { + free_all_nodes(*node_allocator_,branch); + return error_node(); + } else if (!details::all_nodes_valid<N>(branch)) { free_all_nodes(*node_allocator_,branch); @@ -33828,15 +34373,15 @@ return expression_point; } - bool strength_reduction_enabled_; + bool strength_reduction_enabled_; details::node_allocator* node_allocator_; - synthesize_map_t synthesize_map_; - unary_op_map_t* unary_op_map_; - binary_op_map_t* binary_op_map_; - inv_binary_op_map_t* inv_binary_op_map_; - sf3_map_t* sf3_map_; - sf4_map_t* sf4_map_; - parser_t* parser_; + synthesize_map_t synthesize_map_; + unary_op_map_t* unary_op_map_; + binary_op_map_t* binary_op_map_; + inv_binary_op_map_t* inv_binary_op_map_; + sf3_map_t* sf3_map_; + sf4_map_t* sf4_map_; + parser_t* parser_; }; inline void set_error(const parser_error::type& error_type) @@ -33878,7 +34423,7 @@ if (se.data) { - e.register_local_data(se.data,1,0); + e.register_local_data(se.data, 1, 0); } } else if (scope_element::e_vector == se.type) @@ -33890,7 +34435,7 @@ if (se.data) { - e.register_local_data(se.data,se.size,1); + e.register_local_data(se.data, se.size, 1); } } #ifndef exprtk_disable_string_capabilities @@ -33903,7 +34448,7 @@ if (se.data) { - e.register_local_data(se.data,se.size,2); + e.register_local_data(se.data, se.size, 2); } } #endif @@ -34780,79 +35325,79 @@ #define poly_rtrn(NN) \ return (NN != N) ? std::numeric_limits<T>::quiet_NaN() : - inline virtual T operator()(const T& x, const T& c1, const T& c0) + inline virtual T operator() (const T& x, const T& c1, const T& 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) + 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); } - inline virtual T operator()(const T& x, const T& c3, const T& c2, const T& c1, const T& 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); } - inline virtual T operator()(const T& x, const T& c4, const T& c3, const T& c2, const T& c1, const T& 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); } - 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) + 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); } - 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) + 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); } - 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) + 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); } - 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) + 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); } - 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) + 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); } - 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) + 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); } - 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) + 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); } - 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) + 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); } #undef poly_rtrn - inline virtual T operator()() + inline virtual T operator() () { return std::numeric_limits<T>::quiet_NaN(); } - inline virtual T operator()(const T&) + inline virtual T operator() (const T&) { return std::numeric_limits<T>::quiet_NaN(); } - inline virtual T operator()(const T&, const T&) + inline virtual T operator() (const T&, const T&) { return std::numeric_limits<T>::quiet_NaN(); } @@ -35183,7 +35728,7 @@ func_0param() : base_func(0) {} - inline T operator()() + inline T operator() () { return this->value(base_func::expression); } @@ -35211,13 +35756,11 @@ func_1param() : base_func(1) {} - inline T operator()(type v0) + inline T operator() (type v0) { scoped_bft<func_1param> sb(*this); base_func::update(v0); - T result = this->value(base_func::expression); - - return result; + return this->value(base_func::expression); } }; @@ -35227,13 +35770,11 @@ func_2param() : base_func(2) {} - inline T operator()(type v0, type v1) + inline T operator() (type v0, type v1) { scoped_bft<func_2param> sb(*this); - base_func::update(v0,v1); - T result = this->value(base_func::expression); - - return result; + base_func::update(v0, v1); + return this->value(base_func::expression); } }; @@ -35243,13 +35784,11 @@ func_3param() : base_func(3) {} - inline T operator()(type v0, type v1, type v2) + inline T operator() (type v0, type v1, type v2) { scoped_bft<func_3param> sb(*this); - base_func::update(v0,v1,v2); - T result = this->value(base_func::expression); - - return result; + base_func::update(v0, v1, v2); + return this->value(base_func::expression); } }; @@ -35259,13 +35798,11 @@ func_4param() : base_func(4) {} - inline T operator()(type v0, type v1, type v2, type v3) + inline T operator() (type v0, type v1, type v2, type v3) { scoped_bft<func_4param> sb(*this); - base_func::update(v0,v1,v2,v3); - T result = this->value(base_func::expression); - - return result; + base_func::update(v0, v1, v2, v3); + return this->value(base_func::expression); } }; @@ -35275,13 +35812,11 @@ func_5param() : base_func(5) {} - inline T operator()(type v0, type v1, type v2, type v3, type v4) + inline T operator() (type v0, type v1, type v2, type v3, type v4) { scoped_bft<func_5param> sb(*this); - base_func::update(v0,v1,v2,v3,v4); - T result = this->value(base_func::expression); - - return result; + base_func::update(v0, v1, v2, v3, v4); + return this->value(base_func::expression); } }; @@ -35291,13 +35826,11 @@ func_6param() : base_func(6) {} - inline T operator()(type v0, type v1, type v2, type v3, type v4, type v5) + inline T operator() (type v0, type v1, type v2, type v3, type v4, type v5) { scoped_bft<func_6param> sb(*this); - base_func::update(v0,v1,v2,v3,v4,v5); - T result = this->value(base_func::expression); - - return result; + base_func::update(v0, v1, v2, v3, v4, v5); + return this->value(base_func::expression); } }; @@ -35344,9 +35877,7 @@ const Sequence<std::string,Allocator>& var_list, const bool override = false) { - const std::size_t n = var_list.size(); - - typename std::map<std::string,expression_t>::iterator itr = expr_map_.find(name); + const typename std::map<std::string,expression_t>::iterator itr = expr_map_.find(name); if (expr_map_.end() != itr) { @@ -35363,6 +35894,8 @@ if (compile_expression(name,expression,var_list)) { + const std::size_t n = var_list.size(); + fp_map_[n][name]->setup(expr_map_[name]); return true; @@ -35428,7 +35961,7 @@ inline bool add(const function& f, const bool override = false) { - return add(f.name_,f.expression_,f.v_,override); + return add(f.name_, f.expression_, f.v_,override); } private: @@ -35491,7 +36024,7 @@ { remove(name,input_var_list.size()); - return compile_expression(name,expression,input_var_list,true); + return compile_expression(name, expression, input_var_list, true); } // Make sure every return point has a scalar as its first parameter @@ -35586,14 +36119,14 @@ if (arg_count > 6) return; - typename std::map<std::string,expression_t>::iterator em_itr = expr_map_.find(name); + const typename std::map<std::string,expression_t>::iterator em_itr = expr_map_.find(name); if (expr_map_.end() != em_itr) { expr_map_.erase(em_itr); } - typename funcparam_t::iterator fp_itr = fp_map_[arg_count].find(name); + const typename funcparam_t::iterator fp_itr = fp_map_[arg_count].find(name); if (fp_map_[arg_count].end() != fp_itr) { @@ -36003,7 +36536,7 @@ exprtk::enable_zero_parameters(*this); } - inline T operator()(parameter_list_t parameters) + inline T operator() (parameter_list_t parameters) { details::print_impl<T>::process(scalar_format_,parameters); return T(0); @@ -36025,7 +36558,7 @@ exprtk::enable_zero_parameters(*this); } - inline T operator()(parameter_list_t parameters) + inline T operator() (parameter_list_t parameters) { details::print_impl<T>::process(scalar_format_,parameters); printf("\n"); @@ -36289,6 +36822,7 @@ #pragma warning(pop) #endif } + } // namespace exprtk::rtl::io::file::details template <typename T> @@ -36307,7 +36841,7 @@ : exprtk::igeneric_function<T>("S|SS") { details::perform_check<T>(); } - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { std::string file_name; std::string access; @@ -36352,7 +36886,7 @@ : exprtk::ifunction<T>(1) { details::perform_check<T>(); } - inline T operator()(const T& v) + inline T operator() (const T& v) { details::file_descriptor* fd = details::make_handle(v); @@ -36383,7 +36917,7 @@ : igfun_t("TS|TST|TV|TVT") { details::perform_check<T>(); } - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])()); @@ -36392,26 +36926,26 @@ switch (ps_index) { case 0 : { - string_t buffer(parameters[1]); + const string_t buffer(parameters[1]); amount = buffer.size(); return T(fd->write(buffer,amount) ? 1 : 0); } case 1 : { - string_t buffer(parameters[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); } case 2 : { - vector_t vec(parameters[1]); + const vector_t vec(parameters[1]); amount = vec.size(); return T(fd->write(vec,amount) ? 1 : 0); } case 3 : { - vector_t vec(parameters[1]); + 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); @@ -36440,7 +36974,7 @@ : igfun_t("TS|TST|TV|TVT") { details::perform_check<T>(); } - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])()); @@ -36496,8 +37030,8 @@ : igfun_t("T",igfun_t::e_rtrn_string) { details::perform_check<T>(); } - inline T operator()(std::string& result, - parameter_list_t parameters) + inline T operator() (std::string& result, + parameter_list_t parameters) { details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])()); return T(fd->getline(result) ? 1 : 0); @@ -36513,7 +37047,7 @@ : exprtk::ifunction<T>(1) { details::perform_check<T>(); } - inline T operator()(const T& v) + inline T operator() (const T& v) { details::file_descriptor* fd = details::make_handle(v); @@ -36646,9 +37180,9 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - const vector_t& vec(parameters[0]); + const vector_t vec(parameters[0]); std::size_t r0 = 0; std::size_t r1 = vec.size() - 1; @@ -36692,9 +37226,9 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - const vector_t& vec(parameters[0]); + const vector_t vec(parameters[0]); std::size_t r0 = 0; std::size_t r1 = vec.size() - 1; @@ -36738,9 +37272,9 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - const vector_t& vec(parameters[0]); + const vector_t vec(parameters[0]); std::size_t r0 = 0; std::size_t r1 = vec.size() - 1; @@ -36784,9 +37318,9 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - const vector_t& vec(parameters[0]); + const vector_t vec(parameters[0]); std::size_t r0 = 0; std::size_t r1 = vec.size() - 1; @@ -36830,9 +37364,9 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - const vector_t& vec(parameters[0]); + const vector_t vec(parameters[0]); std::size_t r0 = 0; std::size_t r1 = vec.size() - 1; @@ -36876,10 +37410,10 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - vector_t x(parameters[0]); - vector_t y(parameters[(0 == ps_index) ? 1 : 3]); + const vector_t x(parameters[0]); + vector_t y(parameters[(0 == ps_index) ? 1 : 3]); std::size_t xr0 = 0; std::size_t xr1 = x.size() - 1; @@ -36926,7 +37460,7 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { vector_t vec(parameters[0]); @@ -36974,7 +37508,7 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { vector_t vec(parameters[0]); @@ -37022,7 +37556,7 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { vector_t vec(parameters[0]); @@ -37077,7 +37611,7 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { vector_t vec(parameters[0]); @@ -37136,7 +37670,7 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { vector_t vec(parameters[0]); @@ -37191,7 +37725,7 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { vector_t vec(parameters[0]); @@ -37235,7 +37769,7 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { vector_t vec(parameters[0]); @@ -37284,9 +37818,9 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - vector_t vec(parameters[0]); + const vector_t vec(parameters[0]); std::size_t r0 = 0; std::size_t r1 = vec.size() - 1; @@ -37299,7 +37833,7 @@ for (std::size_t i = r0; i <= r1; ++i) { - details::kahan_sum(result,error,vec[i]); + details::kahan_sum(result, error, vec[i]); } return result; @@ -37329,10 +37863,10 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - vector_t x(parameters[1]); - vector_t y(parameters[2]); + const vector_t x(parameters[1]); + vector_t y(parameters[2]); std::size_t r0 = 0; std::size_t r1 = std::min(x.size(),y.size()) - 1; @@ -37346,7 +37880,7 @@ for (std::size_t i = r0; i <= r1; ++i) { - y[i] = a * x[i] + y[i]; + y[i] = (a * x[i]) + y[i]; } return T(1); @@ -37376,10 +37910,10 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - vector_t x(parameters[1]); - vector_t y(parameters[3]); + const vector_t x(parameters[1]); + vector_t y(parameters[3]); std::size_t r0 = 0; std::size_t r1 = std::min(x.size(),y.size()) - 1; @@ -37424,11 +37958,11 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - vector_t x(parameters[1]); - vector_t y(parameters[2]); - vector_t z(parameters[3]); + const vector_t x(parameters[1]); + const vector_t y(parameters[2]); + vector_t z(parameters[3]); std::size_t r0 = 0; std::size_t r1 = std::min(x.size(),y.size()) - 1; @@ -37444,7 +37978,7 @@ for (std::size_t i = r0; i <= r1; ++i) { - z[i] = a * x[i] + y[i]; + z[i] = (a * x[i]) + y[i]; } return T(1); @@ -37474,11 +38008,11 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - vector_t x(parameters[1]); - vector_t y(parameters[3]); - vector_t z(parameters[4]); + const vector_t x(parameters[1]); + const vector_t y(parameters[3]); + vector_t z(parameters[4]); std::size_t r0 = 0; std::size_t r1 = std::min(x.size(),y.size()) - 1; @@ -37525,10 +38059,10 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - vector_t x(parameters[1]); - vector_t z(parameters[3]); + const vector_t x(parameters[1]); + vector_t z(parameters[3]); std::size_t r0 = 0; std::size_t r1 = x.size() - 1; @@ -37543,7 +38077,7 @@ for (std::size_t i = r0; i <= r1; ++i) { - z[i] = a * x[i] + b; + z[i] = (a * x[i]) + b; } return T(1); @@ -37572,10 +38106,10 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - vector_t x(parameters[0]); - vector_t y(parameters[1]); + const vector_t x(parameters[0]); + const vector_t y(parameters[1]); std::size_t r0 = 0; std::size_t r1 = std::min(x.size(),y.size()) - 1; @@ -37618,10 +38152,10 @@ */ {} - inline T operator()(const std::size_t& ps_index, parameter_list_t parameters) + inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) { - vector_t x(parameters[0]); - vector_t y(parameters[1]); + const vector_t x(parameters[0]); + const vector_t y(parameters[1]); std::size_t r0 = 0; std::size_t r1 = std::min(x.size(),y.size()) - 1; @@ -37636,7 +38170,7 @@ for (std::size_t i = r0; i <= r1; ++i) { - details::kahan_sum(result,error,(x[i] * y[i])); + details::kahan_sum(result, error, (x[i] * y[i])); } return result; @@ -37732,6 +38266,22 @@ } // namespace information + #ifdef exprtk_debug + #undef exprtk_debug + #endif + + #ifdef exprtk_error_location + #undef exprtk_error_location + #endif + + #ifdef exprtk_disable_fallthrough_begin + #undef exprtk_disable_fallthrough_begin + #endif + + #ifdef exprtk_disable_fallthrough_end + #undef exprtk_disable_fallthrough_end + #endif + } // namespace exprtk #endif
diff --git a/exprtk_simple_example_02.cpp b/exprtk_simple_example_02.cpp index cb18b35..71b2069 100644 --- a/exprtk_simple_example_02.cpp +++ b/exprtk_simple_example_02.cpp
@@ -39,14 +39,14 @@ static const T pi = T(3.141592653589793238462643383279502); - T f = pi / T(10); - T t = T(0); - T a = T(10); + const T f = pi / T(10); + const T a = T(10); + T t = T(0); symbol_table_t symbol_table; - symbol_table.add_variable("f",f); symbol_table.add_variable("t",t); - symbol_table.add_variable("a",a); + symbol_table.add_constant("f",f); + symbol_table.add_constant("a",a); symbol_table.add_constants(); expression_t expression;
diff --git a/exprtk_simple_example_03.cpp b/exprtk_simple_example_03.cpp index 16b627f..924e404 100644 --- a/exprtk_simple_example_03.cpp +++ b/exprtk_simple_example_03.cpp
@@ -30,9 +30,9 @@ std::string expression_string = "25x^5 - 35x^4 - 15x^3 + 40x^2 - 15x + 1"; - T r0 = T(0); - T r1 = T(1); - T x = T(0); + const T r0 = T(0); + const T r1 = T(1); + T x = T(0); symbol_table_t symbol_table; symbol_table.add_variable("x",x);
diff --git a/exprtk_simple_example_04.cpp b/exprtk_simple_example_04.cpp index 7cf9393..801feae 100644 --- a/exprtk_simple_example_04.cpp +++ b/exprtk_simple_example_04.cpp
@@ -70,7 +70,7 @@ for (std::size_t i = 0; i < 40; ++i) { - x = i; + x = static_cast<T>(i); T result = expression.value();
diff --git a/exprtk_simple_example_09.cpp b/exprtk_simple_example_09.cpp index 469c910..5f68703 100644 --- a/exprtk_simple_example_09.cpp +++ b/exprtk_simple_example_09.cpp
@@ -130,7 +130,7 @@ for (std::size_t i = 0; i < 100; ++i) { - x = i; + x = static_cast<T>(i); T result1 = expression1.value(); T result2 = expression2.value();
diff --git a/exprtk_simple_example_10.cpp b/exprtk_simple_example_10.cpp index 43cb0b1..9a2e4c1 100644 --- a/exprtk_simple_example_10.cpp +++ b/exprtk_simple_example_10.cpp
@@ -72,7 +72,7 @@ for (std::size_t i = 0; i < 100; ++i) { - x = i; + x = static_cast<T>(i); T result = expression.value();
diff --git a/exprtk_test.cpp b/exprtk_test.cpp index 4fcdbe4..9867f33 100644 --- a/exprtk_test.cpp +++ b/exprtk_test.cpp
@@ -4848,7 +4848,7 @@ std::size_t line_count = 0; - while (std::getline(stream,buffer)) + while (std::getline(stream,(buffer))) { if (buffer.empty()) continue; @@ -7685,7 +7685,7 @@ { static T var_default_value = 1.0; - if (!(result = symbol_table.create_variable(unknown_symbol, var_default_value++))) + if ((result = symbol_table.create_variable(unknown_symbol, var_default_value++)) == false) { error_message = "Failed to create variable(" + unknown_symbol + ") in primary symbol table"; } @@ -7694,7 +7694,7 @@ { static T cvar_default_value = 1.0; - if (!(result = symbol_table.add_constant(unknown_symbol, cvar_default_value++))) + if ((result = symbol_table.add_constant(unknown_symbol, cvar_default_value++)) == false) { error_message = "Failed to create const variable(" + unknown_symbol + ") in primary symbol table"; }
diff --git a/readme.txt b/readme.txt index 485791b..a819125 100644 --- a/readme.txt +++ b/readme.txt
@@ -224,7 +224,7 @@ +----------+---------------------------------------------------------+ | true | True state or any value other than zero (typically 1). | +----------+---------------------------------------------------------+ -| false | False state, value of zero. | +| false | False state, value of exactly zero. | +----------+---------------------------------------------------------+ | and | Logical AND, True only if x and y are both true. | | | (eg: x and y) | @@ -275,7 +275,7 @@ | clamp | Clamp x in range between r0 and r1, where r0 < r1. | | | (eg: clamp(r0,x,r1)) | +----------+---------------------------------------------------------+ -| equal | Equality test between x and y using normalized epsilon | +| equal | Equality test between x and y using normalised epsilon | +----------+---------------------------------------------------------+ | erf | Error function of x. (eg: erf(x)) | +----------+---------------------------------------------------------+ @@ -321,7 +321,7 @@ +----------+---------------------------------------------------------+ | ncdf | Normal cumulative distribution function. (eg: ncdf(x)) | +----------+---------------------------------------------------------+ -| nequal | Not-equal test between x and y using normalized epsilon | +| nequal | Not-equal test between x and y using normalised epsilon | +----------+---------------------------------------------------------+ | pow | x to the power of y. (eg: pow(x,y) == x ^ y) | +----------+---------------------------------------------------------+ @@ -499,7 +499,7 @@ | | eg: | | | 1. if (x > y) z; else w; | | | 2. if (x > y) z; else if (w != u) v; | -| | 3. if (x < y) {z; w + 1;} else u; | +| | 3. if (x < y) { z; w + 1; } else u; | | | 4. if ((x != y) and (z > w)) | | | { | | | y := sin(x) / u; | @@ -651,7 +651,7 @@ (1) Scalar Type The scalar type is a singular numeric value. The underlying type is -that used to specialize the ExprTk components (float, double, long +that used to specialise the ExprTk components (float, double, long double, MPFR et al). @@ -673,7 +673,7 @@ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [SECTION 10 - COMPONENTS] -There are three primary components, that are specialized upon a given +There are three primary components, that are specialised upon a given numeric type, which make up the core of ExprTk. The components are as follows: @@ -791,8 +791,9 @@ 4. bool add_vector (const std::string& name, vector_type&) -The 'vector' type must consist of a contiguous array of scalars which -can be one of the following: +Note: The 'vector' type must be comprised from a contiguous array of +scalars with a size that is larger than zero. The vector type itself +can be any one of the following: 1. std::vector<scalar_t> 2. scalar_t(&v)[N] @@ -800,6 +801,18 @@ 4. exprtk::vector_view<scalar_t> +When registering a variable, vector, string or function with an +instance of a symbol_table, the call to 'add_...' may fail and return +a false result due to one or more of the following reasons: + + 1. Variable name contains invalid characters or is ill-formed + 2. Variable name conflicts with a reserved word (eg: 'while') + 3. Variable name conflicts with a previously registered variable + 4. A vector of size (length) zero is being registered + 5. A free function exceeding fifteen parameters is being registered + 6. The symbol_table instance is in an invalid state + + (2) Expression A structure that holds an abstract syntax tree or AST for a specified expression and is used to evaluate said expression. Evaluation of the @@ -920,8 +933,8 @@ associated reference counts. - exprtk::expression e0; // constructed expression, eg: x + 1 - exprtk::expression e1; // constructed expression, eg: 2z + y + exprtk::expression e0; // constructed expression, eg: x + 1 + exprtk::expression e1; // constructed expression, eg: 2z + y +-----[ e0 cntrl block]----+ +-----[ e1 cntrl block]-----+ | 1. Expression Node 'x+1' | | 1. Expression Node '2z+y' | @@ -934,7 +947,7 @@ +--------------------+ +--------------------+ - e0 = e1; // e0 and e1 are now 2z+y + e0 = e1; // e0 and e1 are now 2z+y +-----[ e1 cntrl block]-----+ | 1. Expression Node '2z+y' | @@ -1226,7 +1239,7 @@ within the loop body on its last iteration: var x := 1; - x + for (var i := i; i < 10; i += 1) + x + for (var i := x; i < 10; i += 1) { i / 2; i + 1; @@ -1303,7 +1316,7 @@ var x := 2; // Statement 1 var y := x + 2; // Statement 2 - x + y // Statement 3 + x + y; // Statement 3 y := x + 3y; // Statement 4 x - y; // Statement 5 @@ -1332,9 +1345,9 @@ as if-statements. The first form, is a simple function based conditional statement, that takes exactly three input expressions: condition, consequent and alternative. The following is an example -expression that utilizes the function based if-statement. +expression that utilises the function based if-statement. - x := if (y < z, y + 1, 2* z) + x := if (y < z, y + 1, 2 * z) In the example above, if the condition 'y < z' is true, then the @@ -1345,7 +1358,7 @@ variation of the expression where the value of the if-statement is used within another statement is as follows: - x := 3 * if (y < z, y + 1, 2* z) / 2 + x := 3 * if (y < z, y + 1, 2 * z) / 2 The second form of if-statement resembles the standard syntax found in @@ -1401,37 +1414,29 @@ Else and If-Else cascading statements. Examples of such statements are as follows: - Example 1: Example 2: - if (x < y) if (x < y) - z := x + 3; { - else y := z + x; - y := x - z; z := x + 3; - } - else - y := x - z; + Example 1: Example 2: Example 3: + if (x < y) if (x < y) if (x > y + 1) + z := x + 3; { y := abs(x - z); + else y := z + x; else + y := x - z; z := x + 3; { + } y := z + x; + else z := x + 3; + y := x - z; }; - Example 3: Example 4: - if (x > y + 1) if (2 * x < max(y,3)) - y := abs(x - z); { - else y := z + x; - { z := x + 3; - y := z + x; } - z := x + 3; else if (2y - z) - }; y := x - z; - Example 5: Example 6: - if (x < y) if (x < y or (x + z) > y) - z := x + 3; { - else if (2y != z) z := x + 3; - { y := x - z; - z := x + 3; } - y := x - z; else if (abs(2y - z) >= 3) - } y := x - z; - else else - x * x; { - z := abs(x * x); - x * y * z; - }; + Example 4: Example 5: Example 6: + if (2 * x < max(y,3)) if (x < y) if (x < y or (x + z) > y) + { z := x + 3; { + y := z + x; else if (2y != z) z := x + 3; + z := x + 3; { y := x - z; + } z := x + 3; } + else if (2y - z) y := x - z; else if (abs(2y - z) >= 3) + y := x - z; } y := x - z; + else else + x * x; { + z := abs(x * x); + x * y * z; + }; In the case where there is no final else statement and the flow @@ -1451,7 +1456,7 @@ expressions which would otherwise have been written using the common form by reducing the total number of nodes in the evaluation tree of an expression and by also leveraging the compiler's ability to -correctly optimize such expressions for a given architecture. +correctly optimise such expressions for a given architecture. 3-Parameter 4-Parameter +-------------+-------------+ +--------------+------------------+ @@ -1581,25 +1586,28 @@ (a) Initialise to a string var x := 'abc'; - (b) Initialise to a string expression + (b) Initialise to an empty string + var x := ''; + + (c) Initialise to a string expression var x := 'abc' + '123'; - (c) Initialise to a string range + (d) Initialise to a string range var x := 'abc123'[2:4]; - (d) Initialise to another string variable + (e) Initialise to another string variable var x := 'abc'; var y := x; - (e) Initialise to another string variable range + (f) Initialise to another string variable range var x := 'abc123'; var y := x[2:4]; - (f) Initialise to a string expression + (g) Initialise to a string expression var x := 'abc'; var y := x + '123'; - (g) Initialise to a string expression range + (h) Initialise to a string expression range var x := 'abc'; var y := (x + '123')[1:3]; @@ -1775,7 +1783,7 @@ vector_view instance can be efficiently rebased, and the expression evaluated as normal. - exprtk::vector_view<T> view = exprtk::make_vector_view(v, v.size()); + exprtk::vector_view<T> view = exprtk::make_vector_view(v,v.size()); symbol_table_t symbol_table; symbol_table.add_vector("v",view); @@ -1794,7 +1802,7 @@ [SECTION 15 - USER DEFINED FUNCTIONS] ExprTk provides a means whereby custom functions can be defined and -utilized within expressions. The concept requires the user to +utilised within expressions. The concept requires the user to provide a reference to the function coupled with an associated name that will be invoked within expressions. Functions may take numerous inputs but will always return a single value of the underlying numeric @@ -1840,7 +1848,7 @@ (2) ivararg_function This interface supports a variable number of scalar arguments as input into the function. The function operator interface uses a std::vector -specialized upon type T to facilitate parameter passing. The following +specialised upon type T to facilitate parameter passing. The following example defines a vararg function called 'boo': template <typename T> @@ -1863,7 +1871,7 @@ (3) igeneric_function This interface supports a variable number of arguments and types as input into the function. The function operator interface uses a -std::vector specialized upon the type_store type to facilitate +std::vector specialised upon the type_store type to facilitate parameter passing. Scalar <-- function(i_0, i_1, i_2....., i_N) @@ -2335,6 +2343,42 @@ parameter sequence defined in order for the zero parameter trait to properly take effect otherwise a compilation error will occur. + +(9) Free Functions +The ExprTk symbol table supports the registration of free functions +and lambdas (anonymous functors) for use in expressions. The basic +requirements are similar to those found in ifunction derived user +defined functions. This includes support for free functions using +anywhere from zero up to fifteen input parameters of scalar type, with +a return type that is also scalar. Furthermore such functions will by +default be assumed to have side-effects and hence will not participate +in constant folding optimisations. + +In the following example, a two input parameter free function named +'compute', and a three input parameter lambda will be registered with +the given symbol_table instance: + + + double compute(double v0, double v1) + { + return 2.0 * v0 + v1 / 3.0; + } + + . + . + . + + typedef exprtk::symbol_table<double> symbol_table_t; + + symbol_table_t symbol_table; + + symbol_table.add_function("compute", compute); + + symbol_table.add_function("lambda", + [](double v0, double v1, double v2) -> double + { return v0 / v1 + v2; }); + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [SECTION 16 - EXPRESSION DEPENDENTS] @@ -2443,7 +2487,7 @@ (5) None x + y + z -Note: In expression 4, both variables 'z' and 'w' are denoted as being +Note: In expression 4, both variables 'w' and 'z' are denoted as being assignments even though only one of them can ever be modified at the time of evaluation. Furthermore the determination of which of the two variables the modification will occur upon can only be known with @@ -2489,7 +2533,7 @@ However as an expression can have more than one symbol table instance associated with itself, when building more complex systems that -utilize many expressions where each can in turn utilize one or more +utilise many expressions where each can in turn utilise one or more variables from a large set of potential variables, functions or constants, it becomes evident that grouping variables into layers of symbol_tables will simplify and streamline the overall process. @@ -2559,7 +2603,7 @@ (2) customer_name -The following is a diagram depicting the possible version of the +The following is a diagram depicting the possible version of the denoted symbol table hierarchies. In the diagram there are two unique expressions, each of which have a reference to the Global constant, functions and variables symbol tables and an exclusive reference to a @@ -2589,8 +2633,8 @@ Bringing all of the above together, in the following example the -hierarchy of symbol tables are instantiated and initialised. An -expression that makes use of various elements of each symbol table is +hierarchy of symbol tables are instantiated and initialised. An +expression that makes use of various elements of each symbol table is then compiled and later on evaluated: typedef exprtk::symbol_table<double> symbol_table_t; @@ -2722,7 +2766,7 @@ In this scenario one can use the 'dependent_entity_collector' component as described in [Section 16] to further determine which of the registered variables were actually used in the given expression. -As an example once the set of utilized variables are known, any +As an example once the set of utilised variables are known, any further 'attention' can be restricted to only those variables when evaluating the expression. This can be quite useful when dealing with expressions that can draw from a set of hundreds or even thousands of @@ -3427,8 +3471,8 @@ expression.value(); - printf("Result0: %15.5f\n",result0 ); - printf("Result1: %s\n" ,result1.c_str()); + printf("Result0: %15.5f\n", result0 ); + printf("Result1: %s\n" , result1.c_str()); In the example above, the expression will compute two results. As such @@ -3436,7 +3480,7 @@ result1 respectively. The first is of scalar type (double), the second is of string type. Once the expression has been evaluated, the two variables will have been updated with the new result values, and can -then be further utilized from within the calling program. +then be further utilised from within the calling program. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -3753,12 +3797,12 @@ (1) No variables (2) One variable called x - (3) Two variable called x and y - (3) Three variable called x, y and z + (3) Two variables called x and y + (3) Three variables called x, y and z -An example use of each of the three overloads for the compute routine -is as follows: +Example uses of each of the three overloads for the compute routine +are as follows: T result = T(0); @@ -3803,11 +3847,11 @@ (d) integrate This free function will attempt to perform a numerical integration of -a single variable compiled expression over a defined range and given -step size. The numerical integration is based on the three point form -of the Simpson's rule. The integrate function has two overloads, where -the variable of integration can either be passed as a reference or as -a name in string form. Example usage of the function is as follows: +a single variable compiled expression over a specified range and step +size. The numerical integration is based on the three point form of +Simpson's rule. The integrate function has two overloads, where the +variable of integration can either be passed as a reference or as a +name in string form. Example usage of the function is as follows: typedef exprtk::parser<T> parser_t; typedef exprtk::expression<T> expression_t; @@ -3863,7 +3907,7 @@ .... - // Differentiate expression where value of x = 12.3 using a reference + // Differentiate expression at value of x = 12.3 using a reference // to the x variable x = T(12.3); T derivative1 = exprtk::derivative(expression,x); @@ -4047,7 +4091,7 @@ 1 / sqrt(2x) * e^(3y) -Let's say we would like to determine which sub-part of the expression +Lets say we would like to determine which sub-part of the expression takes the most time to evaluate and perhaps attempt to rework the expression based on the results. In order to do this we will create a text file called 'test.txt' and then proceed to make some educated @@ -4133,7 +4177,7 @@ (09) The life-time of objects registered with or created from a specific symbol-table must span at least the life-time of the - compiled expressions which utilize objects, such as variables, + compiled expressions which utilise objects, such as variables, of that symbol-table, otherwise the result will be undefined behavior. @@ -4289,7 +4333,15 @@ performance critical code paths, and should instead occur entirely either before or after such code paths. - (32) Before jumping in and using ExprTk, do take the time to peruse + (32) Deep copying an expression instance for the purposes of + persisting to disk or otherwise transmitting elsewhere with the + intent to 'resurrect' the expression instance later on is not + possible due to the reasons described in the final note of + Section 10. The recommendation is to instead simply persist the + string form of the expression and compile the expression at + run-time on the target. + + (33) Before jumping in and using ExprTk, do take the time to peruse the documentation and all of the examples, both in the main and the extras distributions. Having an informed general view of what can and can't be done, and how something should be done