#include <exprtk.hpp>

Classes
struct	base_func

struct	func_0param

struct	func_0param_retval

struct	func_1param

struct	func_1param_retval

struct	func_2param

struct	func_2param_retval

struct	func_3param

struct	func_3param_retval

struct	func_4param

struct	func_4param_retval

struct	func_5param

struct	func_5param_retval

struct	func_6param

struct	func_6param_retval

struct	function

struct	scoped_bft

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 42926 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 42930 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 43362 of file exprtk.hpp.

◆ parser_t

template<typename T >

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

Definition at line 42932 of file exprtk.hpp.

◆ settings_t

template<typename T >

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

Definition at line 42933 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 42931 of file exprtk.hpp.

◆ type

template<typename T >

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

private

Definition at line 43364 of file exprtk.hpp.

Constructor & Destructor Documentation

◆ function_compositor() [1/2]

template<typename T >

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

inline

Definition at line 43564 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)
      {}

◆ function_compositor() [2/2]

template<typename T >

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

inlineexplicit

Definition at line 43572 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)
      {}

◆ ~function_compositor()

template<typename T >

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

inline

Definition at line 43581 of file exprtk.hpp.

      {
         clear();
      }

References exprtk::function_compositor< T >::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 43665 of file exprtk.hpp.

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

References exprtk::function_compositor< T >::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 43525 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 exprtk::function_compositor< T >::compile_expression(), exprtk::function_compositor< T >::expr_map_, exprtk_debug, exprtk::function_compositor< T >::fp_map_, and exprtk::function_compositor< T >::remove().

Referenced by exprtk::function_compositor< T >::add(), primes_via_naive_method(), and expression_processor< T >::process_function_definition().

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 43596 of file exprtk.hpp.

      {
         auxiliary_symtab_list_.push_back(&symtab);
      }

References exprtk::function_compositor< T >::auxiliary_symtab_list_.

◆ clear()

template<typename T >

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

inline

Definition at line 43641 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 exprtk::symbol_table< T >::clear(), exprtk::function_compositor< T >::clear_compilation_timeout_check(), exprtk::function_compositor< T >::clear_loop_runtime_check(), exprtk::function_compositor< T >::clear_vector_access_runtime_check(), exprtk::function_compositor< T >::expr_map_, exprtk::function_compositor< T >::fp_map_, and exprtk::function_compositor< T >::symbol_table_.

Referenced by exprtk::function_compositor< T >::~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 43636 of file exprtk.hpp.

      {
         parser_.clear_compilation_timeout_check();
      }

References exprtk::parser< T >::clear_compilation_timeout_check(), and exprtk::function_compositor< T >::parser_.

Referenced by exprtk::function_compositor< T >::clear().

Here is the call graph for this function:

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 43626 of file exprtk.hpp.

      {
         parser_.clear_loop_runtime_check();
      }

References exprtk::parser< T >::clear_loop_runtime_check(), and exprtk::function_compositor< T >::parser_.

Referenced by exprtk::function_compositor< T >::clear().

Here is the call graph for this function:

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 43631 of file exprtk.hpp.

      {
         parser_.clear_vector_access_runtime_check();
      }

References exprtk::parser< T >::clear_vector_access_runtime_check(), and exprtk::function_compositor< T >::parser_.

Referenced by exprtk::function_compositor< T >::clear().

Here is the call graph for this function:

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 43699 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(),
                  "ERR283 - 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(), exprtk::symbol_table< T >::add_function(), exprtk::function_compositor< T >::auxiliary_symtab_list_, exprtk::details::back(), exprtk::parser< T >::compile(), exprtk::function_compositor< T >::compile_expression(), exprtk::parser< T >::dec(), exprtk::parser_error::e_parser, exprtk::parser< T >::error(), exprtk::function_compositor< T >::error(), exprtk::parser< T >::error_count(), exprtk::function_compositor< T >::error_list_, exprtk::function_compositor< T >::expr_map_, exprtk_debug, exprtk_error_location, exprtk::function_compositor< T >::forward(), exprtk::function_compositor< T >::fp_map_, exprtk::details::front(), exprtk::parser< T >::get_error(), exprtk::symbol_table< T >::load_from(), exprtk::function_compositor< T >::load_variables_, exprtk::symbol_table< T >::load_variables_from(), exprtk::function_compositor< T >::load_vectors_, exprtk::symbol_table< T >::load_vectors_from(), exprtk::parser_error::make_error(), exprtk::function_compositor< T >::parser_, exprtk::expression< T >::register_symbol_table(), exprtk::function_compositor< T >::remove(), exprtk::parser< T >::dependent_entity_collector::return_param_type_list(), exprtk::parser< T >::dependent_entity_collector::return_present(), exprtk::function_compositor< T >::symbol_table_, and exprtk::function_compositor< T >::valid().

Referenced by exprtk::function_compositor< T >::add(), and exprtk::function_compositor< T >::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 43670 of file exprtk.hpp.

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

References exprtk::function_compositor< T >::error_list_.

Referenced by exprtk::function_compositor< T >::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 43680 of file exprtk.hpp.

      {
         return error_list_.size();
      }

References exprtk::function_compositor< T >::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 43845 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 exprtk::function_compositor< T >::fp_map_.

Referenced by exprtk::function_compositor< T >::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 43685 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 exprtk::function_compositor< T >::error_list_.

◆ load_variables()

template<typename T >

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

inline

Definition at line 43601 of file exprtk.hpp.

      {
         load_variables_ = load;
      }

References exprtk::function_compositor< T >::load_variables_.

◆ load_vectors()

template<typename T >

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

inline

Definition at line 43606 of file exprtk.hpp.

      {
         load_vectors_ = load;
      }

References exprtk::function_compositor< T >::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 43621 of file exprtk.hpp.

      {
         parser_.register_compilation_timeout_check(compchk);
      }

References exprtk::function_compositor< T >::parser_, and exprtk::parser< T >::register_compilation_timeout_check().

Here is the call graph for this function:

◆ register_loop_runtime_check()

template<typename T >

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

inline

Definition at line 43611 of file exprtk.hpp.

      {
         parser_.register_loop_runtime_check(lrtchk);
      }

References exprtk::function_compositor< T >::parser_, and exprtk::parser< T >::register_loop_runtime_check().

Here is the call graph for this function:

◆ 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 43616 of file exprtk.hpp.

      {
         parser_.register_vector_access_runtime_check(vartchk);
      }

References exprtk::function_compositor< T >::parser_, and exprtk::parser< T >::register_vector_access_runtime_check().

Here is the call graph for this function:

◆ remove()

template<typename T >

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

inlineprivate

Definition at line 43871 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 exprtk::function_compositor< T >::expr_map_, exprtk::function_compositor< T >::fp_map_, exprtk::symbol_table< T >::remove_function(), and exprtk::function_compositor< T >::symbol_table_.

Referenced by exprtk::function_compositor< T >::add(), and exprtk::function_compositor< T >::compile_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ return_value()

template<typename T >

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

inlinestaticprivate

Definition at line 43485 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 43586 of file exprtk.hpp.

      {
         return symbol_table_;
      }

References exprtk::function_compositor< T >::symbol_table_.

◆ symbol_table() [2/2]

template<typename T >

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

inline

Definition at line 43591 of file exprtk.hpp.

      {
         return symbol_table_;
      }

References exprtk::function_compositor< T >::symbol_table_.

◆ symbol_used()

template<typename T >

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

inlineprivate

Definition at line 43821 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 exprtk::symbol_table< T >::is_function(), exprtk::symbol_table< T >::is_stringvar(), exprtk::symbol_table< T >::is_vararg_function(), exprtk::symbol_table< T >::is_variable(), exprtk::symbol_table< T >::is_vector(), and exprtk::function_compositor< T >::symbol_table_.

Referenced by exprtk::function_compositor< T >::valid().

Here is the call graph for this function:

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 43832 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;
      }