#include <Exprtk.hpp>

Inheritance diagram for exprtk::parser< T >:

Classes
struct	closed_range_policy

class	dependent_entity_collector

class	expression_generator

struct	halfopen_range_policy

class	interval_container_t

struct	parse_special_function_impl

struct	parser_state

struct	scope_element

class	scope_element_manager

class	scope_handler

struct	scoped_bool_negator

struct	scoped_bool_or_restorer

struct	scoped_delete

struct	scoped_deq_delete

struct	scoped_expression_delete

struct	scoped_inc_dec

struct	scoped_vec_delete

class	settings_store

class	stack_limit_handler

struct	state_t

struct	symtab_store

class	type_checker

struct	unknown_symbol_resolver

Public Types
enum	collect_type { e_ct_none = 0 , e_ct_variables = 1 , e_ct_functions = 2 , e_ct_assignments = 4 }

enum	symbol_type { e_st_unknown = 0 , e_st_variable = 1 , e_st_vector = 2 , e_st_vecelem = 3 , e_st_string = 4 , e_st_function = 5 , e_st_local_variable = 6 , e_st_local_vector = 7 , e_st_local_string = 8 }

typedef settings_store	settings_t

Public Types inherited from exprtk::lexer::parser_helper
enum	token_advance_mode { e_hold = 0 , e_advance = 1 }

typedef token	token_t

typedef generator	generator_t

Public Member Functions
	parser (const settings_t &settings=settings_t())

	~parser ()

void	init_precompilation ()

bool	compile (const std::string &expression_string, expression< T > &expr)

expression_t	compile (const std::string &expression_string, symbol_table_t &symtab)

void	process_lexer_errors ()

bool	run_assemblies ()

settings_store &	settings ()

parser_error::type	get_error (const std::size_t &index) const

std::string	error () const

std::size_t	error_count () const

dependent_entity_collector &	dec ()

bool	replace_symbol (const std::string &old_symbol, const std::string &new_symbol)

bool	remove_replace_symbol (const std::string &symbol)

void	enable_unknown_symbol_resolver (unknown_symbol_resolver usr=reinterpret_cast< unknown_symbol_resolver >(0))

void	enable_unknown_symbol_resolver (unknown_symbol_resolver &usr)

void	disable_unknown_symbol_resolver ()

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 ()

Public Member Functions inherited from exprtk::lexer::parser_helper
bool	init (const std::string &str)

generator_t &	lexer ()

const generator_t &	lexer () const

void	store_token ()

void	restore_token ()

void	next_token ()

const token_t &	current_token () const

const token_t &	peek_next_token ()

void	advance_token (const token_advance_mode mode)

bool	token_is (const token_t::token_type &ttype, const token_advance_mode mode=e_advance)

bool	token_is (const token_t::token_type &ttype, const std::string &value, const token_advance_mode mode=e_advance)

bool	token_is (const std::string &value, const token_advance_mode mode=e_advance)

bool	token_is_arithmetic_opr (const token_advance_mode mode=e_advance)

bool	token_is_ineq_opr (const token_advance_mode mode=e_advance)

bool	token_is_left_bracket (const token_advance_mode mode=e_advance)

bool	token_is_right_bracket (const token_advance_mode mode=e_advance)

bool	token_is_loop (const token_advance_mode mode=e_advance)

bool	peek_token_is (const token_t::token_type &ttype)

bool	peek_token_is (const std::string &s)

Private Types
enum	precedence_level { e_level00 , e_level01 , e_level02 , e_level03 , e_level04 , e_level05 , e_level06 , e_level07 , e_level08 , e_level09 , e_level10 , e_level11 , e_level12 , e_level13 , e_level14 }

typedef const T &	cref_t

typedef const T	const_t

typedef ifunction< T >	F

typedef ivararg_function< T >	VAF

typedef igeneric_function< T >	GF

typedef ifunction< T >	ifunction_t

typedef ivararg_function< T >	ivararg_function_t

typedef igeneric_function< T >	igeneric_function_t

typedef details::expression_node< T >	expression_node_t

typedef details::literal_node< T >	literal_node_t

typedef details::unary_node< T >	unary_node_t

typedef details::binary_node< T >	binary_node_t

typedef details::trinary_node< T >	trinary_node_t

typedef details::quaternary_node< T >	quaternary_node_t

typedef details::conditional_node< T >	conditional_node_t

typedef details::cons_conditional_node< T >	cons_conditional_node_t

typedef details::while_loop_node< T >	while_loop_node_t

typedef details::repeat_until_loop_node< T >	repeat_until_loop_node_t

typedef details::for_loop_node< T >	for_loop_node_t

typedef details::while_loop_rtc_node< T >	while_loop_rtc_node_t

typedef details::repeat_until_loop_rtc_node< T >	repeat_until_loop_rtc_node_t

typedef details::for_loop_rtc_node< T >	for_loop_rtc_node_t

typedef details::while_loop_bc_node< T >	while_loop_bc_node_t

typedef details::repeat_until_loop_bc_node< T >	repeat_until_loop_bc_node_t

typedef details::for_loop_bc_node< T >	for_loop_bc_node_t

typedef details::while_loop_bc_rtc_node< T >	while_loop_bc_rtc_node_t

typedef details::repeat_until_loop_bc_rtc_node< T >	repeat_until_loop_bc_rtc_node_t

typedef details::for_loop_bc_rtc_node< T >	for_loop_bc_rtc_node_t

typedef details::switch_node< T >	switch_node_t

typedef details::variable_node< T >	variable_node_t

typedef details::vector_elem_node< T >	vector_elem_node_t

typedef details::vector_celem_node< T >	vector_celem_node_t

typedef details::vector_elem_rtc_node< T >	vector_elem_rtc_node_t

typedef details::vector_celem_rtc_node< T >	vector_celem_rtc_node_t

typedef details::rebasevector_elem_node< T >	rebasevector_elem_node_t

typedef details::rebasevector_celem_node< T >	rebasevector_celem_node_t

typedef details::rebasevector_elem_rtc_node< T >	rebasevector_elem_rtc_node_t

typedef details::rebasevector_celem_rtc_node< T >	rebasevector_celem_rtc_node_t

typedef details::vector_node< T >	vector_node_t

typedef details::vector_size_node< T >	vector_size_node_t

typedef details::range_pack< T >	range_t

typedef details::stringvar_node< T >	stringvar_node_t

typedef details::string_literal_node< T >	string_literal_node_t

typedef details::string_range_node< T >	string_range_node_t

typedef details::const_string_range_node< T >	const_string_range_node_t

typedef details::generic_string_range_node< T >	generic_string_range_node_t

typedef details::string_concat_node< T >	string_concat_node_t

typedef details::assignment_string_node< T >	assignment_string_node_t

typedef details::assignment_string_range_node< T >	assignment_string_range_node_t

typedef details::conditional_string_node< T >	conditional_string_node_t

typedef details::cons_conditional_str_node< T >	cons_conditional_str_node_t

typedef details::assignment_node< T >	assignment_node_t

typedef details::assignment_vec_elem_node< T >	assignment_vec_elem_node_t

typedef details::assignment_vec_elem_rtc_node< T >	assignment_vec_elem_rtc_node_t

typedef details::assignment_rebasevec_elem_node< T >	assignment_rebasevec_elem_node_t

typedef details::assignment_rebasevec_elem_rtc_node< T >	assignment_rebasevec_elem_rtc_node_t

typedef details::assignment_rebasevec_celem_node< T >	assignment_rebasevec_celem_node_t

typedef details::assignment_vec_node< T >	assignment_vec_node_t

typedef details::assignment_vecvec_node< T >	assignment_vecvec_node_t

typedef details::conditional_vector_node< T >	conditional_vector_node_t

typedef details::scand_node< T >	scand_node_t

typedef details::scor_node< T >	scor_node_t

typedef lexer::token	token_t

typedef expression_node_t *	expression_node_ptr

typedef expression< T >	expression_t

typedef symbol_table< T >	symbol_table_t

typedef expression< T >::symtab_list_t	symbol_table_list_t

typedef details::vector_holder< T >	vector_holder_t

typedef vector_holder_t *	vector_holder_ptr

typedef details::functor_t< T >	functor_t

typedef functor_t::qfunc_t	quaternary_functor_t

typedef functor_t::tfunc_t	trinary_functor_t

typedef functor_t::bfunc_t	binary_functor_t

typedef functor_t::ufunc_t	unary_functor_t

typedef details::operator_type	operator_t

typedef std::map< operator_t, unary_functor_t >	unary_op_map_t

typedef std::map< operator_t, binary_functor_t >	binary_op_map_t

typedef std::map< operator_t, trinary_functor_t >	trinary_op_map_t

typedef std::map< std::string, std::pair< trinary_functor_t,operator_t> >	sf3_map_t

typedef std::map< std::string, std::pair< quaternary_functor_t, operator_t> >	sf4_map_t

typedef std::map< binary_functor_t, operator_t>	inv_binary_op_map_t

typedef std::multimap< std::string, details::base_operation_t, details::ilesscompare >	base_ops_map_t

typedef std::set< std::string, details::ilesscompare >	disabled_func_set_t

typedef details::T0oT1_define< T, cref_t, cref_t >	vov_t

typedef details::T0oT1_define< T, const_t, cref_t >	cov_t

typedef details::T0oT1_define< T, cref_t, const_t >	voc_t

typedef details::T0oT1oT2_define< T, cref_t, cref_t, cref_t >	vovov_t

typedef details::T0oT1oT2_define< T, cref_t, cref_t, const_t >	vovoc_t

typedef details::T0oT1oT2_define< T, cref_t, const_t, cref_t >	vocov_t

typedef details::T0oT1oT2_define< T, const_t, cref_t, cref_t >	covov_t

typedef details::T0oT1oT2_define< T, const_t, cref_t, const_t >	covoc_t

typedef details::T0oT1oT2_define< T, const_t, const_t, cref_t >	cocov_t

typedef details::T0oT1oT2_define< T, cref_t, const_t, const_t >	vococ_t

typedef details::T0oT1oT2oT3_define< T, cref_t, cref_t, cref_t, cref_t >	vovovov_t

typedef details::T0oT1oT2oT3_define< T, cref_t, cref_t, cref_t, const_t >	vovovoc_t

typedef details::T0oT1oT2oT3_define< T, cref_t, cref_t, const_t, cref_t >	vovocov_t

typedef details::T0oT1oT2oT3_define< T, cref_t, const_t, cref_t, cref_t >	vocovov_t

typedef details::T0oT1oT2oT3_define< T, const_t, cref_t, cref_t, cref_t >	covovov_t

typedef details::T0oT1oT2oT3_define< T, const_t, cref_t, const_t, cref_t >	covocov_t

typedef details::T0oT1oT2oT3_define< T, cref_t, const_t, cref_t, const_t >	vocovoc_t

typedef details::T0oT1oT2oT3_define< T, const_t, cref_t, cref_t, const_t >	covovoc_t

typedef details::T0oT1oT2oT3_define< T, cref_t, const_t, const_t, cref_t >	vococov_t

typedef results_context< T >	results_context_t

typedef parser_helper	prsrhlpr_t

typedef interval_container_t< const void * >::interval_t	interval_t

typedef interval_container_t< const void * >	immutable_memory_map_t

typedef std::map< interval_t, token_t >	immutable_symtok_map_t

Private Member Functions
bool	valid_base_operation (const std::string &symbol) const

bool	valid_vararg_operation (const std::string &symbol) const

bool	is_invalid_logic_operation (const details::operator_type operation) const

bool	is_invalid_arithmetic_operation (const details::operator_type operation) const

bool	is_invalid_assignment_operation (const details::operator_type operation) const

bool	is_invalid_inequality_operation (const details::operator_type operation) const

expression_node_ptr	parse_corpus ()

std::string	construct_subexpr (lexer::token &begin_token, lexer::token &end_token)

void	push_current_state (const state_t current_state)

void	pop_current_state ()

state_t	current_state () const

bool	halt_compilation_check ()

expression_node_ptr	parse_expression (precedence_level precedence=e_level00)

bool	simplify_unary_negation_branch (expression_node_ptr &node)

expression_node_ptr	parse_function_invocation (ifunction< T > *function, const std::string &function_name)

template<std::size_t NumberofParameters>
expression_node_ptr	parse_function_call (ifunction< T > *function, const std::string &function_name)

expression_node_ptr	parse_function_call_0 (ifunction< T > *function, const std::string &function_name)

template<std::size_t MaxNumberofParameters>
std::size_t	parse_base_function_call (expression_node_ptr(&param_list)[MaxNumberofParameters], const std::string &function_name="")

expression_node_ptr	parse_base_operation ()

expression_node_ptr	parse_conditional_statement_01 (expression_node_ptr condition)

expression_node_ptr	parse_conditional_statement_02 (expression_node_ptr condition)

expression_node_ptr	parse_conditional_statement ()

expression_node_ptr	parse_ternary_conditional_statement (expression_node_ptr condition)

expression_node_ptr	parse_not_statement ()

void	handle_brkcnt_scope_exit ()

expression_node_ptr	parse_while_loop ()

expression_node_ptr	parse_repeat_until_loop ()

expression_node_ptr	parse_for_loop ()

expression_node_ptr	parse_switch_statement ()

expression_node_ptr	parse_multi_switch_statement ()

expression_node_ptr	parse_vararg_function ()

expression_node_ptr	parse_string_range_statement (expression_node_ptr &expression)

bool	parse_pending_string_rangesize (expression_node_ptr &expression)

void	parse_pending_vector_index_operator (expression_node_ptr &expression)

template<typename Allocator1 , typename Allocator2 , template< typename, typename > class Sequence>
expression_node_ptr	simplify (Sequence< expression_node_ptr, Allocator1 > &expression_list, Sequence< bool, Allocator2 > &side_effect_list, const bool specialise_on_final_type=false)

expression_node_ptr	parse_multi_sequence (const std::string &source="", const bool enforce_crlbrackets=false)

bool	parse_range (range_t &rp, const bool skip_lsqr=false)

void	lodge_symbol (const std::string &symbol, const symbol_type st)

expression_node_ptr	parse_string ()

expression_node_ptr	parse_const_string ()

expression_node_ptr	parse_vector_index (const std::string &vector_name="")

expression_node_ptr	parse_vector ()

expression_node_ptr	synthesize_vector_element (const std::string &vector_name, vector_holder_ptr vec, expression_node_ptr vec_node, expression_node_ptr index_expr)

expression_node_ptr	parse_vararg_function_call (ivararg_function< T > *vararg_function, const std::string &vararg_function_name)

expression_node_ptr	parse_generic_function_call (igeneric_function< T > *function, const std::string &function_name)

bool	parse_igeneric_function_params (std::string &param_type_list, std::vector< expression_node_ptr > &arg_list, const std::string &function_name, igeneric_function< T > *function, const type_checker &tc)

expression_node_ptr	parse_string_function_call (igeneric_function< T > *function, const std::string &function_name)

expression_node_ptr	parse_overload_function_call (igeneric_function< T > *function, const std::string &function_name)

expression_node_ptr	parse_special_function ()

expression_node_ptr	parse_null_statement ()

expression_node_ptr	parse_break_statement ()

expression_node_ptr	parse_continue_statement ()

expression_node_ptr	parse_define_vector_statement (const std::string &vec_name)

expression_node_ptr	parse_define_string_statement (const std::string &str_name, expression_node_ptr initialisation_expression)

bool	local_variable_is_shadowed (const std::string &symbol)

expression_node_ptr	parse_define_var_statement ()

expression_node_ptr	parse_uninitialised_var_statement (const std::string &var_name)

expression_node_ptr	parse_swap_statement ()

expression_node_ptr	parse_return_statement ()

bool	post_variable_process (const std::string &symbol)

bool	post_bracket_process (const typename token_t::token_type &token, expression_node_ptr &branch)

interval_t	make_memory_range (const T &t)

interval_t	make_memory_range (const T *begin, const std::size_t size)

interval_t	make_memory_range (details::char_cptr begin, const std::size_t size)

void	lodge_immutable_symbol (const lexer::token &token, const interval_t interval)

expression_node_ptr	parse_symtab_symbol ()

expression_node_ptr	parse_symbol ()

expression_node_ptr	parse_branch (precedence_level precedence=e_level00)

void	set_error (const parser_error::type &error_type)

void	remove_last_error ()

void	set_synthesis_error (const std::string &synthesis_error_message)

void	register_local_vars (expression< T > &e)

void	register_return_results (expression< T > &e)

void	load_unary_operations_map (unary_op_map_t &m)

void	load_binary_operations_map (binary_op_map_t &m)

void	load_inv_binary_operations_map (inv_binary_op_map_t &m)

void	load_sf3_map (sf3_map_t &sf3_map)

void	load_sf4_map (sf4_map_t &sf4_map)

results_context_t &	results_ctx ()

void	return_cleanup ()

	parser (const parser< T > &) exprtk_delete

parser< T > &	operator= (const parser< T > &) exprtk_delete

Static Private Member Functions
static expression_node_ptr	error_node ()

Private Attributes
settings_store	settings_

expression_generator< T >	expression_generator_

details::node_allocator	node_allocator_

symtab_store	symtab_store_

dependent_entity_collector	dec_

std::deque< parser_error::type >	error_list_

std::deque< bool >	brkcnt_list_

parser_state	state_

bool	resolve_unknown_symbol_

results_context_t *	results_context_

unknown_symbol_resolver *	unknown_symbol_resolver_

unknown_symbol_resolver	default_usr_

base_ops_map_t	base_ops_map_

unary_op_map_t	unary_op_map_

binary_op_map_t	binary_op_map_

inv_binary_op_map_t	inv_binary_op_map_

sf3_map_t	sf3_map_

sf4_map_t	sf4_map_

std::string	synthesis_error_

scope_element_manager	sem_

std::vector< state_t >	current_state_stack_

immutable_memory_map_t	immutable_memory_map_

immutable_symtok_map_t	immutable_symtok_map_

lexer::helper::helper_assembly	helper_assembly_

lexer::helper::commutative_inserter	commutative_inserter_

lexer::helper::operator_joiner	operator_joiner_2_

lexer::helper::operator_joiner	operator_joiner_3_

lexer::helper::symbol_replacer	symbol_replacer_

lexer::helper::bracket_checker	bracket_checker_

lexer::helper::numeric_checker< T >	numeric_checker_

lexer::helper::sequence_validator	sequence_validator_

lexer::helper::sequence_validator_3tokens	sequence_validator_3tkns_

loop_runtime_check_ptr	loop_runtime_check_

vector_access_runtime_check_ptr	vector_access_runtime_check_

compilation_check_ptr	compilation_check_ptr_

Static Private Attributes
static const precedence_level	default_precedence = e_level00

Friends
template<typename ParserType >
void	details::disable_type_checking (ParserType &p)

Member Typedef Documentation

◆ assignment_node_t

template<typename T >

typedef details::assignment_node<T> exprtk::parser< T >::assignment_node_t

private

◆ assignment_rebasevec_celem_node_t

template<typename T >

typedef details::assignment_rebasevec_celem_node<T> exprtk::parser< T >::assignment_rebasevec_celem_node_t

private

◆ assignment_rebasevec_elem_node_t

template<typename T >

typedef details::assignment_rebasevec_elem_node<T> exprtk::parser< T >::assignment_rebasevec_elem_node_t

private

◆ assignment_rebasevec_elem_rtc_node_t

template<typename T >

typedef details::assignment_rebasevec_elem_rtc_node<T> exprtk::parser< T >::assignment_rebasevec_elem_rtc_node_t

private

◆ assignment_string_node_t

template<typename T >

typedef details::assignment_string_node<T> exprtk::parser< T >::assignment_string_node_t

private

◆ assignment_string_range_node_t

template<typename T >

typedef details::assignment_string_range_node<T> exprtk::parser< T >::assignment_string_range_node_t

private

◆ assignment_vec_elem_node_t

template<typename T >

typedef details::assignment_vec_elem_node<T> exprtk::parser< T >::assignment_vec_elem_node_t

private

◆ assignment_vec_elem_rtc_node_t

template<typename T >

typedef details::assignment_vec_elem_rtc_node<T> exprtk::parser< T >::assignment_vec_elem_rtc_node_t

private

◆ assignment_vec_node_t

template<typename T >

typedef details::assignment_vec_node<T> exprtk::parser< T >::assignment_vec_node_t

private

◆ assignment_vecvec_node_t

template<typename T >

typedef details::assignment_vecvec_node<T> exprtk::parser< T >::assignment_vecvec_node_t

private

◆ base_ops_map_t

template<typename T >

typedef std::multimap<std::string,details::base_operation_t,details::ilesscompare> exprtk::parser< T >::base_ops_map_t

private

◆ binary_functor_t

template<typename T >

typedef functor_t::bfunc_t exprtk::parser< T >::binary_functor_t

private

◆ binary_node_t

template<typename T >

typedef details::binary_node<T> exprtk::parser< T >::binary_node_t

private

◆ binary_op_map_t

template<typename T >

typedef std::map<operator_t, binary_functor_t > exprtk::parser< T >::binary_op_map_t

private

◆ cocov_t

template<typename T >

typedef details::T0oT1oT2_define<T, const_t, const_t, cref_t > exprtk::parser< T >::cocov_t

private

◆ conditional_node_t

template<typename T >

typedef details::conditional_node<T> exprtk::parser< T >::conditional_node_t

private

◆ conditional_string_node_t

template<typename T >

typedef details::conditional_string_node<T> exprtk::parser< T >::conditional_string_node_t

private

◆ conditional_vector_node_t

template<typename T >

typedef details::conditional_vector_node<T> exprtk::parser< T >::conditional_vector_node_t

private

◆ cons_conditional_node_t

template<typename T >

typedef details::cons_conditional_node<T> exprtk::parser< T >::cons_conditional_node_t

private

◆ cons_conditional_str_node_t

template<typename T >

typedef details::cons_conditional_str_node<T> exprtk::parser< T >::cons_conditional_str_node_t

private

◆ const_string_range_node_t

template<typename T >

typedef details::const_string_range_node<T> exprtk::parser< T >::const_string_range_node_t

private

◆ const_t

template<typename T >

typedef const T exprtk::parser< T >::const_t

private

◆ cov_t

template<typename T >

typedef details::T0oT1_define<T, const_t, cref_t > exprtk::parser< T >::cov_t

private

◆ covoc_t

template<typename T >

typedef details::T0oT1oT2_define<T, const_t, cref_t , const_t> exprtk::parser< T >::covoc_t

private

◆ covocov_t

template<typename T >

typedef details::T0oT1oT2oT3_define<T, const_t, cref_t , const_t, cref_t > exprtk::parser< T >::covocov_t

private

◆ covov_t

template<typename T >

typedef details::T0oT1oT2_define<T, const_t, cref_t , cref_t > exprtk::parser< T >::covov_t

private

◆ covovoc_t

template<typename T >

typedef details::T0oT1oT2oT3_define<T, const_t, cref_t , cref_t , const_t> exprtk::parser< T >::covovoc_t

private

◆ covovov_t

template<typename T >

typedef details::T0oT1oT2oT3_define<T, const_t, cref_t , cref_t , cref_t > exprtk::parser< T >::covovov_t

private

◆ cref_t

template<typename T >

typedef const T& exprtk::parser< T >::cref_t

private

◆ disabled_func_set_t

template<typename T >

typedef std::set<std::string,details::ilesscompare> exprtk::parser< T >::disabled_func_set_t

private

◆ expression_node_ptr

template<typename T >

typedef expression_node_t* exprtk::parser< T >::expression_node_ptr

private

◆ expression_node_t

template<typename T >

typedef details::expression_node<T> exprtk::parser< T >::expression_node_t

private

◆ expression_t

template<typename T >

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

private

◆ F

template<typename T >

typedef ifunction<T> exprtk::parser< T >::F

private

◆ for_loop_bc_node_t

template<typename T >

typedef details::for_loop_bc_node<T> exprtk::parser< T >::for_loop_bc_node_t

private

◆ for_loop_bc_rtc_node_t

template<typename T >

typedef details::for_loop_bc_rtc_node<T> exprtk::parser< T >::for_loop_bc_rtc_node_t

private

◆ for_loop_node_t

template<typename T >

typedef details::for_loop_node<T> exprtk::parser< T >::for_loop_node_t

private

◆ for_loop_rtc_node_t

template<typename T >

typedef details::for_loop_rtc_node<T> exprtk::parser< T >::for_loop_rtc_node_t

private

◆ functor_t

template<typename T >

typedef details::functor_t<T> exprtk::parser< T >::functor_t

private

◆ generic_string_range_node_t

template<typename T >

typedef details::generic_string_range_node<T> exprtk::parser< T >::generic_string_range_node_t

private

◆ GF

template<typename T >

typedef igeneric_function<T> exprtk::parser< T >::GF

private

◆ ifunction_t

template<typename T >

typedef ifunction<T> exprtk::parser< T >::ifunction_t

private

◆ igeneric_function_t

template<typename T >

typedef igeneric_function<T> exprtk::parser< T >::igeneric_function_t

private

◆ immutable_memory_map_t

template<typename T >

typedef interval_container_t<const void*> exprtk::parser< T >::immutable_memory_map_t

private

◆ immutable_symtok_map_t

template<typename T >

typedef std::map<interval_t,token_t> exprtk::parser< T >::immutable_symtok_map_t

private

◆ interval_t

template<typename T >

typedef interval_container_t<const void*>::interval_t exprtk::parser< T >::interval_t

private

◆ inv_binary_op_map_t

template<typename T >

typedef std::map<binary_functor_t,operator_t> exprtk::parser< T >::inv_binary_op_map_t

private

◆ ivararg_function_t

template<typename T >

typedef ivararg_function<T> exprtk::parser< T >::ivararg_function_t

private

◆ literal_node_t

template<typename T >

typedef details::literal_node<T> exprtk::parser< T >::literal_node_t

private

◆ operator_t

template<typename T >

typedef details::operator_type exprtk::parser< T >::operator_t

private

◆ prsrhlpr_t

template<typename T >

typedef parser_helper exprtk::parser< T >::prsrhlpr_t

private

◆ quaternary_functor_t

template<typename T >

typedef functor_t::qfunc_t exprtk::parser< T >::quaternary_functor_t

private

◆ quaternary_node_t

template<typename T >

typedef details::quaternary_node<T> exprtk::parser< T >::quaternary_node_t

private

◆ range_t

template<typename T >

typedef details::range_pack<T> exprtk::parser< T >::range_t

private

◆ rebasevector_celem_node_t

template<typename T >

typedef details::rebasevector_celem_node<T> exprtk::parser< T >::rebasevector_celem_node_t

private

◆ rebasevector_celem_rtc_node_t

template<typename T >

typedef details::rebasevector_celem_rtc_node<T> exprtk::parser< T >::rebasevector_celem_rtc_node_t

private

◆ rebasevector_elem_node_t

template<typename T >

typedef details::rebasevector_elem_node<T> exprtk::parser< T >::rebasevector_elem_node_t

private

◆ rebasevector_elem_rtc_node_t

template<typename T >

typedef details::rebasevector_elem_rtc_node<T> exprtk::parser< T >::rebasevector_elem_rtc_node_t

private

◆ repeat_until_loop_bc_node_t

template<typename T >

typedef details::repeat_until_loop_bc_node<T> exprtk::parser< T >::repeat_until_loop_bc_node_t

private

◆ repeat_until_loop_bc_rtc_node_t

template<typename T >

typedef details::repeat_until_loop_bc_rtc_node<T> exprtk::parser< T >::repeat_until_loop_bc_rtc_node_t

private

◆ repeat_until_loop_node_t

template<typename T >

typedef details::repeat_until_loop_node<T> exprtk::parser< T >::repeat_until_loop_node_t

private

◆ repeat_until_loop_rtc_node_t

template<typename T >

typedef details::repeat_until_loop_rtc_node<T> exprtk::parser< T >::repeat_until_loop_rtc_node_t

private

◆ results_context_t

template<typename T >

typedef results_context<T> exprtk::parser< T >::results_context_t

private

◆ scand_node_t

template<typename T >

typedef details::scand_node<T> exprtk::parser< T >::scand_node_t

private

◆ scor_node_t

template<typename T >

typedef details::scor_node<T> exprtk::parser< T >::scor_node_t

private

◆ settings_t

template<typename T >

typedef settings_store exprtk::parser< T >::settings_t

◆ sf3_map_t

template<typename T >

typedef std::map<std::string,std::pair<trinary_functor_t ,operator_t> > exprtk::parser< T >::sf3_map_t

private

◆ sf4_map_t

template<typename T >

typedef std::map<std::string,std::pair<quaternary_functor_t,operator_t> > exprtk::parser< T >::sf4_map_t

private

◆ string_concat_node_t

template<typename T >

typedef details::string_concat_node<T> exprtk::parser< T >::string_concat_node_t

private

◆ string_literal_node_t

template<typename T >

typedef details::string_literal_node<T> exprtk::parser< T >::string_literal_node_t

private

◆ string_range_node_t

template<typename T >

typedef details::string_range_node<T> exprtk::parser< T >::string_range_node_t

private

◆ stringvar_node_t

template<typename T >

typedef details::stringvar_node<T> exprtk::parser< T >::stringvar_node_t

private

◆ switch_node_t

template<typename T >

typedef details::switch_node<T> exprtk::parser< T >::switch_node_t

private

◆ symbol_table_list_t

template<typename T >

typedef expression<T>::symtab_list_t exprtk::parser< T >::symbol_table_list_t

private

◆ symbol_table_t

template<typename T >

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

private

◆ token_t

template<typename T >

typedef lexer::token exprtk::parser< T >::token_t

private

◆ trinary_functor_t

template<typename T >

typedef functor_t::tfunc_t exprtk::parser< T >::trinary_functor_t

private

◆ trinary_node_t

template<typename T >

typedef details::trinary_node<T> exprtk::parser< T >::trinary_node_t

private

◆ trinary_op_map_t

template<typename T >

typedef std::map<operator_t, trinary_functor_t> exprtk::parser< T >::trinary_op_map_t

private

◆ unary_functor_t

template<typename T >

typedef functor_t::ufunc_t exprtk::parser< T >::unary_functor_t

private

◆ unary_node_t

template<typename T >

typedef details::unary_node<T> exprtk::parser< T >::unary_node_t

private

◆ unary_op_map_t

template<typename T >

typedef std::map<operator_t, unary_functor_t > exprtk::parser< T >::unary_op_map_t

private

◆ VAF

template<typename T >

typedef ivararg_function<T> exprtk::parser< T >::VAF

private

◆ variable_node_t

template<typename T >

typedef details::variable_node<T> exprtk::parser< T >::variable_node_t

private

◆ vector_celem_node_t

template<typename T >

typedef details::vector_celem_node<T> exprtk::parser< T >::vector_celem_node_t

private

◆ vector_celem_rtc_node_t

template<typename T >

typedef details::vector_celem_rtc_node<T> exprtk::parser< T >::vector_celem_rtc_node_t

private

◆ vector_elem_node_t

template<typename T >

typedef details::vector_elem_node<T> exprtk::parser< T >::vector_elem_node_t

private

◆ vector_elem_rtc_node_t

template<typename T >

typedef details::vector_elem_rtc_node<T> exprtk::parser< T >::vector_elem_rtc_node_t

private

◆ vector_holder_ptr

template<typename T >

typedef vector_holder_t* exprtk::parser< T >::vector_holder_ptr

private

◆ vector_holder_t

template<typename T >

typedef details::vector_holder<T> exprtk::parser< T >::vector_holder_t

private

◆ vector_node_t

template<typename T >

typedef details::vector_node<T> exprtk::parser< T >::vector_node_t

private

◆ vector_size_node_t

template<typename T >

typedef details::vector_size_node<T> exprtk::parser< T >::vector_size_node_t

private

◆ voc_t

template<typename T >

typedef details::T0oT1_define<T, cref_t , const_t> exprtk::parser< T >::voc_t

private

◆ vococ_t

template<typename T >

typedef details::T0oT1oT2_define<T, cref_t , const_t, const_t> exprtk::parser< T >::vococ_t

private

◆ vococov_t

template<typename T >

typedef details::T0oT1oT2oT3_define<T, cref_t , const_t, const_t, cref_t > exprtk::parser< T >::vococov_t

private

◆ vocov_t

template<typename T >

typedef details::T0oT1oT2_define<T, cref_t , const_t, cref_t > exprtk::parser< T >::vocov_t

private

◆ vocovoc_t

template<typename T >

typedef details::T0oT1oT2oT3_define<T, cref_t , const_t, cref_t , const_t> exprtk::parser< T >::vocovoc_t

private

◆ vocovov_t

template<typename T >

typedef details::T0oT1oT2oT3_define<T, cref_t , const_t, cref_t , cref_t > exprtk::parser< T >::vocovov_t

private

◆ vov_t

template<typename T >

typedef details::T0oT1_define<T, cref_t , cref_t > exprtk::parser< T >::vov_t

private

◆ vovoc_t

template<typename T >

typedef details::T0oT1oT2_define<T, cref_t , cref_t , const_t> exprtk::parser< T >::vovoc_t

private

◆ vovocov_t

template<typename T >

typedef details::T0oT1oT2oT3_define<T, cref_t , cref_t , const_t, cref_t > exprtk::parser< T >::vovocov_t

private

◆ vovov_t

template<typename T >

typedef details::T0oT1oT2_define<T, cref_t , cref_t , cref_t > exprtk::parser< T >::vovov_t

private

◆ vovovoc_t

template<typename T >

typedef details::T0oT1oT2oT3_define<T, cref_t , cref_t , cref_t , const_t> exprtk::parser< T >::vovovoc_t

private

◆ vovovov_t

template<typename T >

typedef details::T0oT1oT2oT3_define<T, cref_t , cref_t , cref_t , cref_t > exprtk::parser< T >::vovovov_t

private

◆ while_loop_bc_node_t

template<typename T >

typedef details::while_loop_bc_node<T> exprtk::parser< T >::while_loop_bc_node_t

private

◆ while_loop_bc_rtc_node_t

template<typename T >

typedef details::while_loop_bc_rtc_node<T> exprtk::parser< T >::while_loop_bc_rtc_node_t

private

◆ while_loop_node_t

template<typename T >

typedef details::while_loop_node<T> exprtk::parser< T >::while_loop_node_t

private

◆ while_loop_rtc_node_t

template<typename T >

typedef details::while_loop_rtc_node<T> exprtk::parser< T >::while_loop_rtc_node_t

private

Member Enumeration Documentation

◆ collect_type

template<typename T >

enum exprtk::parser::collect_type

Enumerator
e_ct_none
e_ct_variables
e_ct_functions
e_ct_assignments

◆ precedence_level

template<typename T >

enum exprtk::parser::precedence_level

private

Enumerator
e_level00
e_level01
e_level02
e_level03
e_level04
e_level05
e_level06
e_level07
e_level08
e_level09
e_level10
e_level11
e_level12
e_level13
e_level14

◆ symbol_type

template<typename T >

enum exprtk::parser::symbol_type

Enumerator
e_st_unknown
e_st_variable
e_st_vector
e_st_vecelem
e_st_string
e_st_function
e_st_local_variable
e_st_local_vector
e_st_local_string

Constructor & Destructor Documentation

◆ parser() [1/2]

template<typename T >

exprtk::parser< T >::parser ( const settings_t & settings = settings_t() )

inlineexplicit

◆ ~parser()

template<typename T >

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

inline

◆ parser() [2/2]

template<typename T >

exprtk::parser< T >::parser ( const parser< T > & )

private

Member Function Documentation

◆ clear_compilation_timeout_check()

template<typename T >

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

inline

◆ clear_loop_runtime_check()

template<typename T >

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

inline

◆ clear_vector_access_runtime_check()

template<typename T >

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

inline

◆ compile() [1/2]

template<typename T >

bool exprtk::parser< T >::compile	(	const std::string &	expression_string,
		expression< T > &	expr
	)

inline

◆ compile() [2/2]

template<typename T >

expression_t exprtk::parser< T >::compile	(	const std::string &	expression_string,
		symbol_table_t &	symtab
	)

inline

◆ construct_subexpr()

template<typename T >

std::string exprtk::parser< T >::construct_subexpr	(	lexer::token &	begin_token,
		lexer::token &	end_token
	)

inlineprivate

◆ current_state()

template<typename T >

state_t exprtk::parser< T >::current_state ( ) const

inlineprivate

◆ dec()

template<typename T >

dependent_entity_collector& exprtk::parser< T >::dec ( )

inline

◆ disable_unknown_symbol_resolver()

template<typename T >

void exprtk::parser< T >::disable_unknown_symbol_resolver ( )

inline

◆ enable_unknown_symbol_resolver() [1/2]

template<typename T >

void exprtk::parser< T >::enable_unknown_symbol_resolver ( unknown_symbol_resolver & usr )

inline

◆ enable_unknown_symbol_resolver() [2/2]

template<typename T >

void exprtk::parser< T >::enable_unknown_symbol_resolver ( unknown_symbol_resolver * usr = reinterpret_cast<unknown_symbol_resolver*>(0) )

inline

◆ error()

template<typename T >

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

inline

◆ error_count()

template<typename T >

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

inline

◆ error_node()

template<typename T >

static expression_node_ptr exprtk::parser< T >::error_node ( )

inlinestaticprivate

◆ get_error()

template<typename T >

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

inline

◆ halt_compilation_check()

template<typename T >

bool exprtk::parser< T >::halt_compilation_check ( )

inlineprivate

◆ handle_brkcnt_scope_exit()

template<typename T >

void exprtk::parser< T >::handle_brkcnt_scope_exit ( )

inlineprivate

◆ init_precompilation()

template<typename T >

void exprtk::parser< T >::init_precompilation ( )

inline

◆ is_invalid_arithmetic_operation()

template<typename T >

bool exprtk::parser< T >::is_invalid_arithmetic_operation ( const details::operator_type operation ) const

inlineprivate

◆ is_invalid_assignment_operation()

template<typename T >

bool exprtk::parser< T >::is_invalid_assignment_operation ( const details::operator_type operation ) const

inlineprivate

◆ is_invalid_inequality_operation()

template<typename T >

bool exprtk::parser< T >::is_invalid_inequality_operation ( const details::operator_type operation ) const

inlineprivate

◆ is_invalid_logic_operation()

template<typename T >

bool exprtk::parser< T >::is_invalid_logic_operation ( const details::operator_type operation ) const

inlineprivate

◆ load_binary_operations_map()

template<typename T >

void exprtk::parser< T >::load_binary_operations_map ( binary_op_map_t & m )

inlineprivate

◆ load_inv_binary_operations_map()

template<typename T >

void exprtk::parser< T >::load_inv_binary_operations_map ( inv_binary_op_map_t & m )

inlineprivate

◆ load_sf3_map()

template<typename T >

void exprtk::parser< T >::load_sf3_map ( sf3_map_t & sf3_map )

inlineprivate

◆ load_sf4_map()

template<typename T >

void exprtk::parser< T >::load_sf4_map ( sf4_map_t & sf4_map )

inlineprivate

◆ load_unary_operations_map()

template<typename T >

void exprtk::parser< T >::load_unary_operations_map ( unary_op_map_t & m )

inlineprivate

◆ local_variable_is_shadowed()

template<typename T >

bool exprtk::parser< T >::local_variable_is_shadowed ( const std::string & symbol )

inlineprivate

◆ lodge_immutable_symbol()

template<typename T >

void exprtk::parser< T >::lodge_immutable_symbol	(	const lexer::token &	token,
		const interval_t	interval
	)

inlineprivate

◆ lodge_symbol()

template<typename T >

void exprtk::parser< T >::lodge_symbol	(	const std::string &	symbol,
		const symbol_type	st
	)

inlineprivate

◆ make_memory_range() [1/3]

template<typename T >

interval_t exprtk::parser< T >::make_memory_range ( const T & t )

inlineprivate

◆ make_memory_range() [2/3]

template<typename T >

interval_t exprtk::parser< T >::make_memory_range	(	const T *	begin,
		const std::size_t	size
	)

inlineprivate

◆ make_memory_range() [3/3]

template<typename T >

interval_t exprtk::parser< T >::make_memory_range	(	details::char_cptr	begin,
		const std::size_t	size
	)

inlineprivate

◆ operator=()

template<typename T >

parser<T>& exprtk::parser< T >::operator= ( const parser< T > & )

private

◆ parse_base_function_call()

template<typename T >

template<std::size_t MaxNumberofParameters>

std::size_t exprtk::parser< T >::parse_base_function_call	(	expression_node_ptr(&)	param_list[MaxNumberofParameters],
		const std::string &	function_name = `""`
	)

inlineprivate

◆ parse_base_operation()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_base_operation ( )

inlineprivate

◆ parse_branch()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_branch ( precedence_level precedence = e_level00 )

inlineprivate

◆ parse_break_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_break_statement ( )

inlineprivate

◆ parse_conditional_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_conditional_statement ( )

inlineprivate

◆ parse_conditional_statement_01()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_conditional_statement_01 ( expression_node_ptr condition )

inlineprivate

◆ parse_conditional_statement_02()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_conditional_statement_02 ( expression_node_ptr condition )

inlineprivate

◆ parse_const_string()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_const_string ( )

inlineprivate

◆ parse_continue_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_continue_statement ( )

inlineprivate

◆ parse_corpus()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_corpus ( )

inlineprivate

◆ parse_define_string_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_define_string_statement	(	const std::string &	str_name,
		expression_node_ptr	initialisation_expression
	)

inlineprivate

◆ parse_define_var_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_define_var_statement ( )

inlineprivate

◆ parse_define_vector_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_define_vector_statement ( const std::string & vec_name )

inlineprivate

◆ parse_expression()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_expression ( precedence_level precedence = e_level00 )

inlineprivate

◆ parse_for_loop()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_for_loop ( )

inlineprivate

◆ parse_function_call()

template<typename T >

template<std::size_t NumberofParameters>

expression_node_ptr exprtk::parser< T >::parse_function_call	(	ifunction< T > *	function,
		const std::string &	function_name
	)

inlineprivate

◆ parse_function_call_0()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_function_call_0	(	ifunction< T > *	function,
		const std::string &	function_name
	)

inlineprivate

◆ parse_function_invocation()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_function_invocation	(	ifunction< T > *	function,
		const std::string &	function_name
	)

inlineprivate

◆ parse_generic_function_call()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_generic_function_call	(	igeneric_function< T > *	function,
		const std::string &	function_name
	)

inlineprivate

◆ parse_igeneric_function_params()

template<typename T >

bool exprtk::parser< T >::parse_igeneric_function_params	(	std::string &	param_type_list,
		std::vector< expression_node_ptr > &	arg_list,
		const std::string &	function_name,
		igeneric_function< T > *	function,
		const type_checker &	tc
	)

inlineprivate

◆ parse_multi_sequence()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_multi_sequence	(	const std::string &	source = `""`,
		const bool	enforce_crlbrackets = `false`
	)

inlineprivate

◆ parse_multi_switch_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_multi_switch_statement ( )

inlineprivate

◆ parse_not_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_not_statement ( )

inlineprivate

◆ parse_null_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_null_statement ( )

inlineprivate

◆ parse_overload_function_call()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_overload_function_call	(	igeneric_function< T > *	function,
		const std::string &	function_name
	)

inlineprivate

◆ parse_pending_string_rangesize()

template<typename T >

bool exprtk::parser< T >::parse_pending_string_rangesize ( expression_node_ptr & expression )

inlineprivate

◆ parse_pending_vector_index_operator()

template<typename T >

void exprtk::parser< T >::parse_pending_vector_index_operator ( expression_node_ptr & expression )

inlineprivate

◆ parse_range()

template<typename T >

bool exprtk::parser< T >::parse_range	(	range_t &	rp,
		const bool	skip_lsqr = `false`
	)

inlineprivate

◆ parse_repeat_until_loop()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_repeat_until_loop ( )

inlineprivate

◆ parse_return_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_return_statement ( )

inlineprivate

◆ parse_special_function()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_special_function ( )

inlineprivate

◆ parse_string()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_string ( )

inlineprivate

◆ parse_string_function_call()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_string_function_call	(	igeneric_function< T > *	function,
		const std::string &	function_name
	)

inlineprivate

◆ parse_string_range_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_string_range_statement ( expression_node_ptr & expression )

inlineprivate

◆ parse_swap_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_swap_statement ( )

inlineprivate

◆ parse_switch_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_switch_statement ( )

inlineprivate

◆ parse_symbol()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_symbol ( )

inlineprivate

◆ parse_symtab_symbol()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_symtab_symbol ( )

inlineprivate

◆ parse_ternary_conditional_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_ternary_conditional_statement ( expression_node_ptr condition )

inlineprivate

◆ parse_uninitialised_var_statement()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_uninitialised_var_statement ( const std::string & var_name )

inlineprivate

◆ parse_vararg_function()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_vararg_function ( )

inlineprivate

◆ parse_vararg_function_call()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_vararg_function_call	(	ivararg_function< T > *	vararg_function,
		const std::string &	vararg_function_name
	)

inlineprivate

◆ parse_vector()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_vector ( )

inlineprivate

◆ parse_vector_index()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_vector_index ( const std::string & vector_name = "" )

inlineprivate

◆ parse_while_loop()

template<typename T >

expression_node_ptr exprtk::parser< T >::parse_while_loop ( )

inlineprivate

◆ pop_current_state()

template<typename T >

void exprtk::parser< T >::pop_current_state ( )

inlineprivate

◆ post_bracket_process()

template<typename T >

bool exprtk::parser< T >::post_bracket_process	(	const typename token_t::token_type &	token,
		expression_node_ptr &	branch
	)

inlineprivate

◆ post_variable_process()

template<typename T >

bool exprtk::parser< T >::post_variable_process ( const std::string & symbol )

inlineprivate

◆ process_lexer_errors()

template<typename T >

void exprtk::parser< T >::process_lexer_errors ( )

inline

◆ push_current_state()

template<typename T >

void exprtk::parser< T >::push_current_state ( const state_t current_state )

inlineprivate

◆ register_compilation_timeout_check()

template<typename T >

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

inline

◆ register_local_vars()

template<typename T >

void exprtk::parser< T >::register_local_vars ( expression< T > & e )

inlineprivate

◆ register_loop_runtime_check()

template<typename T >

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

inline

◆ register_return_results()

template<typename T >

void exprtk::parser< T >::register_return_results ( expression< T > & e )

inlineprivate

◆ register_vector_access_runtime_check()

template<typename T >

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

inline

◆ remove_last_error()

template<typename T >

void exprtk::parser< T >::remove_last_error ( )

inlineprivate

◆ remove_replace_symbol()

template<typename T >

bool exprtk::parser< T >::remove_replace_symbol ( const std::string & symbol )

inline

◆ replace_symbol()

template<typename T >

bool exprtk::parser< T >::replace_symbol	(	const std::string &	old_symbol,
		const std::string &	new_symbol
	)

inline

◆ results_ctx()

template<typename T >

results_context_t& exprtk::parser< T >::results_ctx ( )

inlineprivate

◆ return_cleanup()

template<typename T >

void exprtk::parser< T >::return_cleanup ( )

inlineprivate

◆ run_assemblies()

template<typename T >

bool exprtk::parser< T >::run_assemblies ( )

inline

◆ set_error()

template<typename T >

void exprtk::parser< T >::set_error ( const parser_error::type & error_type )

inlineprivate

◆ set_synthesis_error()

template<typename T >

void exprtk::parser< T >::set_synthesis_error ( const std::string & synthesis_error_message )

inlineprivate

◆ settings()

template<typename T >

settings_store& exprtk::parser< T >::settings ( )

inline

◆ simplify()

template<typename T >

template<typename Allocator1 , typename Allocator2 , template< typename, typename > class Sequence>

expression_node_ptr exprtk::parser< T >::simplify	(	Sequence< expression_node_ptr, Allocator1 > &	expression_list,
		Sequence< bool, Allocator2 > &	side_effect_list,
		const bool	specialise_on_final_type = `false`
	)

inlineprivate

◆ simplify_unary_negation_branch()

template<typename T >

bool exprtk::parser< T >::simplify_unary_negation_branch ( expression_node_ptr & node )

inlineprivate

◆ synthesize_vector_element()

template<typename T >

expression_node_ptr exprtk::parser< T >::synthesize_vector_element	(	const std::string &	vector_name,
		vector_holder_ptr	vec,
		expression_node_ptr	vec_node,
		expression_node_ptr	index_expr
	)

inlineprivate

◆ valid_base_operation()

template<typename T >

bool exprtk::parser< T >::valid_base_operation ( const std::string & symbol ) const

inlineprivate

◆ valid_vararg_operation()

template<typename T >

bool exprtk::parser< T >::valid_vararg_operation ( const std::string & symbol ) const

inlineprivate

Friends And Related Function Documentation

◆ details::disable_type_checking

template<typename T >

template<typename ParserType >

void details::disable_type_checking ( ParserType & p )

friend

Member Data Documentation

◆ base_ops_map_

template<typename T >

base_ops_map_t exprtk::parser< T >::base_ops_map_

private

◆ binary_op_map_

template<typename T >

binary_op_map_t exprtk::parser< T >::binary_op_map_

private

◆ bracket_checker_

template<typename T >

lexer::helper::bracket_checker exprtk::parser< T >::bracket_checker_

private

◆ brkcnt_list_

template<typename T >

std::deque<bool> exprtk::parser< T >::brkcnt_list_

private

◆ commutative_inserter_

template<typename T >

lexer::helper::commutative_inserter exprtk::parser< T >::commutative_inserter_

private

◆ compilation_check_ptr_

template<typename T >

compilation_check_ptr exprtk::parser< T >::compilation_check_ptr_

private

◆ current_state_stack_

template<typename T >

std::vector<state_t> exprtk::parser< T >::current_state_stack_

private

◆ dec_

template<typename T >

dependent_entity_collector exprtk::parser< T >::dec_

private

◆ default_precedence

template<typename T >

const precedence_level exprtk::parser< T >::default_precedence = e_level00

staticprivate

◆ default_usr_

template<typename T >

unknown_symbol_resolver exprtk::parser< T >::default_usr_

private

◆ error_list_

template<typename T >

std::deque<parser_error::type> exprtk::parser< T >::error_list_

private

◆ expression_generator_

template<typename T >

expression_generator<T> exprtk::parser< T >::expression_generator_

private

◆ helper_assembly_

template<typename T >

lexer::helper::helper_assembly exprtk::parser< T >::helper_assembly_

private

◆ immutable_memory_map_

template<typename T >

immutable_memory_map_t exprtk::parser< T >::immutable_memory_map_

private

◆ immutable_symtok_map_

template<typename T >

immutable_symtok_map_t exprtk::parser< T >::immutable_symtok_map_

private

◆ inv_binary_op_map_

template<typename T >

inv_binary_op_map_t exprtk::parser< T >::inv_binary_op_map_

private

◆ loop_runtime_check_

template<typename T >

loop_runtime_check_ptr exprtk::parser< T >::loop_runtime_check_

private

◆ node_allocator_

template<typename T >

details::node_allocator exprtk::parser< T >::node_allocator_

private

◆ numeric_checker_

template<typename T >

lexer::helper::numeric_checker<T> exprtk::parser< T >::numeric_checker_

private

◆ operator_joiner_2_

template<typename T >

lexer::helper::operator_joiner exprtk::parser< T >::operator_joiner_2_

private

◆ operator_joiner_3_

template<typename T >

lexer::helper::operator_joiner exprtk::parser< T >::operator_joiner_3_

private

◆ resolve_unknown_symbol_

template<typename T >

bool exprtk::parser< T >::resolve_unknown_symbol_

private

◆ results_context_

template<typename T >

results_context_t* exprtk::parser< T >::results_context_

private

◆ sem_

template<typename T >

scope_element_manager exprtk::parser< T >::sem_

private

◆ sequence_validator_

template<typename T >

lexer::helper::sequence_validator exprtk::parser< T >::sequence_validator_

private

◆ sequence_validator_3tkns_

template<typename T >

lexer::helper::sequence_validator_3tokens exprtk::parser< T >::sequence_validator_3tkns_

private

◆ settings_

template<typename T >

settings_store exprtk::parser< T >::settings_

private

◆ sf3_map_

template<typename T >

sf3_map_t exprtk::parser< T >::sf3_map_

private

◆ sf4_map_

template<typename T >

sf4_map_t exprtk::parser< T >::sf4_map_

private

◆ state_

template<typename T >

parser_state exprtk::parser< T >::state_

private

◆ symbol_replacer_

template<typename T >

lexer::helper::symbol_replacer exprtk::parser< T >::symbol_replacer_

private

◆ symtab_store_

template<typename T >

symtab_store exprtk::parser< T >::symtab_store_

private

◆ synthesis_error_

template<typename T >

std::string exprtk::parser< T >::synthesis_error_

private

◆ unary_op_map_

template<typename T >

unary_op_map_t exprtk::parser< T >::unary_op_map_

private

◆ unknown_symbol_resolver_

template<typename T >

unknown_symbol_resolver* exprtk::parser< T >::unknown_symbol_resolver_

private

◆ vector_access_runtime_check_

template<typename T >

vector_access_runtime_check_ptr exprtk::parser< T >::vector_access_runtime_check_

private

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

/home/granoo/granoo/Lib/GranOO3/Math/Exprtk.hpp

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Member Typedef Documentation

◆ assignment_node_t

◆ assignment_rebasevec_celem_node_t

◆ assignment_rebasevec_elem_node_t

◆ assignment_rebasevec_elem_rtc_node_t

◆ assignment_string_node_t

◆ assignment_string_range_node_t

◆ assignment_vec_elem_node_t

◆ assignment_vec_elem_rtc_node_t

◆ assignment_vec_node_t

◆ assignment_vecvec_node_t

◆ base_ops_map_t

◆ binary_functor_t

◆ binary_node_t

◆ binary_op_map_t

◆ cocov_t

◆ conditional_node_t

◆ conditional_string_node_t

◆ conditional_vector_node_t

◆ cons_conditional_node_t

◆ cons_conditional_str_node_t

◆ const_string_range_node_t

◆ const_t

◆ cov_t

◆ covoc_t

◆ covocov_t

◆ covov_t

◆ covovoc_t

◆ covovov_t

◆ cref_t

◆ disabled_func_set_t

◆ expression_node_ptr

◆ expression_node_t

◆ expression_t

◆ F

◆ for_loop_bc_node_t

◆ for_loop_bc_rtc_node_t

◆ for_loop_node_t

◆ for_loop_rtc_node_t

◆ functor_t

◆ generic_string_range_node_t

◆ GF

◆ ifunction_t

◆ igeneric_function_t

◆ immutable_memory_map_t

◆ immutable_symtok_map_t

◆ interval_t

◆ inv_binary_op_map_t

◆ ivararg_function_t

◆ literal_node_t

◆ operator_t

◆ prsrhlpr_t

◆ quaternary_functor_t

◆ quaternary_node_t

◆ range_t

◆ rebasevector_celem_node_t

◆ rebasevector_celem_rtc_node_t

◆ rebasevector_elem_node_t

◆ rebasevector_elem_rtc_node_t

◆ repeat_until_loop_bc_node_t

◆ repeat_until_loop_bc_rtc_node_t

◆ repeat_until_loop_node_t

◆ repeat_until_loop_rtc_node_t

◆ results_context_t

◆ scand_node_t

◆ scor_node_t

◆ settings_t

◆ sf3_map_t

◆ sf4_map_t

◆ string_concat_node_t

◆ string_literal_node_t