#include <exprtk.hpp>

Classes
struct	function
struct	base_func
struct	scoped_bft
struct	func_0param
struct	func_1param
struct	func_2param
struct	func_3param
struct	func_4param
struct	func_5param
struct	func_6param
struct	func_0param_retval
struct	func_1param_retval
struct	func_2param_retval
struct	func_3param_retval
struct	func_4param_retval
struct	func_5param_retval
struct	func_6param_retval

Public Types
typedef exprtk::expression< T >	expression_t
typedef exprtk::symbol_table< T >	symbol_table_t
typedef exprtk::parser< T >	parser_t
typedef parser_t::settings_store	settings_t

Public Member Functions
	function_compositor ()
	function_compositor (const symbol_table_t &st)
	~function_compositor ()
symbol_table_t &	symbol_table ()
const symbol_table_t &	symbol_table () const
void	add_auxiliary_symtab (symbol_table_t &symtab)
void	load_variables (const bool load=true)
void	load_vectors (const bool load=true)
void	register_loop_runtime_check (loop_runtime_check &lrtchk)
void	register_vector_access_runtime_check (vector_access_runtime_check &vartchk)
void	register_compilation_timeout_check (compilation_check &compchk)
void	clear_loop_runtime_check ()
void	clear_vector_access_runtime_check ()
void	clear_compilation_timeout_check ()
void	clear ()
bool	add (const function &f, const bool override=false)
std::string	error () const
std::size_t	error_count () const
parser_error::type	get_error (const std::size_t &index) const

Private Types
typedef std::map< std::string, base_func * >	funcparam_t
typedef const T &	type

Private Member Functions
template<typename Allocator, template< typename, typename > class Sequence>
bool	add (const std::string &name, const std::string &expression, const Sequence< std::string, Allocator > &var_list, const bool override=false)
template<typename Allocator, template< typename, typename > class Sequence>
bool	compile_expression (const std::string &name, const std::string &expression, const Sequence< std::string, Allocator > &input_var_list, bool return_present=false)
bool	symbol_used (const std::string &symbol) const
bool	valid (const std::string &name, const std::size_t &arg_count) const
bool	forward (const std::string &name, const std::size_t &arg_count, symbol_table_t &sym_table, const bool ret_present=false)
void	remove (const std::string &name, const std::size_t &arg_count)

Static Private Member Functions
static T	return_value (expression_t &e)

Private Attributes
symbol_table_t	symbol_table_
parser_t	parser_
std::map< std::string, expression_t >	expr_map_
std::vector< funcparam_t >	fp_map_
std::vector< symbol_table_t * >	auxiliary_symtab_list_
std::deque< parser_error::type >	error_list_
bool	load_variables_
bool	load_vectors_

Detailed Description

template<typename T>
class exprtk::function_compositor< T >

Definition at line 43056 of file exprtk.hpp.

Member Typedef Documentation

◆ expression_t

template<typename T>

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

Definition at line 43060 of file exprtk.hpp.

◆ funcparam_t

template<typename T>

typedef std::map<std::string,base_func*> exprtk::function_compositor< T >::funcparam_t

private

Definition at line 43492 of file exprtk.hpp.

◆ parser_t

template<typename T>

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

Definition at line 43062 of file exprtk.hpp.

◆ settings_t

template<typename T>

typedef parser_t::settings_store exprtk::function_compositor< T >::settings_t

Definition at line 43063 of file exprtk.hpp.

◆ symbol_table_t

template<typename T>

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

Definition at line 43061 of file exprtk.hpp.

◆ type

template<typename T>

typedef const T& exprtk::function_compositor< T >::type

private

Definition at line 43494 of file exprtk.hpp.

Constructor & Destructor Documentation

◆ function_compositor() [1/2]

template<typename T>

exprtk::function_compositor< T >::function_compositor ( )

inline

Definition at line 43694 of file exprtk.hpp.

      : parser_(settings_t::default_compile_all_opts +
                settings_t::e_disable_zero_return)
      , fp_map_(7)
      , load_variables_(false)
      , load_vectors_(false)
      {}

References fp_map_, load_variables_, load_vectors_, and parser_.

◆ function_compositor() [2/2]

template<typename T>

exprtk::function_compositor< T >::function_compositor ( const symbol_table_t & st )

inlineexplicit

Definition at line 43702 of file exprtk.hpp.

      : symbol_table_(st)
      , parser_(settings_t::default_compile_all_opts +
                settings_t::e_disable_zero_return)
      , fp_map_(7)
      , load_variables_(false)
      , load_vectors_(false)
      {}

References fp_map_, load_variables_, load_vectors_, parser_, and symbol_table_.

◆ ~function_compositor()

template<typename T>

exprtk::function_compositor< T >::~function_compositor ( )

inline

Definition at line 43711 of file exprtk.hpp.

      {
         clear();
      }

References clear().

Here is the call graph for this function:

Member Function Documentation

◆ add() [1/2]

template<typename T>

bool exprtk::function_compositor< T >::add	(	const function &	f,
		const bool	override = false )

inline

Definition at line 43795 of file exprtk.hpp.

      {
         return add(f.name_, f.expression_, f.v_,override);
      }

References add(), exprtk::function_compositor< T >::function::expression_, exprtk::function_compositor< T >::function::name_, and exprtk::function_compositor< T >::function::v_.

Here is the call graph for this function:

◆ add() [2/2]

template<typename T>

template<typename Allocator, template< typename, typename > class Sequence>

bool exprtk::function_compositor< T >::add	(	const std::string &	name,
		const std::string &	expression,
		const Sequence< std::string, Allocator > &	var_list,
		const bool	override = false )

inlineprivate

Definition at line 43655 of file exprtk.hpp.

      {
         const typename std::map<std::string,expression_t>::iterator itr = expr_map_.find(name);
 
         if (expr_map_.end() != itr)
         {
            if (!override)
            {
               exprtk_debug(("Compositor error(add): function '%s' already defined\n",
                             name.c_str()));
 
               return false;
            }
 
            remove(name, var_list.size());
         }
 
         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;
         }
         else
         {
            exprtk_debug(("Compositor error(add): Failed to compile function '%s'\n",
                          name.c_str()));
 
            return false;
         }
      }

References compile_expression(), expr_map_, exprtk_debug, fp_map_, and remove().

Referenced by add(), and primes_via_naive_method().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_auxiliary_symtab()

template<typename T>

void exprtk::function_compositor< T >::add_auxiliary_symtab ( symbol_table_t & symtab )

inline

Definition at line 43726 of file exprtk.hpp.

      {
         auxiliary_symtab_list_.push_back(&symtab);
      }

References auxiliary_symtab_list_.

◆ clear()

template<typename T>

void exprtk::function_compositor< T >::clear ( )

inline

Definition at line 43771 of file exprtk.hpp.

      {
         symbol_table_.clear();
         expr_map_    .clear();
 
         for (std::size_t i = 0; i < fp_map_.size(); ++i)
         {
            typename funcparam_t::iterator itr = fp_map_[i].begin();
            typename funcparam_t::iterator end = fp_map_[i].end  ();
 
            while (itr != end)
            {
               delete itr->second;
               ++itr;
            }
 
            fp_map_[i].clear();
         }
 
         clear_loop_runtime_check         ();
         clear_vector_access_runtime_check();
         clear_compilation_timeout_check  ();
      }

References clear_compilation_timeout_check(), clear_loop_runtime_check(), clear_vector_access_runtime_check(), expr_map_, fp_map_, and symbol_table_.

Referenced by ~function_compositor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear_compilation_timeout_check()

template<typename T>

void exprtk::function_compositor< T >::clear_compilation_timeout_check ( )

inline

Definition at line 43766 of file exprtk.hpp.

      {
         parser_.clear_compilation_timeout_check();
      }

References parser_.

Referenced by clear().

Here is the caller graph for this function:

◆ clear_loop_runtime_check()

template<typename T>

void exprtk::function_compositor< T >::clear_loop_runtime_check ( )

inline

Definition at line 43756 of file exprtk.hpp.

      {
         parser_.clear_loop_runtime_check();
      }

References parser_.

Referenced by clear().

Here is the caller graph for this function:

◆ clear_vector_access_runtime_check()

template<typename T>

void exprtk::function_compositor< T >::clear_vector_access_runtime_check ( )

inline

Definition at line 43761 of file exprtk.hpp.

      {
         parser_.clear_vector_access_runtime_check();
      }

References parser_.

Referenced by clear().

Here is the caller graph for this function:

◆ compile_expression()

template<typename T>

template<typename Allocator, template< typename, typename > class Sequence>

bool exprtk::function_compositor< T >::compile_expression	(	const std::string &	name,
		const std::string &	expression,
		const Sequence< std::string, Allocator > &	input_var_list,
		bool	return_present = false )

inlineprivate

Definition at line 43829 of file exprtk.hpp.

      {
         expression_t compiled_expression;
         symbol_table_t local_symbol_table;
 
         local_symbol_table.load_from(symbol_table_);
         local_symbol_table.add_constants();
 
         if (load_variables_)
         {
            local_symbol_table.load_variables_from(symbol_table_);
         }
 
         if (load_vectors_)
         {
            local_symbol_table.load_vectors_from(symbol_table_);
         }
 
         error_list_.clear();
 
         if (!valid(name,input_var_list.size()))
         {
            parser_error::type error =
               parser_error::make_error(
                  parser_error::e_parser,
                  lexer::token(),
                  "ERR285 - Function '" + name + "' is an invalid overload",
                  exprtk_error_location);
 
            error_list_.push_back(error);
            return false;
         }
 
         if (!forward(name,
                      input_var_list.size(),
                      local_symbol_table,
                      return_present))
            return false;
 
         compiled_expression.register_symbol_table(local_symbol_table);
 
         for (std::size_t i = 0; i < auxiliary_symtab_list_.size(); ++i)
         {
            compiled_expression.register_symbol_table((*auxiliary_symtab_list_[i]));
         }
 
         std::string mod_expression;
 
         for (std::size_t i = 0; i < input_var_list.size(); ++i)
         {
            mod_expression += " var " + input_var_list[i] + "{};\n";
         }
 
         if (
              ('{' == details::front(expression)) &&
              ('}' == details::back (expression))
            )
            mod_expression += "~" + expression + ";";
         else
            mod_expression += "~{" + expression + "};";
 
         if (!parser_.compile(mod_expression,compiled_expression))
         {
            exprtk_debug(("Compositor Error: %s\n", parser_.error().c_str()));
            exprtk_debug(("Compositor modified expression: \n%s\n", mod_expression.c_str()));
 
            remove(name,input_var_list.size());
 
            for (std::size_t err_index = 0; err_index < parser_.error_count(); ++err_index)
            {
               error_list_.push_back(parser_.get_error(err_index));
            }
 
            return false;
         }
 
         if (!return_present && parser_.dec().return_present())
         {
            remove(name,input_var_list.size());
            return compile_expression(name, expression, input_var_list, true);
         }
 
         // Make sure every return point has a scalar as its first parameter
         if (parser_.dec().return_present())
         {
            typedef std::vector<std::string> str_list_t;
 
            str_list_t ret_param_list = parser_.dec().return_param_type_list();
 
            for (std::size_t i = 0; i < ret_param_list.size(); ++i)
            {
               const std::string& params = ret_param_list[i];
 
               if (params.empty() || ('T' != params[0]))
               {
                  exprtk_debug(("Compositor Error: Return statement in function '%s' is invalid\n",
                                name.c_str()));
 
                  remove(name,input_var_list.size());
 
                  return false;
               }
            }
         }
 
         expr_map_[name] = compiled_expression;
 
         exprtk::ifunction<T>& ifunc = (*(fp_map_[input_var_list.size()])[name]);
 
         if (symbol_table_.add_function(name,ifunc))
            return true;
         else
         {
            exprtk_debug(("Compositor Error: Failed to add function '%s' to symbol table\n",
                          name.c_str()));
            return false;
         }
      }

References exprtk::symbol_table< T >::add_constants(), auxiliary_symtab_list_, exprtk::details::back(), compile_expression(), exprtk::parser_error::e_parser, error(), error_list_, expr_map_, exprtk_debug, exprtk_error_location, forward(), fp_map_, exprtk::details::front(), exprtk::symbol_table< T >::load_from(), load_variables_, exprtk::symbol_table< T >::load_variables_from(), load_vectors_, exprtk::symbol_table< T >::load_vectors_from(), exprtk::parser_error::make_error(), parser_, exprtk::expression< T >::register_symbol_table(), remove(), symbol_table_, and valid().

Referenced by add(), and compile_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ error()

template<typename T>

std::string exprtk::function_compositor< T >::error ( ) const

inline

Definition at line 43800 of file exprtk.hpp.

      {
         if (!error_list_.empty())
         {
            return error_list_[0].diagnostic;
         }
         else
            return std::string("No Error");
      }

References error_list_.

Referenced by compile_expression().

Here is the caller graph for this function:

◆ error_count()

template<typename T>

std::size_t exprtk::function_compositor< T >::error_count ( ) const

inline

Definition at line 43810 of file exprtk.hpp.

      {
         return error_list_.size();
      }

References error_list_.

◆ forward()

template<typename T>

bool exprtk::function_compositor< T >::forward	(	const std::string &	name,
		const std::size_t &	arg_count,
		symbol_table_t &	sym_table,
		const bool	ret_present = false )

inlineprivate

Definition at line 43975 of file exprtk.hpp.

      {
         switch (arg_count)
         {
            #define case_stmt(N)                                     \
            case N : (fp_map_[arg_count])[name] =                    \
                     (!ret_present) ? static_cast<base_func*>        \
                                      (new func_##N##param) :        \
                                      static_cast<base_func*>        \
                                      (new func_##N##param_retval) ; \
                     break;                                          \
 
            case_stmt(0) case_stmt(1) case_stmt(2)
            case_stmt(3) case_stmt(4) case_stmt(5)
            case_stmt(6)
            #undef case_stmt
         }
 
         exprtk::ifunction<T>& ifunc = (*(fp_map_[arg_count])[name]);
 
         return sym_table.add_function(name,ifunc);
      }

References exprtk::symbol_table< T >::add_function(), case_stmt, and fp_map_.

Referenced by compile_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_error()

template<typename T>

parser_error::type exprtk::function_compositor< T >::get_error ( const std::size_t & index ) const

inline

Definition at line 43815 of file exprtk.hpp.

      {
         if (index < error_list_.size())
         {
            return error_list_[index];
         }
 
         throw std::invalid_argument("compositor::get_error() - Invalid error index specified");
      }

References error_list_.

◆ load_variables()

template<typename T>

void exprtk::function_compositor< T >::load_variables ( const bool load = true )

inline

Definition at line 43731 of file exprtk.hpp.

      {
         load_variables_ = load;
      }

References load_variables_.

◆ load_vectors()

template<typename T>

void exprtk::function_compositor< T >::load_vectors ( const bool load = true )

inline

Definition at line 43736 of file exprtk.hpp.

      {
         load_vectors_ = load;
      }

References load_vectors_.

◆ register_compilation_timeout_check()

template<typename T>

void exprtk::function_compositor< T >::register_compilation_timeout_check ( compilation_check & compchk )

inline

Definition at line 43751 of file exprtk.hpp.

      {
         parser_.register_compilation_timeout_check(compchk);
      }

References parser_.

◆ register_loop_runtime_check()

template<typename T>

void exprtk::function_compositor< T >::register_loop_runtime_check ( loop_runtime_check & lrtchk )

inline

Definition at line 43741 of file exprtk.hpp.

      {
         parser_.register_loop_runtime_check(lrtchk);
      }

References parser_.

◆ register_vector_access_runtime_check()

template<typename T>

void exprtk::function_compositor< T >::register_vector_access_runtime_check ( vector_access_runtime_check & vartchk )

inline

Definition at line 43746 of file exprtk.hpp.

      {
         parser_.register_vector_access_runtime_check(vartchk);
      }

References parser_.

◆ remove()

template<typename T>

void exprtk::function_compositor< T >::remove	(	const std::string &	name,
		const std::size_t &	arg_count )

inlineprivate

Definition at line 44001 of file exprtk.hpp.

      {
         if (arg_count > 6)
            return;
 
         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);
         }
 
         const typename funcparam_t::iterator fp_itr = fp_map_[arg_count].find(name);
 
         if (fp_map_[arg_count].end() != fp_itr)
         {
            delete fp_itr->second;
            fp_map_[arg_count].erase(fp_itr);
         }
 
         symbol_table_.remove_function(name);
      }

References expr_map_, fp_map_, and symbol_table_.

Referenced by add(), and compile_expression().

Here is the caller graph for this function:

◆ return_value()

template<typename T>

T exprtk::function_compositor< T >::return_value ( expression_t & e )

inlinestaticprivate

Definition at line 43615 of file exprtk.hpp.

      {
         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;
 
         const T result = e.value();
 
         if (e.return_invoked())
         {
            // Due to the post compilation checks, it can be safely
            // assumed that there will be at least one parameter
            // and that the first parameter will always be scalar.
            return scalar_t(e.results()[0])();
         }
 
         return result;
      }

◆ symbol_table() [1/2]

template<typename T>

symbol_table_t & exprtk::function_compositor< T >::symbol_table ( )

inline

Definition at line 43716 of file exprtk.hpp.

      {
         return symbol_table_;
      }

References symbol_table_.

◆ symbol_table() [2/2]

template<typename T>

const symbol_table_t & exprtk::function_compositor< T >::symbol_table ( ) const

inline

Definition at line 43721 of file exprtk.hpp.

      {
         return symbol_table_;
      }

References symbol_table_.

◆ symbol_used()

template<typename T>

bool exprtk::function_compositor< T >::symbol_used ( const std::string & symbol ) const

inlineprivate

Definition at line 43951 of file exprtk.hpp.

      {
         return (
                  symbol_table_.is_variable       (symbol) ||
                  symbol_table_.is_stringvar      (symbol) ||
                  symbol_table_.is_function       (symbol) ||
                  symbol_table_.is_vector         (symbol) ||
                  symbol_table_.is_vararg_function(symbol)
                );
      }

References symbol_table_.

Referenced by valid().

Here is the caller graph for this function:

◆ valid()

template<typename T>

bool exprtk::function_compositor< T >::valid	(	const std::string &	name,
		const std::size_t &	arg_count ) const

inlineprivate

Definition at line 43962 of file exprtk.hpp.

      {
         if (arg_count > 6)
            return false;
         else if (symbol_used(name))
            return false;
         else if (fp_map_[arg_count].end() != fp_map_[arg_count].find(name))
            return false;
         else
            return true;
      }