xfygogo
/
exprtk
mirror of https://github.com/ArashPartow/exprtk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

C++ Mathematical Expression Library (ExprTk) http://www.partow.net/programming/exprtk/index.html

This commit is contained in:
Arash Partow 2014-03-23 21:10:21 +11:00
parent 77897604bc
commit 8a64a1faf6
1 changed files with 80 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
exprtk.hpp
View File

@ -2034,7 +2034,7 @@ namespace exprtk
token_t t; token_t t;
if (std::distance(s_itr_,s_end_) < 2) if (std::distance(s_itr_,s_end_) < 2)
{ {
t.set_error(token::e_err_string,begin,s_itr_,base_itr_); t.set_error(token::e_err_string,s_itr_,s_end_,base_itr_);
token_list_.push_back(t); token_list_.push_back(t);
return; return;
} }
@ -2741,6 +2741,7 @@ namespace exprtk
add_invalid(lexer::token::e_string,lexer::token::e_number); add_invalid(lexer::token::e_string,lexer::token::e_number);
add_invalid(lexer::token::e_string,lexer::token::e_colon ); add_invalid(lexer::token::e_string,lexer::token::e_colon );
add_invalid(lexer::token::e_colon ,lexer::token::e_string); add_invalid(lexer::token::e_colon ,lexer::token::e_string);
add_invalid(lexer::token::e_assign,lexer::token::e_string);
add_invalid_set1(lexer::token::e_assign); add_invalid_set1(lexer::token::e_assign);
add_invalid_set1(lexer::token::e_shr ); add_invalid_set1(lexer::token::e_shr );
add_invalid_set1(lexer::token::e_shl ); add_invalid_set1(lexer::token::e_shl );
@ -10133,6 +10134,7 @@ namespace exprtk
load_sf3_map(sf3_map_); load_sf3_map(sf3_map_);
load_sf4_map(sf4_map_); load_sf4_map(sf4_map_);
expression_generator_.init_synthesize_map(); expression_generator_.init_synthesize_map();
expression_generator_.set_parser(*this);
expression_generator_.set_uom(unary_op_map_); expression_generator_.set_uom(unary_op_map_);
expression_generator_.set_bom(binary_op_map_); expression_generator_.set_bom(binary_op_map_);
expression_generator_.set_ibom(inv_binary_op_map_); expression_generator_.set_ibom(inv_binary_op_map_);
@ -10197,6 +10199,7 @@ namespace exprtk
inline bool compile(const std::string& expression_string, expression<T>& expr) inline bool compile(const std::string& expression_string, expression<T>& expr)
{ {
synthesis_error_.clear();
error_list_.clear(); error_list_.clear();
expression_generator_.set_allocator(node_allocator_); expression_generator_.set_allocator(node_allocator_);
@ -10709,25 +10712,38 @@ namespace exprtk
next_token(); next_token();
expression_node_ptr right_branch = parse_expression(current_state.right); expression_node_ptr right_branch = parse_expression(current_state.right);
expression_node_ptr new_expression = error_node();
if (right_branch) if (right_branch)
{ {
expression = expression_generator_( new_expression = expression_generator_(
current_state.operation, current_state.operation,
expression, expression,
right_branch right_branch
); );
} }
if ((0 == expression) || (0 == right_branch)) if ((0 == new_expression) || (0 == right_branch))
{
if (error_list_.empty())
{ {
set_error( set_error(
make_error(parser_error::e_syntax, make_error(parser_error::e_syntax,
current_token_, prev_token,
"ERR08 - General parsing error.")); !synthesis_error_.empty() ?
synthesis_error_ :
"ERR08 - General parsing error at token: '" + prev_token.value + "'"));
}
free_node(node_allocator_, expression);
free_node(node_allocator_,right_branch);
return error_node(); return error_node();
} }
else
expression = new_expression;
} }
return expression; return expression;
} }
@ -12436,6 +12452,7 @@ namespace exprtk
typedef details::expression_node<Type>* expression_node_ptr; typedef details::expression_node<Type>* expression_node_ptr;
typedef expression_node_ptr (*synthesize_functor_t)(expression_generator<T>&, const details::operator_type& operation, expression_node_ptr (&branch)[2]); typedef expression_node_ptr (*synthesize_functor_t)(expression_generator<T>&, const details::operator_type& operation, expression_node_ptr (&branch)[2]);
typedef std::map<std::string,synthesize_functor_t> synthesize_map_t; typedef std::map<std::string,synthesize_functor_t> synthesize_map_t;
typedef typename exprtk::parser<Type> parser_t;
typedef const Type& vtype; typedef const Type& vtype;
typedef const Type ctype; typedef const Type ctype;
@ -12510,6 +12527,11 @@ namespace exprtk
register_synthezier(synthesize_covovoc_expression4) register_synthezier(synthesize_covovoc_expression4)
} }
inline void set_parser(parser_t& p)
{
parser_ = &p;
}
inline void set_uom(unary_op_map_t& unary_op_map) inline void set_uom(unary_op_map_t& unary_op_map)
{ {
unary_op_map_ = &unary_op_map; unary_op_map_ = &unary_op_map;
@ -12869,7 +12891,7 @@ namespace exprtk
result = true; result = true;
if (result) if (result)
{ {
details::free_all_nodes(*node_allocator_,branch); parser_->set_synthesis_error("Invalid string operation.");
} }
return result; return result;
} }
@ -12886,7 +12908,7 @@ namespace exprtk
result = true; result = true;
if (result) if (result)
{ {
details::free_all_nodes(*node_allocator_,branch); parser_->set_synthesis_error("Invalid string operation.");
} }
return result; return result;
} }
@ -12927,10 +12949,7 @@ namespace exprtk
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])) if ((0 == branch[0]) || (0 == branch[1]))
{
details::free_all_nodes(*node_allocator_,branch);
return error_node(); return error_node();
}
else if (is_invalid_string_op(operation,branch)) else if (is_invalid_string_op(operation,branch))
return error_node(); return error_node();
else if (details::e_assign == operation) else if (details::e_assign == operation)
@ -13003,11 +13022,7 @@ namespace exprtk
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)) if ((0 == b0) || (0 == b1))
{
details::free_node(*node_allocator_,b0);
details::free_node(*node_allocator_,b1);
return error_node(); return error_node();
}
else else
{ {
expression_node_ptr branch[2] = { b0, b1 }; expression_node_ptr branch[2] = { b0, b1 };
@ -13736,8 +13751,11 @@ namespace exprtk
if (details::is_variable_node(branch[0])) if (details::is_variable_node(branch[0]))
return synthesize_expression<assignment_node_t,2>(operation,branch); return synthesize_expression<assignment_node_t,2>(operation,branch);
else else
{
parser_->set_synthesis_error("Invalid assignment operation.");
return error_node(); return error_node();
} }
}
#ifndef exprtk_disable_sc_andor #ifndef exprtk_disable_sc_andor
inline expression_node_ptr synthesize_shortcircuit_expression(const details::operator_type& operation, expression_node_ptr (&branch)[2]) inline expression_node_ptr synthesize_shortcircuit_expression(const details::operator_type& operation, expression_node_ptr (&branch)[2])
@ -18057,6 +18075,7 @@ namespace exprtk
inv_binary_op_map_t* inv_binary_op_map_; inv_binary_op_map_t* inv_binary_op_map_;
sf3_map_t* sf3_map_; sf3_map_t* sf3_map_;
sf4_map_t* sf4_map_; sf4_map_t* sf4_map_;
parser_t* parser_;
}; };
inline void set_error(const parser_error::type& error_type) inline void set_error(const parser_error::type& error_type)
@ -18072,6 +18091,14 @@ namespace exprtk
} }
} }
inline void set_synthesis_error(const std::string& synthesis_error_message)
{
if (synthesis_error_.empty())
{
synthesis_error_ = synthesis_error_message;
}
}
inline void load_unary_operations_map(unary_op_map_t& m) inline void load_unary_operations_map(unary_op_map_t& m)
{ {
#define register_unary_op(Op,UnaryFunctor) \ #define register_unary_op(Op,UnaryFunctor) \
@ -18247,6 +18274,7 @@ namespace exprtk
inv_binary_op_map_t inv_binary_op_map_; inv_binary_op_map_t inv_binary_op_map_;
sf3_map_t sf3_map_; sf3_map_t sf3_map_;
sf4_map_t sf4_map_; sf4_map_t sf4_map_;
std::string synthesis_error_;
lexer::helper::helper_assembly helper_assembly_; lexer::helper::helper_assembly helper_assembly_;