expression_processor< T > Class Template Reference

Collaboration diagram for expression_processor< T >:

Classes
struct	function_definition
struct	parse_function_definition_impl

Public Types
typedef exprtk::symbol_table< T >	symbol_table_t
typedef exprtk::expression< T >	expression_t
typedef exprtk::parser< T >	parser_t
typedef exprtk::parser_error::type	error_t
typedef exprtk::function_compositor< T >	compositor_t
typedef compositor_t::function	function_t
typedef parser_t::settings_store	settings_store_t
typedef exprtk::lexer::parser_helper	prsrhlpr_t
typedef parser_t::dependent_entity_collector::symbol_t	symbol_t
typedef std::vector< symbol_t >	symbol_list_t
typedef exprtk::symbol_table< T >	symbol_table_t
typedef exprtk::expression< T >	expression_t
typedef exprtk::parser< T >	parser_t
typedef exprtk::parser_error::type	error_t
typedef exprtk::function_compositor< T >	compositor_t
typedef compositor_t::function	function_t
typedef parser_t::settings_store	settings_store_t
typedef exprtk::lexer::parser_helper	prsrhlpr_t
typedef parser_t::dependent_entity_collector::symbol_t	symbol_t
typedef std::vector< symbol_t >	symbol_list_t

Public Member Functions
	expression_processor ()
	~expression_processor ()
bool &	persist_symbol_table ()
bool &	symbol_dump ()
bool &	assignment_dump ()
bool &	display_total_time ()
bool &	display_total_compile_time ()
bool &	enable_usr ()
bool &	disable_local_vardef ()
void	setup_symbol_table ()
void	process (std::string program)
void	process_from_file (const std::string &file_name)
void	process_directive (std::string expression)
	expression_processor ()
	~expression_processor ()
bool &	persist_symbol_table ()
bool &	symbol_dump ()
bool &	assignment_dump ()
bool &	display_total_time ()
bool &	display_total_compile_time ()
bool &	enable_usr ()
bool &	disable_local_vardef ()
bool &	disable_commutative_check ()
void	setup_symbol_table ()
void	process (std::string program)
void	process_from_file (const std::string &file_name)
void	process_directive (std::string expression)

Private Types
enum	func_parse_result {   e_parse_unknown = 0 , e_parse_success = 1 , e_parse_partial = 2 , e_parse_lexfail = 4 ,   e_parse_notfunc = 8 , e_parse_unknown = 0 , e_parse_success = 1 , e_parse_partial = 2 ,   e_parse_lexfail = 4 , e_parse_notfunc = 8 }
enum	func_parse_result {   e_parse_unknown = 0 , e_parse_success = 1 , e_parse_partial = 2 , e_parse_lexfail = 4 ,   e_parse_notfunc = 8 , e_parse_unknown = 0 , e_parse_success = 1 , e_parse_partial = 2 ,   e_parse_lexfail = 4 , e_parse_notfunc = 8 }

Private Member Functions
void	print_results (const exprtk::results_context< T > &results)
void	perform_symbol_dump (const symbol_list_t &variable_list) const
void	process_batch_run (const std::string &batch_runs_cnt)
void	process_multiline ()
func_parse_result	parse_function_definition (std::string &func_def, function_definition &cf)
std::string	read_from_stdin ()
void	process_function_definition (const std::string &func_def_header, bool read_stdin=true)
void	list_symbols ()
void	clear_functions ()
std::string	trim_whitespace (std::string s)
void	process_disable_arithmetic (const std::string &arithmetic)
void	process_disable_assignment (const std::string &assignment)
void	process_disable_inequality (const std::string &inequality)
void	process_enable_arithmetic (const std::string &arithmetic)
void	process_enable_assignment (const std::string &assignment)
void	process_enable_inequality (const std::string &inequality)
void	print_results (const exprtk::results_context< T > &results)
void	perform_symbol_dump (const symbol_list_t &variable_list) const
void	process_batch_run (const std::string &batch_runs_cnt)
void	process_multiline ()
func_parse_result	parse_function_definition (std::string &func_def, function_definition &cf)
std::string	read_from_stdin ()
void	process_function_definition (const std::string &func_def_header, bool read_stdin=true)
void	list_symbols ()
void	clear_functions ()
std::string	trim_whitespace (std::string s)
void	process_disable_arithmetic (const std::string &arithmetic)
void	process_disable_assignment (const std::string &assignment)
void	process_disable_inequality (const std::string &inequality)
void	process_enable_arithmetic (const std::string &arithmetic)
void	process_enable_assignment (const std::string &assignment)
void	process_enable_inequality (const std::string &inequality)

Private Attributes
bool	persist_symbol_table_
bool	symbol_dump_
bool	assignment_dump_
bool	display_total_time_
bool	display_total_compile_time_
bool	enable_usr_
bool	disable_local_vardef_
std::size_t	batch_runs_cnt_
symbol_table_t	symbol_table_
symbol_table_t	function_symbol_table_
parser_t	parser_
compositor_t	compositor_
putch< T >	putch_
putint< T >	putint_
rnd_01< T >	rnd_01_
exprtk::rtl::io::file::package< T >	fileio_package_
exprtk::rtl::vecops::package< T >	vecops_package_
exprtk::rtl::io::package< T >	io_package_
exprtk::polynomial< T, 1 >	poly01_
exprtk::polynomial< T, 2 >	poly02_
exprtk::polynomial< T, 3 >	poly03_
exprtk::polynomial< T, 4 >	poly04_
exprtk::polynomial< T, 5 >	poly05_
exprtk::polynomial< T, 6 >	poly06_
exprtk::polynomial< T, 7 >	poly07_
exprtk::polynomial< T, 8 >	poly08_
exprtk::polynomial< T, 9 >	poly09_
exprtk::polynomial< T, 10 >	poly10_
exprtk::polynomial< T, 11 >	poly11_
exprtk::polynomial< T, 12 >	poly12_
std::vector< function_definition >	func_def_list_
std::map< std::string, typename settings_store_t::settings_arithmetic_opr >	arith_opr_
std::map< std::string, typename settings_store_t::settings_assignment_opr >	assign_opr_
std::map< std::string, typename settings_store_t::settings_inequality_opr >	inequality_opr_
bool	disable_commutative_check_
vector_access_rtc	vector_access_rtc_

Detailed Description

template<typename T>
class expression_processor< T >

Definition at line 78 of file exprtk_mpfr_repl.cpp.

Member Typedef Documentation

compositor_t [1/2]

template<typename T>

typedef exprtk::function_compositor<T> expression_processor< T >::compositor_t

Definition at line 86 of file exprtk_mpfr_repl.cpp.

compositor_t [2/2]

template<typename T>

typedef exprtk::function_compositor<T> expression_processor< T >::compositor_t

Definition at line 100 of file exprtk_repl.cpp.

error_t [1/2]

template<typename T>

typedef exprtk::parser_error::type expression_processor< T >::error_t

Definition at line 85 of file exprtk_mpfr_repl.cpp.

error_t [2/2]

template<typename T>

typedef exprtk::parser_error::type expression_processor< T >::error_t

Definition at line 99 of file exprtk_repl.cpp.

expression_t [1/2]

template<typename T>

typedef exprtk::expression<T> expression_processor< T >::expression_t

Definition at line 83 of file exprtk_mpfr_repl.cpp.

expression_t [2/2]

template<typename T>

typedef exprtk::expression<T> expression_processor< T >::expression_t

Definition at line 97 of file exprtk_repl.cpp.

function_t [1/2]

template<typename T>

typedef compositor_t::function expression_processor< T >::function_t

Definition at line 87 of file exprtk_mpfr_repl.cpp.

function_t [2/2]

template<typename T>

typedef compositor_t::function expression_processor< T >::function_t

Definition at line 101 of file exprtk_repl.cpp.

parser_t [1/2]

template<typename T>

typedef exprtk::parser<T> expression_processor< T >::parser_t

Definition at line 84 of file exprtk_mpfr_repl.cpp.

parser_t [2/2]

template<typename T>

typedef exprtk::parser<T> expression_processor< T >::parser_t

Definition at line 98 of file exprtk_repl.cpp.

prsrhlpr_t [1/2]

template<typename T>

typedef exprtk::lexer::parser_helper expression_processor< T >::prsrhlpr_t

Definition at line 89 of file exprtk_mpfr_repl.cpp.

prsrhlpr_t [2/2]

template<typename T>

typedef exprtk::lexer::parser_helper expression_processor< T >::prsrhlpr_t

Definition at line 103 of file exprtk_repl.cpp.

settings_store_t [1/2]

template<typename T>

typedef parser_t::settings_store expression_processor< T >::settings_store_t

Definition at line 88 of file exprtk_mpfr_repl.cpp.

settings_store_t [2/2]

template<typename T>

typedef parser_t::settings_store expression_processor< T >::settings_store_t

Definition at line 102 of file exprtk_repl.cpp.

symbol_list_t [1/2]

template<typename T>

typedef std::vector<symbol_t> expression_processor< T >::symbol_list_t

Definition at line 92 of file exprtk_mpfr_repl.cpp.

symbol_list_t [2/2]

template<typename T>

typedef std::vector<symbol_t> expression_processor< T >::symbol_list_t

Definition at line 106 of file exprtk_repl.cpp.

symbol_t [1/2]

template<typename T>

typedef parser_t::dependent_entity_collector::symbol_t expression_processor< T >::symbol_t

Definition at line 91 of file exprtk_mpfr_repl.cpp.

symbol_t [2/2]

template<typename T>

typedef parser_t::dependent_entity_collector::symbol_t expression_processor< T >::symbol_t

Definition at line 105 of file exprtk_repl.cpp.

symbol_table_t [1/2]

template<typename T>

typedef exprtk::symbol_table<T> expression_processor< T >::symbol_table_t

Definition at line 82 of file exprtk_mpfr_repl.cpp.

symbol_table_t [2/2]

template<typename T>

typedef exprtk::symbol_table<T> expression_processor< T >::symbol_table_t

Definition at line 96 of file exprtk_repl.cpp.

Member Enumeration Documentation

func_parse_result [1/2]

template<typename T>

enum expression_processor::func_parse_result

private

Enumerator
e_parse_unknown
e_parse_success
e_parse_partial
e_parse_lexfail
e_parse_notfunc
e_parse_unknown
e_parse_success
e_parse_partial
e_parse_lexfail
e_parse_notfunc

Definition at line 607 of file exprtk_mpfr_repl.cpp.

   {
      e_parse_unknown = 0,
      e_parse_success = 1,
      e_parse_partial = 2,
      e_parse_lexfail = 4,
      e_parse_notfunc = 8
   };

func_parse_result [2/2]

template<typename T>

enum expression_processor::func_parse_result

private

Enumerator
e_parse_unknown
e_parse_success
e_parse_partial
e_parse_lexfail
e_parse_notfunc
e_parse_unknown
e_parse_success
e_parse_partial
e_parse_lexfail
e_parse_notfunc

Definition at line 636 of file exprtk_repl.cpp.

   {
      e_parse_unknown = 0,
      e_parse_success = 1,
      e_parse_partial = 2,
      e_parse_lexfail = 4,
      e_parse_notfunc = 8
   };

Constructor & Destructor Documentation

expression_processor() [1/2]

template<typename T>

expression_processor< T >::expression_processor ( )

inline

Definition at line 94 of file exprtk_mpfr_repl.cpp.

   : persist_symbol_table_      (false),
     symbol_dump_               (false),
     assignment_dump_           (false),
     display_total_time_        (false),
     display_total_compile_time_(false),
     enable_usr_                (false),
     disable_local_vardef_      (false),
     batch_runs_cnt_            (0),
     compositor_(function_symbol_table_)
     #ifdef exprtk_enable_repl_variables
     ,s0_("abcdefghijk"),
      s1_("abcdefghijk0123456789"),
      s2_("012345678901234567890123456789"),
      v0_({1,1,1}),
      v1_({2,2,2,2,2}),
      v2_({3,3,3,3,3,3,3}),
      v3_({4,4,4,4,4,4,4,4}),
      vv_(exprtk::make_vector_view(v2_,v2_.size()))
     #endif
   {
      symbol_table_.add_constants();
 
      symbol_table_.add_function("putch"  ,putch_  );
      symbol_table_.add_function("putint" ,putint_ );
      symbol_table_.add_function("rnd_01" ,rnd_01_ );
      symbol_table_.add_package (fileio_package_   );
      symbol_table_.add_package (vecops_package_   );
      symbol_table_.add_package (io_package_       );
 
      symbol_table_.add_function("poly01", poly01_);
      symbol_table_.add_function("poly02", poly02_);
      symbol_table_.add_function("poly03", poly03_);
      symbol_table_.add_function("poly04", poly04_);
      symbol_table_.add_function("poly05", poly05_);
      symbol_table_.add_function("poly06", poly06_);
      symbol_table_.add_function("poly07", poly07_);
      symbol_table_.add_function("poly08", poly08_);
      symbol_table_.add_function("poly09", poly09_);
      symbol_table_.add_function("poly10", poly10_);
      symbol_table_.add_function("poly11", poly11_);
      symbol_table_.add_function("poly12", poly12_);
 
      #ifdef exprtk_enable_repl_variables
      symbol_table_.add_stringvar("s0",s0_);
      symbol_table_.add_stringvar("s1",s1_);
      symbol_table_.add_stringvar("s2",s2_);
      symbol_table_.add_vector   ("v0",v0_);
      symbol_table_.add_vector   ("v1",v1_);
      symbol_table_.add_vector   ("v2",v2_);
      symbol_table_.add_vector   ("v3",v3_);
 
      vv_ = exprtk::make_vector_view(v2_,v2_.size());
      symbol_table_.add_vector   ("vv",vv_);
      #endif
 
      compositor_.add_auxiliary_symtab(symbol_table_);
 
      arith_opr_["+"] = settings_store_t::e_arith_add;
      arith_opr_["-"] = settings_store_t::e_arith_sub;
      arith_opr_["*"] = settings_store_t::e_arith_mul;
      arith_opr_["/"] = settings_store_t::e_arith_div;
      arith_opr_["%"] = settings_store_t::e_arith_mod;
      arith_opr_["^"] = settings_store_t::e_arith_pow;
 
      assign_opr_[":="] = settings_store_t::e_assign_assign;
      assign_opr_["+="] = settings_store_t::e_assign_addass;
      assign_opr_["-="] = settings_store_t::e_assign_subass;
      assign_opr_["*="] = settings_store_t::e_assign_mulass;
      assign_opr_["/="] = settings_store_t::e_assign_divass;
      assign_opr_["%="] = settings_store_t::e_assign_modass;
 
      inequality_opr_[ "<"] = settings_store_t::e_ineq_lt;
      inequality_opr_["<="] = settings_store_t::e_ineq_lte;
      inequality_opr_["=="] = settings_store_t::e_ineq_eq;
      inequality_opr_[ "="] = settings_store_t::e_ineq_equal;
      inequality_opr_["!="] = settings_store_t::e_ineq_ne;
      inequality_opr_["<>"] = settings_store_t::e_ineq_nequal;
      inequality_opr_[">="] = settings_store_t::e_ineq_gte;
      inequality_opr_[ ">"] = settings_store_t::e_ineq_gt;
 
      clear_functions();
   }

References assignment_dump_, batch_runs_cnt_, compositor_, disable_local_vardef_, display_total_compile_time_, display_total_time_, enable_usr_, function_symbol_table_, persist_symbol_table_, and symbol_dump_.

~expression_processor() [1/2]

template<typename T>

expression_processor< T >::~expression_processor ( )

inline

Definition at line 178 of file exprtk_mpfr_repl.cpp.

   {
      clear_functions();
   }

References clear_functions().

Here is the call graph for this function:

expression_processor() [2/2]

template<typename T>

expression_processor< T >::expression_processor ( )

inline

Definition at line 108 of file exprtk_repl.cpp.

   : persist_symbol_table_          (false)
   , symbol_dump_                   (false)
   , assignment_dump_               (false)
   , display_total_time_            (false)
   , display_total_compile_time_    (false)
   , enable_usr_                    (false)
   , disable_local_vardef_          (false)
   , disable_commutative_check_(false)
   , batch_runs_cnt_                (0    )
   , compositor_(function_symbol_table_)
   #ifdef exprtk_enable_repl_variables
   , s0_("abcdefghijk")
   , s1_("abcdefghijk0123456789")
   , s2_("012345678901234567890123456789")
   , v0_({ 1, 1, 1 })
   , v1_({ 2, 2, 2, 2, 2})
   , v2_({ 3, 3, 3, 3, 3, 3, 3})
   , v3_({ 4, 4, 4, 4, 4, 4, 4, 4})
   , vv_(exprtk::make_vector_view(v2_,v2_.size()))
   #endif
   {
      symbol_table_.add_constants();
 
      symbol_table_.add_function("putch"  , putch_  );
      symbol_table_.add_function("putint" , putint_ );
      symbol_table_.add_function("rnd_01" , rnd_01_ );
      symbol_table_.add_package (fileio_package_    );
      symbol_table_.add_package (vecops_package_    );
      symbol_table_.add_package (io_package_        );
 
      symbol_table_.add_function("poly01", poly01_);
      symbol_table_.add_function("poly02", poly02_);
      symbol_table_.add_function("poly03", poly03_);
      symbol_table_.add_function("poly04", poly04_);
      symbol_table_.add_function("poly05", poly05_);
      symbol_table_.add_function("poly06", poly06_);
      symbol_table_.add_function("poly07", poly07_);
      symbol_table_.add_function("poly08", poly08_);
      symbol_table_.add_function("poly09", poly09_);
      symbol_table_.add_function("poly10", poly10_);
      symbol_table_.add_function("poly11", poly11_);
      symbol_table_.add_function("poly12", poly12_);
 
      #ifdef exprtk_enable_repl_variables
      symbol_table_.add_stringvar("s0", s0_);
      symbol_table_.add_stringvar("s1", s1_);
      symbol_table_.add_stringvar("s2", s2_);
      symbol_table_.add_vector   ("v0", v0_);
      symbol_table_.add_vector   ("v1", v1_);
      symbol_table_.add_vector   ("v2", v2_);
      symbol_table_.add_vector   ("v3", v3_);
 
      vv_ = exprtk::make_vector_view(v2_,v2_.size());
      symbol_table_.add_vector   ("vv", vv_);
      #endif
 
      compositor_.add_auxiliary_symtab(symbol_table_);
 
      arith_opr_["+"] = settings_store_t::e_arith_add;
      arith_opr_["-"] = settings_store_t::e_arith_sub;
      arith_opr_["*"] = settings_store_t::e_arith_mul;
      arith_opr_["/"] = settings_store_t::e_arith_div;
      arith_opr_["%"] = settings_store_t::e_arith_mod;
      arith_opr_["^"] = settings_store_t::e_arith_pow;
 
      assign_opr_[":="] = settings_store_t::e_assign_assign;
      assign_opr_["+="] = settings_store_t::e_assign_addass;
      assign_opr_["-="] = settings_store_t::e_assign_subass;
      assign_opr_["*="] = settings_store_t::e_assign_mulass;
      assign_opr_["/="] = settings_store_t::e_assign_divass;
      assign_opr_["%="] = settings_store_t::e_assign_modass;
 
      inequality_opr_[ "<"] = settings_store_t::e_ineq_lt;
      inequality_opr_["<="] = settings_store_t::e_ineq_lte;
      inequality_opr_["=="] = settings_store_t::e_ineq_eq;
      inequality_opr_[ "="] = settings_store_t::e_ineq_equal;
      inequality_opr_["!="] = settings_store_t::e_ineq_ne;
      inequality_opr_["<>"] = settings_store_t::e_ineq_nequal;
      inequality_opr_[">="] = settings_store_t::e_ineq_gte;
      inequality_opr_[ ">"] = settings_store_t::e_ineq_gt;
 
      clear_functions();
   }

References assignment_dump_, batch_runs_cnt_, compositor_, disable_commutative_check_, disable_local_vardef_, display_total_compile_time_, display_total_time_, enable_usr_, function_symbol_table_, persist_symbol_table_, and symbol_dump_.

~expression_processor() [2/2]

template<typename T>

expression_processor< T >::~expression_processor ( )

inline

Definition at line 193 of file exprtk_repl.cpp.

   {
      clear_functions();
   }

References clear_functions().

Here is the call graph for this function:

Member Function Documentation

assignment_dump() [1/2]

template<typename T>

bool & expression_processor< T >::assignment_dump ( )

inline

Definition at line 193 of file exprtk_mpfr_repl.cpp.

   {
      return assignment_dump_;
   }

References assignment_dump_.

Referenced by process_directive().

Here is the caller graph for this function:

assignment_dump() [2/2]

template<typename T>

bool & expression_processor< T >::assignment_dump ( )

inline

Definition at line 208 of file exprtk_repl.cpp.

   {
      return assignment_dump_;
   }

References assignment_dump_.

clear_functions() [1/2]

template<typename T>

void expression_processor< T >::clear_functions ( )

inlineprivate

Definition at line 848 of file exprtk_mpfr_repl.cpp.

   {
      func_def_list_.clear();
      function_symbol_table_.clear();
   }

References func_def_list_, and function_symbol_table_.

Referenced by process_directive(), and ~expression_processor().

Here is the caller graph for this function:

clear_functions() [2/2]

template<typename T>

void expression_processor< T >::clear_functions ( )

inlineprivate

Definition at line 877 of file exprtk_repl.cpp.

   {
      func_def_list_.clear();
      function_symbol_table_.clear();
   }

References func_def_list_, and function_symbol_table_.

disable_commutative_check()

template<typename T>

bool & expression_processor< T >::disable_commutative_check ( )

inline

Definition at line 233 of file exprtk_repl.cpp.

   {
      return disable_commutative_check_;
   }

References disable_commutative_check_.

Referenced by process_directive().

Here is the caller graph for this function:

disable_local_vardef() [1/2]

template<typename T>

bool & expression_processor< T >::disable_local_vardef ( )

inline

Definition at line 213 of file exprtk_mpfr_repl.cpp.

   {
      return disable_local_vardef_;
   }

References disable_local_vardef_.

Referenced by process_directive().

Here is the caller graph for this function:

disable_local_vardef() [2/2]

template<typename T>

bool & expression_processor< T >::disable_local_vardef ( )

inline

Definition at line 228 of file exprtk_repl.cpp.

   {
      return disable_local_vardef_;
   }

References disable_local_vardef_.

display_total_compile_time() [1/2]

template<typename T>

bool & expression_processor< T >::display_total_compile_time ( )

inline

Definition at line 203 of file exprtk_mpfr_repl.cpp.

   {
      return display_total_compile_time_;
   }

References display_total_compile_time_.

Referenced by process_directive().

Here is the caller graph for this function:

display_total_compile_time() [2/2]

template<typename T>

bool & expression_processor< T >::display_total_compile_time ( )

inline

Definition at line 218 of file exprtk_repl.cpp.

   {
      return display_total_compile_time_;
   }

References display_total_compile_time_.

display_total_time() [1/2]

template<typename T>

bool & expression_processor< T >::display_total_time ( )

inline

Definition at line 198 of file exprtk_mpfr_repl.cpp.

   {
      return display_total_time_;
   }

References display_total_time_.

Referenced by process_directive().

Here is the caller graph for this function:

display_total_time() [2/2]

template<typename T>

bool & expression_processor< T >::display_total_time ( )

inline

Definition at line 213 of file exprtk_repl.cpp.

   {
      return display_total_time_;
   }

References display_total_time_.

enable_usr() [1/2]

template<typename T>

bool & expression_processor< T >::enable_usr ( )

inline

Definition at line 208 of file exprtk_mpfr_repl.cpp.

   {
      return enable_usr_;
   }

References enable_usr_.

Referenced by process_directive().

Here is the caller graph for this function:

enable_usr() [2/2]

template<typename T>

bool & expression_processor< T >::enable_usr ( )

inline

Definition at line 223 of file exprtk_repl.cpp.

   {
      return enable_usr_;
   }

References enable_usr_.

list_symbols() [1/2]

template<typename T>

void expression_processor< T >::list_symbols ( )

inlineprivate

Definition at line 817 of file exprtk_mpfr_repl.cpp.

   {
      std::deque<std::pair<std::string,T> > variable_list;
      symbol_table_.get_variable_list(variable_list);
 
      std::size_t max_varname_length = 0;
 
      for (std::size_t i = 0; i < variable_list.size(); ++i)
      {
         max_varname_length = std::max(max_varname_length,variable_list[i].first.size());
      }
 
      for (std::size_t i = 0; i < variable_list.size(); ++i)
      {
         int pad_length = 0;
 
         if (max_varname_length > variable_list[i].first.size())
         {
            pad_length = static_cast<int>(max_varname_length - variable_list[i].first.size());
         }
 
         printf("%02d %s%*.*s %s\n",
                static_cast<unsigned int>(i),
                variable_list[i].first.c_str(),
                pad_length,
                pad_length,
                std::string(max_varname_length,' ').c_str(),
                variable_list[i].second.toString().c_str());
      }
   }

References symbol_table_.

Referenced by process_directive().

Here is the caller graph for this function:

list_symbols() [2/2]

template<typename T>

void expression_processor< T >::list_symbols ( )

inlineprivate

Definition at line 846 of file exprtk_repl.cpp.

   {
      std::deque<std::pair<std::string,T> > variable_list;
      symbol_table_.get_variable_list(variable_list);
 
      std::size_t max_varname_length = 0;
 
      for (std::size_t i = 0; i < variable_list.size(); ++i)
      {
         max_varname_length = std::max(max_varname_length,variable_list[i].first.size());
      }
 
      for (std::size_t i = 0; i < variable_list.size(); ++i)
      {
         int pad_length = 0;
 
         if (max_varname_length > variable_list[i].first.size())
         {
            pad_length = static_cast<int>(max_varname_length - variable_list[i].first.size());
         }
 
         printf("%02d %s%*.*s %25.10f\n",
                static_cast<unsigned int>(i),
                variable_list[i].first.c_str(),
                pad_length,
                pad_length,
                std::string(max_varname_length,' ').c_str(),
                variable_list[i].second);
      }
   }

References symbol_table_.

parse_function_definition() [1/2]

template<typename T>

func_parse_result expression_processor< T >::parse_function_definition ( std::string & func_def, function_definition & cf )

inlineprivate

Definition at line 703 of file exprtk_mpfr_repl.cpp.

   {
      parse_function_definition_impl parser;
      return parser.process(func_def,cf);
   }

References expression_processor< T >::parse_function_definition_impl::process().

Referenced by process_function_definition().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_function_definition() [2/2]

template<typename T>

func_parse_result expression_processor< T >::parse_function_definition ( std::string & func_def, function_definition & cf )

inlineprivate

Definition at line 732 of file exprtk_repl.cpp.

   {
      parse_function_definition_impl parser;
      return parser.process(func_def,cf);
   }

perform_symbol_dump() [1/2]

template<typename T>

void expression_processor< T >::perform_symbol_dump ( const symbol_list_t & variable_list ) const

inlineprivate

Definition at line 520 of file exprtk_mpfr_repl.cpp.

   {
      for (std::size_t i = 0; i < variable_list.size(); ++i)
      {
         const symbol_t& symbol = variable_list[i];
 
         switch (symbol.second)
         {
            case parser_t::e_st_variable : printf("[%02d] Variable  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_vector   : printf("[%02d] Vector    %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_string   : printf("[%02d] String    %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_function : printf("[%02d] Function  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_local_variable
                                         : printf("[%02d] LocalVar  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_local_vector
                                         : printf("[%02d] LocalVec  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_local_string
                                         : printf("[%02d] LocalStr  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            default                      : break;
         }
      }
   }

References exprtk::parser< T >::e_st_function, exprtk::parser< T >::e_st_local_string, exprtk::parser< T >::e_st_local_variable, exprtk::parser< T >::e_st_local_vector, exprtk::parser< T >::e_st_string, exprtk::parser< T >::e_st_variable, and exprtk::parser< T >::e_st_vector.

Referenced by process().

Here is the caller graph for this function:

perform_symbol_dump() [2/2]

template<typename T>

void expression_processor< T >::perform_symbol_dump ( const symbol_list_t & variable_list ) const

inlineprivate

Definition at line 549 of file exprtk_repl.cpp.

   {
      for (std::size_t i = 0; i < variable_list.size(); ++i)
      {
         const symbol_t& symbol = variable_list[i];
 
         switch (symbol.second)
         {
            case parser_t::e_st_variable : printf("[%02d] Variable  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_vector   : printf("[%02d] Vector    %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_string   : printf("[%02d] String    %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_function : printf("[%02d] Function  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_local_variable
                                         : printf("[%02d] LocalVar  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_local_vector
                                         : printf("[%02d] LocalVec  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            case parser_t::e_st_local_string
                                         : printf("[%02d] LocalStr  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;
 
            default                      : break;
         }
      }
   }

References exprtk::parser< T >::e_st_function, exprtk::parser< T >::e_st_local_string, exprtk::parser< T >::e_st_local_variable, exprtk::parser< T >::e_st_local_vector, exprtk::parser< T >::e_st_string, exprtk::parser< T >::e_st_variable, and exprtk::parser< T >::e_st_vector.

persist_symbol_table() [1/2]

template<typename T>

bool & expression_processor< T >::persist_symbol_table ( )

inline

Definition at line 183 of file exprtk_mpfr_repl.cpp.

   {
      return persist_symbol_table_;
   }

References persist_symbol_table_.

Referenced by process_directive().

Here is the caller graph for this function:

persist_symbol_table() [2/2]

template<typename T>

bool & expression_processor< T >::persist_symbol_table ( )

inline

Definition at line 198 of file exprtk_repl.cpp.

   {
      return persist_symbol_table_;
   }

References persist_symbol_table_.

print_results() [1/2]

template<typename T>

void expression_processor< T >::print_results ( const exprtk::results_context< T > & results )

inlineprivate

Definition at line 468 of file exprtk_mpfr_repl.cpp.

   {
      typedef exprtk::results_context<T> results_context_t;
      typedef typename results_context_t::type_store_t type_t;
      typedef typename type_t::scalar_view scalar_t;
      typedef typename type_t::vector_view vector_t;
      typedef typename type_t::string_view string_t;
 
      typename exprtk::details::numeric::details::number_type<T>::type num_type;
 
      printf("%s\n",std::string(10,'-').c_str());
      printf("Return Results (#%d)\n",static_cast<int>(results.count()));
 
      for (std::size_t i = 0; i < results.count(); ++i)
      {
         printf("[%02d]  ",static_cast<int>(i));
 
         type_t t = results[i];
 
         switch (t.type)
         {
            case type_t::e_scalar : printf("Scalar\t");
                                    exprtk::rtl::io::details::print_type("%10.5f",scalar_t(t)(),num_type);
                                    break;
 
            case type_t::e_vector : {
                                       printf("Vector\t");
                                       vector_t vector(t);
 
                                       for (std::size_t x = 0; x < vector.size(); ++x)
                                       {
                                          exprtk::rtl::io::details::print_type("%10.5f",vector[x],num_type);
 
                                          if ((x + 1) < vector.size())
                                             printf(" ");
                                       }
                                    }
                                    break;
 
            case type_t::e_string : printf("String\t");
                                    printf("%s",to_str(string_t(t)).c_str());
                                    break;
 
            default               : continue;
         }
 
         printf("\n");
      }
 
      printf("%s\n",std::string(10,'-').c_str());
   }

References exprtk::results_context< T >::count(), and exprtk::rtl::io::details::print_type().

Referenced by process().

Here is the call graph for this function:

Here is the caller graph for this function:

print_results() [2/2]

template<typename T>

void expression_processor< T >::print_results ( const exprtk::results_context< T > & results )

inlineprivate

Definition at line 497 of file exprtk_repl.cpp.

   {
      typedef exprtk::results_context<T> results_context_t;
      typedef typename results_context_t::type_store_t type_t;
      typedef typename type_t::scalar_view scalar_t;
      typedef typename type_t::vector_view vector_t;
      typedef typename type_t::string_view string_t;
 
      typename exprtk::details::numeric::details::number_type<T>::type num_type;
 
      printf("%s\n",std::string(10,'-').c_str());
      printf("Return Results (#%d)\n",static_cast<int>(results.count()));
 
      for (std::size_t i = 0; i < results.count(); ++i)
      {
         printf("[%02d]  ",static_cast<int>(i));
 
         type_t t = results[i];
 
         switch (t.type)
         {
            case type_t::e_scalar : printf("Scalar\t");
                                    exprtk::rtl::io::details::print_type("%10.5f",scalar_t(t)(),num_type);
                                    break;
 
            case type_t::e_vector : {
                                       printf("Vector\t");
                                       vector_t vector(t);
 
                                       for (std::size_t x = 0; x < vector.size(); ++x)
                                       {
                                          exprtk::rtl::io::details::print_type("%10.5f",vector[x],num_type);
 
                                          if ((x + 1) < vector.size())
                                             printf(" ");
                                       }
                                    }
                                    break;
 
            case type_t::e_string : printf("String\t");
                                    printf("%s",to_str(string_t(t)).c_str());
                                    break;
 
            default               : continue;
         }
 
         printf("\n");
      }
 
      printf("%s\n",std::string(10,'-').c_str());
   }

References exprtk::results_context< T >::count(), and exprtk::rtl::io::details::print_type().

Here is the call graph for this function:

process() [1/2]

template<typename T>

void expression_processor< T >::process ( std::string program )

inline

Definition at line 228 of file exprtk_mpfr_repl.cpp.

   {
      program = trim_whitespace(program);
 
      if (program.empty())
         return;
 
      setup_symbol_table();
 
      expression_t expression;
      expression.register_symbol_table(symbol_table_);
      expression.register_symbol_table(function_symbol_table_);
 
      exprtk::timer compile_timer;
      compile_timer.start();
 
      if (enable_usr_)
         parser_.enable_unknown_symbol_resolver();
      else
         parser_.disable_unknown_symbol_resolver();
 
      if (disable_local_vardef_)
         parser_.settings().disable_local_vardef();
      else
         parser_.settings().enable_local_vardef();
 
      parser_.dec().collect_variables() = symbol_dump_;
      parser_.dec().collect_functions() = symbol_dump_;
 
      parser_.dec().collect_assignments() = assignment_dump_;
 
      if (!parser_.compile(program,expression))
      {
         printf("Error: %s\tExpression:%c%s\n",
                parser_.error().c_str(),
                ((std::string::npos != program.find_first_of('\n')) ? '\n' : ' '),
                ((program.size() < 200) ? program.c_str() : "....."));
 
         for (std::size_t i = 0; i < parser_.error_count(); ++i)
         {
            error_t error = parser_.get_error(i);
 
            printf("Err No.: %02d  Pos: %02d  Type: [%14s] Msg: %s\n",
                   static_cast<unsigned int>(i),
                   static_cast<unsigned int>(error.token.position),
                   exprtk::parser_error::to_str(error.mode).c_str(),
                   error.diagnostic.c_str());
 
            if (
                 (0 == i) &&
                 exprtk::parser_error::update_error(error,program)
               )
            {
               printf("Error (line: %d column: %d)\n",
                      static_cast<unsigned int>(error.line_no),
                      static_cast<unsigned int>(error.column_no));
 
               printf("%s \n",error.error_line.c_str());
               printf("%s^\n",std::string(error.column_no,'~').c_str());
            }
         }
 
         return;
      }
 
      compile_timer.stop();
 
      if (display_total_compile_time_)
      {
         printf("\nCompile time: %6.3fms\n",compile_timer.time() * 1000.0);
      }
 
      if (batch_runs_cnt_)
      {
         std::vector<double> timings(batch_runs_cnt_,0.0);
 
         exprtk::timer total_timer;
         exprtk::timer timer;
 
         T result = T(0);
 
         total_timer.start();
 
         for (std::size_t i = 0; i < batch_runs_cnt_; ++i)
         {
            timer.start();
 
            result = expression.value();
 
            timer.stop();
 
            timings[i] = timer.time() * 1000.0;
         }
 
         total_timer.stop();
 
         printf("\nresult: %s\n",result.toString().c_str());
 
         std::sort(timings.begin(),timings.end());
 
         printf("\nRuns: %4d  Time min %7.3fms\tmax: %7.3fms\tavg: %7.3fms\ttot: %7.3fms   90%%:%7.3fms\n",
                static_cast<unsigned int>(batch_runs_cnt_),
                timings.front(),
                timings.back (),
                std::accumulate(timings.begin(),timings.end(),0.0) / timings.size(),
                total_timer.time() * 1000.0,
                timings[static_cast<int>(timings.size() * 0.90)]);
 
         return;
      }
 
      exprtk::timer timer;
      timer.start();
 
      T result = expression.value();
 
      timer.stop();
 
      if (expression.results().count())
      {
         print_results(expression.results());
      }
 
      printf("\nresult: %s\n",result.toString().c_str());
 
      if (display_total_time_)
      {
         printf("\nTotal time: %6.3fms\n",timer.time() * 1000.0);
      }
 
      if (symbol_dump_)
      {
         symbol_list_t symbol_list;
 
         parser_.dec().symbols(symbol_list);
 
         printf("------ Symbols ------\n");
         perform_symbol_dump(symbol_list);
         printf("---------------------\n");
      }
 
      if (assignment_dump_)
      {
         symbol_list_t assignment_list;
 
         parser_.dec().assignment_symbols(assignment_list);
 
         printf("---- Assignments ----\n");
         perform_symbol_dump(assignment_list);
         printf("---------------------\n");
      }
   }

References assignment_dump_, batch_runs_cnt_, exprtk::parser_error::type::column_no, exprtk::results_context< T >::count(), exprtk::parser_error::type::diagnostic, disable_local_vardef_, display_total_compile_time_, display_total_time_, enable_usr_, exprtk::parser_error::type::error_line, function_symbol_table_, exprtk::parser_error::type::line_no, exprtk::parser_error::type::mode, parser_, perform_symbol_dump(), exprtk::lexer::token::position, print_results(), exprtk::expression< T >::register_symbol_table(), exprtk::expression< T >::results(), setup_symbol_table(), exprtk::timer::start(), exprtk::timer::stop(), symbol_dump_, symbol_table_, exprtk::timer::time(), exprtk::parser_error::to_str(), exprtk::parser_error::type::token, trim_whitespace(), exprtk::parser_error::update_error(), and exprtk::expression< T >::value().

Referenced by process_function_definition(), process_multiline(), and repl().

Here is the call graph for this function:

Here is the caller graph for this function:

process() [2/2]

template<typename T>

void expression_processor< T >::process ( std::string program )

inline

Definition at line 248 of file exprtk_repl.cpp.

   {
      program = trim_whitespace(program);
 
      if (program.empty())
         return;
 
      setup_symbol_table();
 
      expression_t expression;
      expression.register_symbol_table(symbol_table_);
      expression.register_symbol_table(function_symbol_table_);
 
      exprtk::timer compile_timer;
      compile_timer.start();
 
      if (enable_usr_)
         parser_.enable_unknown_symbol_resolver();
      else
         parser_.disable_unknown_symbol_resolver();
 
      if (disable_local_vardef_)
         parser_.settings().disable_local_vardef();
      else
         parser_.settings().enable_local_vardef();
 
      if (disable_commutative_check_)
         parser_.settings().disable_commutative_check();
      else
         parser_.settings().enable_commutative_check();
 
      parser_.dec().collect_variables() = symbol_dump_;
      parser_.dec().collect_functions() = symbol_dump_;
 
      parser_.dec().collect_assignments() = assignment_dump_;
 
      parser_.register_vector_access_runtime_check(vector_access_rtc_);
 
      if (!parser_.compile(program,expression))
      {
         printf("Error: %s\tExpression:%c%s\n",
                parser_.error().c_str(),
                ((std::string::npos != program.find_first_of('\n')) ? '\n' : ' '),
                ((program.size() < 200) ? program.c_str() : "....."));
 
         for (std::size_t i = 0; i < parser_.error_count(); ++i)
         {
            error_t error = parser_.get_error(i);
 
            printf("Err No.: %02d  Pos: %02d  Type: [%14s] Msg: %s\n",
                   static_cast<unsigned int>(i),
                   static_cast<unsigned int>(error.token.position),
                   exprtk::parser_error::to_str(error.mode).c_str(),
                   error.diagnostic.c_str());
 
            if (
                 (0 == i) &&
                 exprtk::parser_error::update_error(error,program)
               )
            {
               printf("Error (line: %d column: %d)\n",
                      static_cast<unsigned int>(error.line_no),
                      static_cast<unsigned int>(error.column_no));
 
               printf("%s \n",error.error_line.c_str());
               printf("%s^\n",std::string(error.column_no,'~').c_str());
            }
         }
 
         return;
      }
 
      compile_timer.stop();
 
      if (display_total_compile_time_)
      {
         printf("\nCompile time: %6.3fms\n",compile_timer.time() * 1000.0);
      }
 
      if (batch_runs_cnt_)
      {
         std::vector<double> timings(batch_runs_cnt_,0.0);
 
         exprtk::timer total_timer;
         exprtk::timer timer;
 
         T result = T(0);
 
         total_timer.start();
 
         for (std::size_t i = 0; i < batch_runs_cnt_; ++i)
         {
            timer.start();
 
            result = expression.value();
 
            timer.stop();
 
            timings[i] = timer.time() * 1000.0;
         }
 
         total_timer.stop();
 
         printf("\nResult: %15.9f\n",result);
 
         std::sort(timings.begin(),timings.end());
 
         printf("\nRuns: %4d  Time min: %7.3fms   max: %7.3fms   avg: %7.3fms   tot: %7.3fms   90%%:%7.3fms\n",
                static_cast<unsigned int>(batch_runs_cnt_),
                timings.front(),
                timings.back (),
                std::accumulate(timings.begin(),timings.end(),0.0) / timings.size(),
                total_timer.time() * 1000.0,
                timings[static_cast<int>(timings.size() * 0.90)]);
 
         return;
      }
 
      exprtk::timer timer;
      timer.start();
 
      const T result = expression.value();
 
      timer.stop();
 
      if (expression.results().count())
      {
         print_results(expression.results());
      }
 
      printf("\nResult: %15.9f\n",result);
 
      if (display_total_time_)
      {
         printf("\nTotal time: %6.3fms\n",timer.time() * 1000.0);
      }
 
      if (symbol_dump_)
      {
         symbol_list_t symbol_list;
 
         parser_.dec().symbols(symbol_list);
 
         printf("------ Symbols ------\n");
         perform_symbol_dump(symbol_list);
         printf("---------------------\n");
      }
 
      if (assignment_dump_)
      {
         symbol_list_t assignment_list;
 
         parser_.dec().assignment_symbols(assignment_list);
 
         printf("---- Assignments ----\n");
         perform_symbol_dump(assignment_list);
         printf("---------------------\n");
      }
   }

References assignment_dump_, batch_runs_cnt_, exprtk::parser_error::type::column_no, exprtk::results_context< T >::count(), exprtk::parser_error::type::diagnostic, disable_commutative_check_, disable_local_vardef_, display_total_compile_time_, display_total_time_, enable_usr_, exprtk::parser_error::type::error_line, function_symbol_table_, exprtk::parser_error::type::line_no, exprtk::parser_error::type::mode, parser_, perform_symbol_dump(), exprtk::lexer::token::position, print_results(), exprtk::expression< T >::register_symbol_table(), exprtk::expression< T >::results(), setup_symbol_table(), exprtk::timer::start(), exprtk::timer::stop(), symbol_dump_, symbol_table_, exprtk::timer::time(), exprtk::parser_error::to_str(), exprtk::parser_error::type::token, trim_whitespace(), exprtk::parser_error::update_error(), exprtk::expression< T >::value(), and vector_access_rtc_.

Here is the call graph for this function:

process_batch_run() [1/2]

template<typename T>

void expression_processor< T >::process_batch_run ( const std::string & batch_runs_cnt )

inlineprivate

Definition at line 564 of file exprtk_mpfr_repl.cpp.

   {
      batch_runs_cnt_ = atoi(batch_runs_cnt.c_str());
   }

References batch_runs_cnt_.

Referenced by process_directive().

Here is the caller graph for this function:

process_batch_run() [2/2]

template<typename T>

void expression_processor< T >::process_batch_run ( const std::string & batch_runs_cnt )

inlineprivate

Definition at line 593 of file exprtk_repl.cpp.

   {
      batch_runs_cnt_ = atoi(batch_runs_cnt.c_str());
   }

References batch_runs_cnt_.

process_directive() [1/2]

template<typename T>

void expression_processor< T >::process_directive ( std::string expression )

inline

Definition at line 402 of file exprtk_mpfr_repl.cpp.

   {
      expression = trim_whitespace(expression);
 
      if ('$' != expression[0])
         return;
      else if ("$enable_cache" == expression)
         persist_symbol_table() = true;
      else if ("$disable_cache" == expression)
         persist_symbol_table() = false;
      else if ("$enable_symbol_dump" == expression)
         symbol_dump() = true;
      else if ("$disable_symbol_dump" == expression)
         symbol_dump() = false;
      else if ("$enable_assignment_dump" == expression)
         assignment_dump() = true;
      else if ("$disable_assignment_dump" == expression)
         assignment_dump() = false;
      else if ("$enable_timer" == expression)
         display_total_time() = true;
      else if ("$enable_compile_timer" == expression)
         display_total_compile_time() = true;
      else if ("$disable_timer" == expression)
         display_total_time() = false;
      else if ("$disable_compile_timer" == expression)
         display_total_compile_time() = false;
      else if ("$enable_usr" == expression)
         enable_usr() = true;
      else if ("$disable_usr" == expression)
         enable_usr() = false;
      else if ("$enable_local_vardef" == expression)
         disable_local_vardef() = false;
      else if ("$disable_local_vardef" == expression)
         disable_local_vardef() = true;
      else if ("$list_vars" == expression)
         list_symbols();
      else if ("$clear_functions" == expression)
         clear_functions();
      else if ((0 == expression.find("$set_mpfr_prec ")) && (expression.size() > 15))
         mpfr::mpreal::set_default_prec(atoi(expression.substr(14,expression.size() - 14).c_str()));
      else if ((0 == expression.find("$batch_run ")) && (expression.size() > 12))
         process_batch_run(expression.substr(11,expression.size() - 11));
      else if ((0 == expression.find("$load ")) && (expression.size() > 7))
         process_from_file(expression.substr(6,expression.size() - 6));
      else if ((0 == expression.find("$disable arithmetic ")) && (expression.size() >= 21))
         process_disable_arithmetic(expression.substr(20,expression.size() - 20));
      else if ((0 == expression.find("$disable assignment ")) && (expression.size() >= 21))
         process_disable_assignment(expression.substr(20,expression.size() - 20));
      else if ((0 == expression.find("$disable inequality ")) && (expression.size() >= 21))
         process_disable_inequality(expression.substr(20,expression.size() - 20));
      else if ((0 == expression.find("$enable arithmetic ")) && (expression.size() >= 20))
         process_enable_arithmetic(expression.substr(19,expression.size() - 19));
      else if ((0 == expression.find("$enable assignment ")) && (expression.size() >= 20))
         process_enable_assignment(expression.substr(19,expression.size() - 19));
      else if ((0 == expression.find("$enable inequality ")) && (expression.size() >= 20))
         process_enable_inequality(expression.substr(19,expression.size() - 19));
      else if ("$begin" == expression)
         process_multiline();
      else if (0 == expression.find("$function"))
         process_function_definition(expression);
      else
         printf("\nERROR - Invalid directive: %s\n",expression.c_str());
   }

References assignment_dump(), clear_functions(), disable_local_vardef(), display_total_compile_time(), display_total_time(), enable_usr(), list_symbols(), persist_symbol_table(), process_batch_run(), process_disable_arithmetic(), process_disable_assignment(), process_disable_inequality(), process_enable_arithmetic(), process_enable_assignment(), process_enable_inequality(), process_from_file(), process_function_definition(), process_multiline(), symbol_dump(), and trim_whitespace().

Referenced by repl().

Here is the call graph for this function:

Here is the caller graph for this function:

process_directive() [2/2]

template<typename T>

void expression_processor< T >::process_directive ( std::string expression )

inline

Definition at line 429 of file exprtk_repl.cpp.

   {
      expression = trim_whitespace(expression);
 
      if ('$' != expression[0])
         return;
      else if ("$enable_cache" == expression)
         persist_symbol_table() = true;
      else if ("$disable_cache" == expression)
         persist_symbol_table() = false;
      else if ("$enable_symbol_dump" == expression)
         symbol_dump() = true;
      else if ("$disable_symbol_dump" == expression)
         symbol_dump() = false;
      else if ("$enable_assignment_dump" == expression)
         assignment_dump() = true;
      else if ("$disable_assignment_dump" == expression)
         assignment_dump() = false;
      else if ("$enable_timer" == expression)
         display_total_time() = true;
      else if ("$enable_compile_timer" == expression)
         display_total_compile_time() = true;
      else if ("$disable_timer" == expression)
         display_total_time() = false;
      else if ("$disable_compile_timer" == expression)
         display_total_compile_time() = false;
      else if ("$enable_usr" == expression)
         enable_usr() = true;
      else if ("$disable_usr" == expression)
         enable_usr() = false;
      else if ("$enable_local_vardef" == expression)
         disable_local_vardef() = false;
      else if ("$disable_local_vardef" == expression)
         disable_local_vardef() = true;
      else if ("$enable_commutative_check" == expression)
         disable_commutative_check() = false;
      else if ("$disable_commutative_check" == expression)
         disable_commutative_check() = true;
      else if ("$list_vars" == expression)
         list_symbols();
      else if ("$clear_functions" == expression)
         clear_functions();
      else if ((0 == expression.find("$batch_run ")) && (expression.size() >= 12))
         process_batch_run(expression.substr(11,expression.size() - 11));
      else if ((0 == expression.find("$load ")) && (expression.size() > 7))
         process_from_file(expression.substr(6,expression.size() - 6));
      else if ((0 == expression.find("$disable arithmetic ")) && (expression.size() >= 21))
         process_disable_arithmetic(expression.substr(20,expression.size() - 20));
      else if ((0 == expression.find("$disable assignment ")) && (expression.size() >= 21))
         process_disable_assignment(expression.substr(20,expression.size() - 20));
      else if ((0 == expression.find("$disable inequality ")) && (expression.size() >= 21))
         process_disable_inequality(expression.substr(20,expression.size() - 20));
      else if ((0 == expression.find("$enable arithmetic ")) && (expression.size() >= 20))
         process_enable_arithmetic(expression.substr(19,expression.size() - 19));
      else if ((0 == expression.find("$enable assignment ")) && (expression.size() >= 20))
         process_enable_assignment(expression.substr(19,expression.size() - 19));
      else if ((0 == expression.find("$enable inequality ")) && (expression.size() >= 20))
         process_enable_inequality(expression.substr(19,expression.size() - 19));
      else if ("$begin" == expression)
         process_multiline();
      else if (0 == expression.find("$function"))
         process_function_definition(expression);
      else
         printf("\nERROR - Invalid directive: %s\n",expression.c_str());
   }

References assignment_dump(), clear_functions(), disable_commutative_check(), disable_local_vardef(), display_total_compile_time(), display_total_time(), enable_usr(), list_symbols(), persist_symbol_table(), process_batch_run(), process_disable_arithmetic(), process_disable_assignment(), process_disable_inequality(), process_enable_arithmetic(), process_enable_assignment(), process_enable_inequality(), process_from_file(), process_function_definition(), process_multiline(), symbol_dump(), and trim_whitespace().

Here is the call graph for this function:

process_disable_arithmetic() [1/2]

template<typename T>

void expression_processor< T >::process_disable_arithmetic ( const std::string & arithmetic )

inlineprivate

Definition at line 876 of file exprtk_mpfr_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;
 
      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .disable_arithmetic_operation(itr->second);
      }
   }

References arith_opr_, and parser_.

Referenced by process_directive().

Here is the caller graph for this function:

process_disable_arithmetic() [2/2]

template<typename T>

void expression_processor< T >::process_disable_arithmetic ( const std::string & arithmetic )

inlineprivate

Definition at line 905 of file exprtk_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;
 
      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .disable_arithmetic_operation(itr->second);
      }
   }

References arith_opr_, and parser_.

process_disable_assignment() [1/2]

template<typename T>

void expression_processor< T >::process_disable_assignment ( const std::string & assignment )

inlineprivate

Definition at line 887 of file exprtk_mpfr_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;
 
      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .disable_assignment_operation(itr->second);
      }
   }

References assign_opr_, and parser_.

Referenced by process_directive().

Here is the caller graph for this function:

process_disable_assignment() [2/2]

template<typename T>

void expression_processor< T >::process_disable_assignment ( const std::string & assignment )

inlineprivate

Definition at line 916 of file exprtk_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;
 
      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .disable_assignment_operation(itr->second);
      }
   }

References assign_opr_, and parser_.

process_disable_inequality() [1/2]

template<typename T>

void expression_processor< T >::process_disable_inequality ( const std::string & inequality )

inlineprivate

Definition at line 898 of file exprtk_mpfr_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;
 
      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .disable_inequality_operation(itr->second);
      }
   }

References inequality_opr_, and parser_.

Referenced by process_directive().

Here is the caller graph for this function:

process_disable_inequality() [2/2]

template<typename T>

void expression_processor< T >::process_disable_inequality ( const std::string & inequality )

inlineprivate

Definition at line 927 of file exprtk_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;
 
      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .disable_inequality_operation(itr->second);
      }
   }

References inequality_opr_, and parser_.

process_enable_arithmetic() [1/2]

template<typename T>

void expression_processor< T >::process_enable_arithmetic ( const std::string & arithmetic )

inlineprivate

Definition at line 909 of file exprtk_mpfr_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;
 
      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .enable_arithmetic_operation(itr->second);
      }
   }

References arith_opr_, and parser_.

Referenced by process_directive().

Here is the caller graph for this function:

process_enable_arithmetic() [2/2]

template<typename T>

void expression_processor< T >::process_enable_arithmetic ( const std::string & arithmetic )

inlineprivate

Definition at line 938 of file exprtk_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;
 
      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .enable_arithmetic_operation(itr->second);
      }
   }

References arith_opr_, and parser_.

process_enable_assignment() [1/2]

template<typename T>

void expression_processor< T >::process_enable_assignment ( const std::string & assignment )

inlineprivate

Definition at line 920 of file exprtk_mpfr_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;
 
      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .enable_assignment_operation(itr->second);
      }
   }

References assign_opr_, and parser_.

Referenced by process_directive().

Here is the caller graph for this function:

process_enable_assignment() [2/2]

template<typename T>

void expression_processor< T >::process_enable_assignment ( const std::string & assignment )

inlineprivate

Definition at line 949 of file exprtk_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;
 
      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .enable_assignment_operation(itr->second);
      }
   }

References assign_opr_, and parser_.

process_enable_inequality() [1/2]

template<typename T>

void expression_processor< T >::process_enable_inequality ( const std::string & inequality )

inlineprivate

Definition at line 931 of file exprtk_mpfr_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;
 
      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .enable_inequality_operation(itr->second);
      }
   }

References inequality_opr_, and parser_.

Referenced by process_directive().

Here is the caller graph for this function:

process_enable_inequality() [2/2]

template<typename T>

void expression_processor< T >::process_enable_inequality ( const std::string & inequality )

inlineprivate

Definition at line 960 of file exprtk_repl.cpp.

   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;
 
      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .enable_inequality_operation(itr->second);
      }
   }

References inequality_opr_, and parser_.

process_from_file() [1/2]

template<typename T>

void expression_processor< T >::process_from_file ( const std::string & file_name )

inline

Definition at line 381 of file exprtk_mpfr_repl.cpp.

   {
      if (file_name.empty())
         return;
 
      std::ifstream stream(file_name.c_str());
 
      if (!stream)
      {
         printf("ERROR: Failed to open file: %s\n\n",file_name.c_str());
         return;
      }
 
      std::string program(
                           (std::istreambuf_iterator<char>(stream)),
                           (std::istreambuf_iterator<char>())
                         );
 
      process_function_definition(program,false);
   }

References process_function_definition().

Referenced by process_directive(), and repl().

Here is the call graph for this function:

Here is the caller graph for this function:

process_from_file() [2/2]

template<typename T>

void expression_processor< T >::process_from_file ( const std::string & file_name )

inline

Definition at line 408 of file exprtk_repl.cpp.

   {
      if (file_name.empty())
         return;
 
      std::ifstream stream(file_name.c_str());
 
      if (!stream)
      {
         printf("ERROR: Failed to open file: %s\n\n",file_name.c_str());
         return;
      }
 
      std::string program(
                           (std::istreambuf_iterator<char>(stream)),
                           (std::istreambuf_iterator<char>())
                         );
 
      process_function_definition(program,false);
   }

References process_function_definition().

Here is the call graph for this function:

process_function_definition() [1/2]

template<typename T>

void expression_processor< T >::process_function_definition ( const std::string & func_def_header, bool read_stdin = true )

inlineprivate

Definition at line 734 of file exprtk_mpfr_repl.cpp.

   {
      std::string func_def = func_def_header;
 
      if (read_stdin)
      {
         func_def += read_from_stdin();
 
         if (!func_def.empty() && ('$' == func_def[0]))
            func_def.erase(func_def.begin());
      }
 
      do
      {
         function_definition fd;
 
         func_parse_result fp_result = parse_function_definition(func_def,fd);
 
         if (e_parse_success == fp_result)
         {
            std::string vars;
 
            for (std::size_t i = 0; i < fd.var_list.size(); ++i)
            {
               vars += fd.var_list[i] + ((i < fd.var_list.size() - 1) ? "," : "");
            }
 
            function_t f(fd.name);
 
            for (std::size_t i = 0; i < fd.var_list.size(); ++i)
            {
               f.var(fd.var_list[i]);
            }
 
            f.expression(fd.body);
 
            if (function_symbol_table_.get_function(fd.name))
            {
               function_symbol_table_.remove_function(fd.name);
 
               for (std::size_t i = 0; i < func_def_list_.size(); ++i)
               {
                  if (exprtk::details::imatch(fd.name, func_def_list_[i].name))
                  {
                     func_def_list_.erase(func_def_list_.begin() + i);
 
                     break;
                  }
               }
            }
 
            if (!compositor_.add(f,true))
            {
               function_symbol_table_.remove_function(fd.name);
 
               printf("Error - Failed to add function: %s\n",fd.name.c_str());
 
               return;
            }
 
            printf("Function[%02d]\n",static_cast<int>(func_def_list_.size()));
            printf("Name: %s      \n",fd.name.c_str()                        );
            printf("Vars: (%s)    \n",vars.c_str()                           );
            printf("------------------------------------------------------\n");
 
            func_def_list_.push_back(fd);
         }
         else if (e_parse_notfunc != fp_result)
         {
            printf("Error - Critical parsing error - partial parse occured\n");
            return;
         }
         else
            break;
      }
      while (!func_def.empty());
 
      if (!func_def.empty())
      {
         process(func_def);
      }
   }

References expression_processor< T >::function_definition::body, compositor_, e_parse_notfunc, e_parse_success, exprtk::function_compositor< T >::function::expression(), func_def_list_, function_symbol_table_, exprtk::details::imatch(), expression_processor< T >::function_definition::name, parse_function_definition(), process(), read_from_stdin(), exprtk::function_compositor< T >::function::var(), and expression_processor< T >::function_definition::var_list.

Referenced by process_directive(), and process_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

process_function_definition() [2/2]

template<typename T>

void expression_processor< T >::process_function_definition ( const std::string & func_def_header, bool read_stdin = true )

inlineprivate

Definition at line 763 of file exprtk_repl.cpp.

   {
      std::string func_def = func_def_header;
 
      if (read_stdin)
      {
         func_def += read_from_stdin();
 
         if (!func_def.empty() && ('$' == func_def[0]))
            func_def.erase(func_def.begin());
      }
 
      do
      {
         function_definition fd;
 
         func_parse_result fp_result = parse_function_definition(func_def,fd);
 
         if (e_parse_success == fp_result)
         {
            std::string vars;
 
            for (std::size_t i = 0; i < fd.var_list.size(); ++i)
            {
               vars += fd.var_list[i] + ((i < fd.var_list.size() - 1) ? "," : "");
            }
 
            function_t f(fd.name);
 
            for (std::size_t i = 0; i < fd.var_list.size(); ++i)
            {
               f.var(fd.var_list[i]);
            }
 
            f.expression(fd.body);
 
            if (function_symbol_table_.get_function(fd.name))
            {
               function_symbol_table_.remove_function(fd.name);
 
               for (std::size_t i = 0; i < func_def_list_.size(); ++i)
               {
                  if (exprtk::details::imatch(fd.name, func_def_list_[i].name))
                  {
                     func_def_list_.erase(func_def_list_.begin() + i);
 
                     break;
                  }
               }
            }
 
            if (!compositor_.add(f,true))
            {
               function_symbol_table_.remove_function(fd.name);
 
               printf("Error - Failed to add function: %s\n",fd.name.c_str());
 
               return;
            }
 
            printf("Function[%02d]\n",static_cast<int>(func_def_list_.size()));
            printf("Name: %s      \n",fd.name.c_str()                        );
            printf("Vars: (%s)    \n",vars.c_str()                           );
            printf("------------------------------------------------------\n");
 
            func_def_list_.push_back(fd);
         }
         else if (e_parse_notfunc != fp_result)
         {
            printf("Error - Critical parsing error - partial parse occurred\n");
            return;
         }
         else
            break;
      }
      while (!func_def.empty());
 
      if (!func_def.empty())
      {
         process(func_def);
      }
   }

References compositor_, e_parse_notfunc, e_parse_success, exprtk::function_compositor< T >::function::expression(), func_def_list_, function_symbol_table_, exprtk::details::imatch(), parse_function_definition(), process(), read_from_stdin(), and exprtk::function_compositor< T >::function::var().

Here is the call graph for this function:

process_multiline() [1/2]

template<typename T>

void expression_processor< T >::process_multiline ( )

inlineprivate

Definition at line 569 of file exprtk_mpfr_repl.cpp.

   {
      std::string program;
 
      for ( ; ; )
      {
         std::string line;
 
         std::cout << ">> ";
         std::getline(std::cin,line);
 
         line = trim_whitespace(line);
 
         if (line.empty())
            continue;
         else if ("$end" == line)
            break;
         else
            program += (line + "\n");
      }
 
      process(program);
   }

References process(), and trim_whitespace().

Referenced by process_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

process_multiline() [2/2]

template<typename T>

void expression_processor< T >::process_multiline ( )

inlineprivate

Definition at line 598 of file exprtk_repl.cpp.

   {
      std::string program;
 
      for ( ; ; )
      {
         std::string line;
 
         std::cout << ">> ";
         std::getline(std::cin,line);
 
         line = trim_whitespace(line);
 
         if (line.empty())
            continue;
         else if ("$end" == line)
            break;
         else
            program += (line + "\n");
      }
 
      process(program);
   }

References process(), and trim_whitespace().

Here is the call graph for this function:

read_from_stdin() [1/2]

template<typename T>

std::string expression_processor< T >::read_from_stdin ( )

inlineprivate

Definition at line 709 of file exprtk_mpfr_repl.cpp.

   {
      std::string input;
 
      for ( ; ; )
      {
         std::string line;
 
         std::cout << ">> ";
         std::getline(std::cin,line);
 
         if (line.empty())
            continue;
         else if ("$end" == line)
            break;
         else
            input += (line + "\n");
      }
 
      if (!input.empty())
         input.erase(input.end() - 1);
 
      return input;
   }

Referenced by process_function_definition().

Here is the caller graph for this function:

read_from_stdin() [2/2]

template<typename T>

std::string expression_processor< T >::read_from_stdin ( )

inlineprivate

Definition at line 738 of file exprtk_repl.cpp.

   {
      std::string input;
 
      for ( ; ; )
      {
         std::string line;
 
         std::cout << ">> ";
         std::getline(std::cin,line);
 
         if (line.empty())
            continue;
         else if ("$end" == line)
            break;
         else
            input += (line + "\n");
      }
 
      if (!input.empty())
         input.erase(input.end() - 1);
 
      return input;
   }

setup_symbol_table() [1/2]

template<typename T>

void expression_processor< T >::setup_symbol_table ( )

inline

Definition at line 218 of file exprtk_mpfr_repl.cpp.

   {
      if (!persist_symbol_table_)
      {
         symbol_table_.clear_variables();
         symbol_table_.add_constants();
         symbol_table_.add_constant ("e",exprtk::details::numeric::constant::e);
      }
   }

References exprtk::details::numeric::constant::e, persist_symbol_table_, and symbol_table_.

Referenced by process().

Here is the caller graph for this function:

setup_symbol_table() [2/2]

template<typename T>

void expression_processor< T >::setup_symbol_table ( )

inline

Definition at line 238 of file exprtk_repl.cpp.

   {
      if (!persist_symbol_table_)
      {
         symbol_table_.clear_variables();
         symbol_table_.add_constants  ();
         symbol_table_.add_constant ("e", exprtk::details::numeric::constant::e);
      }
   }

References exprtk::details::numeric::constant::e, persist_symbol_table_, and symbol_table_.

symbol_dump() [1/2]

template<typename T>

bool & expression_processor< T >::symbol_dump ( )

inline

Definition at line 188 of file exprtk_mpfr_repl.cpp.

   {
      return symbol_dump_;
   }

References symbol_dump_.

Referenced by process_directive().

Here is the caller graph for this function:

symbol_dump() [2/2]

template<typename T>

bool & expression_processor< T >::symbol_dump ( )

inline

Definition at line 203 of file exprtk_repl.cpp.

   {
      return symbol_dump_;
   }

References symbol_dump_.

trim_whitespace() [1/2]

template<typename T>

std::string expression_processor< T >::trim_whitespace ( std::string s )

inlineprivate

Definition at line 854 of file exprtk_mpfr_repl.cpp.

   {
      static const std::string whitespace(" \n\r\t\b\v\f");
 
      if (!s.empty())
      {
         s.erase(0,s.find_first_not_of(whitespace));
 
         if (!s.empty())
         {
            std::size_t index = s.find_last_not_of(whitespace);
 
            if (std::string::npos != index)
               s.erase(index + 1);
            else
               s.clear();
         }
      }
 
      return s;
   }

Referenced by process(), process_directive(), and process_multiline().

Here is the caller graph for this function:

trim_whitespace() [2/2]

template<typename T>

std::string expression_processor< T >::trim_whitespace ( std::string s )

inlineprivate

Definition at line 883 of file exprtk_repl.cpp.

   {
      static const std::string whitespace(" \n\r\t\b\v\f");
 
      if (!s.empty())
      {
         s.erase(0,s.find_first_not_of(whitespace));
 
         if (!s.empty())
         {
            std::size_t index = s.find_last_not_of(whitespace);
 
            if (std::string::npos != index)
               s.erase(index + 1);
            else
               s.clear();
         }
      }
 
      return s;
   }

Member Data Documentation

arith_opr_

template<typename T>

std::map< std::string, typename settings_store_t::settings_arithmetic_opr > expression_processor< T >::arith_opr_

private

Definition at line 981 of file exprtk_mpfr_repl.cpp.

Referenced by process_disable_arithmetic(), and process_enable_arithmetic().

assign_opr_

template<typename T>

std::map< std::string, typename settings_store_t::settings_assignment_opr > expression_processor< T >::assign_opr_

private

Definition at line 982 of file exprtk_mpfr_repl.cpp.

Referenced by process_disable_assignment(), and process_enable_assignment().

assignment_dump_

template<typename T>

bool expression_processor< T >::assignment_dump_

private

Definition at line 947 of file exprtk_mpfr_repl.cpp.

Referenced by assignment_dump(), expression_processor(), and process().

batch_runs_cnt_

template<typename T>

std::size_t expression_processor< T >::batch_runs_cnt_

private

Definition at line 952 of file exprtk_mpfr_repl.cpp.

Referenced by expression_processor(), process(), and process_batch_run().

compositor_

template<typename T>

compositor_t expression_processor< T >::compositor_

private

Definition at line 957 of file exprtk_mpfr_repl.cpp.

Referenced by expression_processor(), and process_function_definition().

disable_commutative_check_

template<typename T>

bool expression_processor< T >::disable_commutative_check_

private

Definition at line 981 of file exprtk_repl.cpp.

Referenced by disable_commutative_check(), expression_processor(), and process().

disable_local_vardef_

template<typename T>

bool expression_processor< T >::disable_local_vardef_

private

Definition at line 951 of file exprtk_mpfr_repl.cpp.

Referenced by disable_local_vardef(), expression_processor(), and process().

display_total_compile_time_

template<typename T>

bool expression_processor< T >::display_total_compile_time_

private

Definition at line 949 of file exprtk_mpfr_repl.cpp.

Referenced by display_total_compile_time(), expression_processor(), and process().

display_total_time_

template<typename T>

bool expression_processor< T >::display_total_time_

private

Definition at line 948 of file exprtk_mpfr_repl.cpp.

Referenced by display_total_time(), expression_processor(), and process().

enable_usr_

template<typename T>

bool expression_processor< T >::enable_usr_

private

Definition at line 950 of file exprtk_mpfr_repl.cpp.

Referenced by enable_usr(), expression_processor(), and process().

fileio_package_

template<typename T>

exprtk::rtl::io::file::package< T > expression_processor< T >::fileio_package_

private

Definition at line 962 of file exprtk_mpfr_repl.cpp.

func_def_list_

template<typename T>

std::vector< function_definition > expression_processor< T >::func_def_list_

private

Definition at line 979 of file exprtk_mpfr_repl.cpp.

Referenced by clear_functions(), and process_function_definition().

function_symbol_table_

template<typename T>

symbol_table_t expression_processor< T >::function_symbol_table_

private

Definition at line 955 of file exprtk_mpfr_repl.cpp.

Referenced by clear_functions(), expression_processor(), process(), and process_function_definition().

inequality_opr_

template<typename T>

std::map< std::string, typename settings_store_t::settings_inequality_opr > expression_processor< T >::inequality_opr_

private

Definition at line 983 of file exprtk_mpfr_repl.cpp.

Referenced by process_disable_inequality(), and process_enable_inequality().

io_package_

template<typename T>

exprtk::rtl::io::package< T > expression_processor< T >::io_package_

private

Definition at line 964 of file exprtk_mpfr_repl.cpp.

parser_

template<typename T>

parser_t expression_processor< T >::parser_

private

Definition at line 956 of file exprtk_mpfr_repl.cpp.

Referenced by process(), process_disable_arithmetic(), process_disable_assignment(), process_disable_inequality(), process_enable_arithmetic(), process_enable_assignment(), and process_enable_inequality().

persist_symbol_table_

template<typename T>

bool expression_processor< T >::persist_symbol_table_

private

Definition at line 945 of file exprtk_mpfr_repl.cpp.

Referenced by expression_processor(), persist_symbol_table(), and setup_symbol_table().

poly01_

template<typename T>

exprtk::polynomial< T, 1 > expression_processor< T >::poly01_

private

Definition at line 966 of file exprtk_mpfr_repl.cpp.

poly02_

template<typename T>

exprtk::polynomial< T, 2 > expression_processor< T >::poly02_

private

Definition at line 967 of file exprtk_mpfr_repl.cpp.

poly03_

template<typename T>

exprtk::polynomial< T, 3 > expression_processor< T >::poly03_

private

Definition at line 968 of file exprtk_mpfr_repl.cpp.

poly04_

template<typename T>

exprtk::polynomial< T, 4 > expression_processor< T >::poly04_

private

Definition at line 969 of file exprtk_mpfr_repl.cpp.

poly05_

template<typename T>

exprtk::polynomial< T, 5 > expression_processor< T >::poly05_

private

Definition at line 970 of file exprtk_mpfr_repl.cpp.

poly06_

template<typename T>

exprtk::polynomial< T, 6 > expression_processor< T >::poly06_

private

Definition at line 971 of file exprtk_mpfr_repl.cpp.

poly07_

template<typename T>

exprtk::polynomial< T, 7 > expression_processor< T >::poly07_

private

Definition at line 972 of file exprtk_mpfr_repl.cpp.

poly08_

template<typename T>

exprtk::polynomial< T, 8 > expression_processor< T >::poly08_

private

Definition at line 973 of file exprtk_mpfr_repl.cpp.

poly09_

template<typename T>

exprtk::polynomial< T, 9 > expression_processor< T >::poly09_

private

Definition at line 974 of file exprtk_mpfr_repl.cpp.

poly10_

template<typename T>

exprtk::polynomial< T, 10 > expression_processor< T >::poly10_

private

Definition at line 975 of file exprtk_mpfr_repl.cpp.

poly11_

template<typename T>

exprtk::polynomial< T, 11 > expression_processor< T >::poly11_

private

Definition at line 976 of file exprtk_mpfr_repl.cpp.

poly12_

template<typename T>

exprtk::polynomial< T, 12 > expression_processor< T >::poly12_

private

Definition at line 977 of file exprtk_mpfr_repl.cpp.

putch_

template<typename T>

putch< T > expression_processor< T >::putch_

private

Definition at line 959 of file exprtk_mpfr_repl.cpp.

putint_

template<typename T>

putint< T > expression_processor< T >::putint_

private

Definition at line 960 of file exprtk_mpfr_repl.cpp.

rnd_01_

template<typename T>

rnd_01< T > expression_processor< T >::rnd_01_

private

Definition at line 961 of file exprtk_mpfr_repl.cpp.

symbol_dump_

template<typename T>

bool expression_processor< T >::symbol_dump_

private

Definition at line 946 of file exprtk_mpfr_repl.cpp.

Referenced by expression_processor(), process(), and symbol_dump().

symbol_table_

template<typename T>

symbol_table_t expression_processor< T >::symbol_table_

private

Definition at line 954 of file exprtk_mpfr_repl.cpp.

Referenced by list_symbols(), process(), and setup_symbol_table().

vecops_package_

template<typename T>

exprtk::rtl::vecops::package< T > expression_processor< T >::vecops_package_

private

Definition at line 963 of file exprtk_mpfr_repl.cpp.

vector_access_rtc_

template<typename T>

vector_access_rtc expression_processor< T >::vector_access_rtc_

private

Definition at line 988 of file exprtk_repl.cpp.

Referenced by process().

---

The documentation for this class was generated from the following files:

• exprtk/exprtk_mpfr_repl.cpp
• exprtk/exprtk_repl.cpp