#include <exprtk.hpp>

Inheritance diagram for exprtk::parser< T >:

Collaboration diagram for exprtk::parser< T >:

Classes
struct	scope_element
class	scope_element_manager
class	scope_handler
struct	halfopen_range_policy
struct	closed_range_policy
class	interval_container_t
class	stack_limit_handler
struct	symtab_store
struct	parser_state
struct	unknown_symbol_resolver
class	dependent_entity_collector
class	settings_store
struct	state_t
struct	scoped_expression_delete
struct	scoped_delete
struct	scoped_deq_delete
struct	scoped_vec_delete
struct	scoped_bool_negator
struct	scoped_bool_or_restorer
struct	scoped_inc_dec
class	type_checker
struct	parse_special_function_impl
class	expression_generator

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 ()
std::size_t	total_local_symbol_size_bytes () const
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	register_assert_check (assert_check &assrt_chck)
void	clear_loop_runtime_check ()
void	clear_vector_access_runtime_check ()
void	clear_compilation_timeout_check ()
void	clear_assert_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_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< constvoid * >::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, const bool cleanup_whitespace=true)
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_define_constvar_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 ()
expression_node_ptr	parse_assert_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	check_block_statement_closure (expression_node_ptr expression)
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 ()
bool	valid_settings ()
	parser (const parser< T > &)
parser< T > &	operator= (const parser< T > &)

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_
assert_check_ptr	assert_check_
std::set< std::string >	assert_ids_

Static Private Attributes
static const precedence_level	default_precedence = e_level00

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

Detailed Description

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

Definition at line 22524 of file exprtk.hpp.

Member Typedef Documentation

◆ assignment_node_t

template<typename T>

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

private

Definition at line 22590 of file exprtk.hpp.

◆ assignment_rebasevec_celem_node_t

template<typename T>

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

private

Definition at line 22595 of file exprtk.hpp.

◆ assignment_rebasevec_elem_node_t

template<typename T>

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

private

Definition at line 22593 of file exprtk.hpp.

◆ 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

Definition at line 22594 of file exprtk.hpp.

◆ assignment_string_node_t

template<typename T>

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

private

Definition at line 22585 of file exprtk.hpp.

◆ assignment_string_range_node_t

template<typename T>

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

private

Definition at line 22586 of file exprtk.hpp.

◆ assignment_vec_elem_node_t

template<typename T>

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

private

Definition at line 22591 of file exprtk.hpp.

◆ 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

Definition at line 22592 of file exprtk.hpp.

◆ assignment_vec_node_t

template<typename T>

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

private

Definition at line 22596 of file exprtk.hpp.

◆ assignment_vecvec_node_t

template<typename T>

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

private

Definition at line 22597 of file exprtk.hpp.

◆ 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

Definition at line 22625 of file exprtk.hpp.

◆ binary_functor_t

template<typename T>

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

private

Definition at line 22612 of file exprtk.hpp.

◆ binary_node_t

template<typename T>

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

private

Definition at line 22546 of file exprtk.hpp.

◆ binary_op_map_t

template<typename T>

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

private

Definition at line 22618 of file exprtk.hpp.

◆ cocov_t

template<typename T>

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

private

Definition at line 22637 of file exprtk.hpp.

◆ conditional_node_t

template<typename T>

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

private

Definition at line 22549 of file exprtk.hpp.

◆ conditional_string_node_t

template<typename T>

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

private

Definition at line 22587 of file exprtk.hpp.

◆ conditional_vector_node_t

template<typename T>

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

private

Definition at line 22598 of file exprtk.hpp.

◆ cons_conditional_node_t

template<typename T>

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

private

Definition at line 22550 of file exprtk.hpp.

◆ cons_conditional_str_node_t

template<typename T>

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

private

Definition at line 22588 of file exprtk.hpp.

◆ const_string_range_node_t

template<typename T>

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

private

Definition at line 22582 of file exprtk.hpp.

◆ const_t

template<typename T>

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

private

Definition at line 22536 of file exprtk.hpp.

◆ cov_t

template<typename T>

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

private

Definition at line 22629 of file exprtk.hpp.

◆ covoc_t

template<typename T>

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

private

Definition at line 22636 of file exprtk.hpp.

◆ covocov_t

template<typename T>

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

private

Definition at line 22646 of file exprtk.hpp.

◆ covov_t

template<typename T>

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

private

Definition at line 22635 of file exprtk.hpp.

◆ covovoc_t

template<typename T>

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

private

Definition at line 22648 of file exprtk.hpp.

◆ covovov_t

template<typename T>

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

private

Definition at line 22644 of file exprtk.hpp.

◆ cref_t

template<typename T>

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

private

Definition at line 22535 of file exprtk.hpp.

◆ disabled_func_set_t

template<typename T>

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

private

Definition at line 22626 of file exprtk.hpp.

◆ expression_node_ptr

template<typename T>

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

private

Definition at line 22602 of file exprtk.hpp.

◆ expression_node_t

template<typename T>

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

private

Definition at line 22543 of file exprtk.hpp.

◆ expression_t

template<typename T>

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

private

Definition at line 22603 of file exprtk.hpp.

◆ F

template<typename T>

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

private

Definition at line 22537 of file exprtk.hpp.

◆ for_loop_bc_node_t

template<typename T>

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

private

Definition at line 22560 of file exprtk.hpp.

◆ 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

Definition at line 22563 of file exprtk.hpp.

◆ for_loop_node_t

template<typename T>

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

private

Definition at line 22553 of file exprtk.hpp.

◆ for_loop_rtc_node_t

template<typename T>

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

private

Definition at line 22556 of file exprtk.hpp.

◆ functor_t

template<typename T>

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

private

Definition at line 22609 of file exprtk.hpp.

◆ generic_string_range_node_t

template<typename T>

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

private

Definition at line 22583 of file exprtk.hpp.

◆ GF

template<typename T>

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

private

Definition at line 22539 of file exprtk.hpp.

◆ ifunction_t

template<typename T>

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

private

Definition at line 22540 of file exprtk.hpp.

◆ igeneric_function_t

template<typename T>

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

private

Definition at line 22542 of file exprtk.hpp.

◆ immutable_memory_map_t

template<typename T>

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

private

Definition at line 31155 of file exprtk.hpp.

◆ immutable_symtok_map_t

template<typename T>

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

private

Definition at line 31156 of file exprtk.hpp.

◆ interval_t

template<typename T>

typedef interval_container_t<constvoid*>::interval_t exprtk::parser< T >::interval_t

private

Definition at line 31154 of file exprtk.hpp.

◆ 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

Definition at line 22624 of file exprtk.hpp.

◆ ivararg_function_t

template<typename T>

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

private

Definition at line 22541 of file exprtk.hpp.

◆ literal_node_t

template<typename T>

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

private

Definition at line 22544 of file exprtk.hpp.

◆ operator_t

template<typename T>

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

private

Definition at line 22615 of file exprtk.hpp.

◆ prsrhlpr_t

template<typename T>

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

private

Definition at line 22653 of file exprtk.hpp.

◆ quaternary_functor_t

template<typename T>

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

private

Definition at line 22610 of file exprtk.hpp.

◆ quaternary_node_t

template<typename T>

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

private

Definition at line 22548 of file exprtk.hpp.

◆ range_t

template<typename T>

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

private

Definition at line 22577 of file exprtk.hpp.

◆ rebasevector_celem_node_t

template<typename T>

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

private

Definition at line 22572 of file exprtk.hpp.

◆ rebasevector_celem_rtc_node_t

template<typename T>

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

private

Definition at line 22574 of file exprtk.hpp.

◆ rebasevector_elem_node_t

template<typename T>

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

private

Definition at line 22571 of file exprtk.hpp.

◆ rebasevector_elem_rtc_node_t

template<typename T>

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

private

Definition at line 22573 of file exprtk.hpp.

◆ 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

Definition at line 22559 of file exprtk.hpp.

◆ 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

Definition at line 22562 of file exprtk.hpp.

◆ repeat_until_loop_node_t

template<typename T>

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

private

Definition at line 22552 of file exprtk.hpp.

◆ 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

Definition at line 22555 of file exprtk.hpp.

◆ results_context_t

template<typename T>

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

private

Definition at line 22651 of file exprtk.hpp.

◆ scand_node_t

template<typename T>

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

private

Definition at line 22599 of file exprtk.hpp.

◆ scor_node_t

template<typename T>

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

private

Definition at line 22600 of file exprtk.hpp.

◆ settings_t

template<typename T>

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

Definition at line 24718 of file exprtk.hpp.

◆ 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

Definition at line 22621 of file exprtk.hpp.

◆ 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

Definition at line 22622 of file exprtk.hpp.

◆ string_concat_node_t

template<typename T>

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

private

Definition at line 22584 of file exprtk.hpp.

◆ string_literal_node_t

template<typename T>

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

private

Definition at line 22580 of file exprtk.hpp.

◆ string_range_node_t

template<typename T>

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

private

Definition at line 22581 of file exprtk.hpp.

◆ stringvar_node_t

template<typename T>

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

private

Definition at line 22579 of file exprtk.hpp.

◆ switch_node_t

template<typename T>

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

private

Definition at line 22565 of file exprtk.hpp.

◆ symbol_table_list_t

template<typename T>

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

private

Definition at line 22605 of file exprtk.hpp.

◆ symbol_table_t

template<typename T>

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

private

Definition at line 22604 of file exprtk.hpp.

◆ token_t

template<typename T>

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

private

Definition at line 22601 of file exprtk.hpp.

◆ trinary_functor_t

template<typename T>

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

private

Definition at line 22611 of file exprtk.hpp.

◆ trinary_node_t

template<typename T>

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

private

Definition at line 22547 of file exprtk.hpp.

◆ trinary_op_map_t

template<typename T>

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

private

Definition at line 22619 of file exprtk.hpp.

◆ unary_functor_t

template<typename T>

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

private

Definition at line 22613 of file exprtk.hpp.

◆ unary_node_t

template<typename T>

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

private

Definition at line 22545 of file exprtk.hpp.

◆ unary_op_map_t

template<typename T>

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

private

Definition at line 22617 of file exprtk.hpp.

◆ VAF

template<typename T>

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

private

Definition at line 22538 of file exprtk.hpp.

◆ variable_node_t

template<typename T>

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

private

Definition at line 22566 of file exprtk.hpp.

◆ vector_celem_node_t

template<typename T>

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

private

Definition at line 22568 of file exprtk.hpp.

◆ vector_celem_rtc_node_t

template<typename T>

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

private

Definition at line 22570 of file exprtk.hpp.

◆ vector_elem_node_t

template<typename T>

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

private

Definition at line 22567 of file exprtk.hpp.

◆ vector_elem_rtc_node_t

template<typename T>

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

private

Definition at line 22569 of file exprtk.hpp.

◆ vector_holder_ptr

template<typename T>

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

private

Definition at line 22607 of file exprtk.hpp.

◆ vector_holder_t

template<typename T>

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

private

Definition at line 22606 of file exprtk.hpp.

◆ vector_node_t

template<typename T>

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

private

Definition at line 22575 of file exprtk.hpp.

◆ vector_size_node_t

template<typename T>

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

private

Definition at line 22576 of file exprtk.hpp.

◆ voc_t

template<typename T>

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

private

Definition at line 22630 of file exprtk.hpp.

◆ vococ_t

template<typename T>

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

private

Definition at line 22638 of file exprtk.hpp.

◆ vococov_t

template<typename T>

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

private

Definition at line 22649 of file exprtk.hpp.

◆ vocov_t

template<typename T>

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

private

Definition at line 22634 of file exprtk.hpp.

◆ vocovoc_t

template<typename T>

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

private

Definition at line 22647 of file exprtk.hpp.

◆ vocovov_t

template<typename T>

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

private

Definition at line 22643 of file exprtk.hpp.

◆ vov_t

template<typename T>

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

private

Definition at line 22628 of file exprtk.hpp.

◆ vovoc_t

template<typename T>

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

private

Definition at line 22633 of file exprtk.hpp.

◆ vovocov_t

template<typename T>

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

private

Definition at line 22642 of file exprtk.hpp.

◆ vovov_t

template<typename T>

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

private

Definition at line 22632 of file exprtk.hpp.

◆ vovovoc_t

template<typename T>

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

private

Definition at line 22641 of file exprtk.hpp.

◆ vovovov_t

template<typename T>

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

private

Definition at line 22640 of file exprtk.hpp.

◆ while_loop_bc_node_t

template<typename T>

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

private

Definition at line 22558 of file exprtk.hpp.

◆ 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

Definition at line 22561 of file exprtk.hpp.

◆ while_loop_node_t

template<typename T>

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

private

Definition at line 22551 of file exprtk.hpp.

◆ while_loop_rtc_node_t

template<typename T>

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

private

Definition at line 22554 of file exprtk.hpp.

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

Definition at line 23845 of file exprtk.hpp.

      {
         e_ct_none        = 0,
         e_ct_variables   = 1,
         e_ct_functions   = 2,
         e_ct_assignments = 4
      };

◆ 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

Definition at line 22528 of file exprtk.hpp.

      {
         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

Definition at line 23853 of file exprtk.hpp.

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

Constructor & Destructor Documentation

◆ parser() [1/2]

template<typename T>

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

inlineexplicit

Definition at line 24720 of file exprtk.hpp.

      : settings_(settings)
      , resolve_unknown_symbol_(false)
      , results_context_(0)
      , unknown_symbol_resolver_(reinterpret_cast<unknown_symbol_resolver*>(0))
        #ifdef _MSC_VER
        #pragma warning(push)
        #pragma warning (disable:4355)
        #endif
      , sem_(*this)
        #ifdef _MSC_VER
        #pragma warning(pop)
        #endif
      , operator_joiner_2_(2)
      , operator_joiner_3_(3)
      , loop_runtime_check_(0)
      , vector_access_runtime_check_(0)
      , compilation_check_ptr_(0)
      , assert_check_(0)
      {
         init_precompilation();
 
         load_operations_map           (base_ops_map_     );
         load_unary_operations_map     (unary_op_map_     );
         load_binary_operations_map    (binary_op_map_    );
         load_inv_binary_operations_map(inv_binary_op_map_);
         load_sf3_map                  (sf3_map_          );
         load_sf4_map                  (sf4_map_          );
 
         expression_generator_.init_synthesize_map();
         expression_generator_.set_parser(*this);
         expression_generator_.set_uom (unary_op_map_     );
         expression_generator_.set_bom (binary_op_map_    );
         expression_generator_.set_ibom(inv_binary_op_map_);
         expression_generator_.set_sf3m(sf3_map_          );
         expression_generator_.set_sf4m(sf4_map_          );
         expression_generator_.set_strength_reduction_state(settings_.strength_reduction_enabled());
      }

Here is the caller graph for this function:

◆ ~parser()

template<typename T>

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

inline

Definition at line 24759 of file exprtk.hpp.

24760 {}

◆ parser() [2/2]

template<typename T>

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

private

Member Function Documentation

◆ check_block_statement_closure()

template<typename T>

expression_node_ptr exprtk::parser< T >::check_block_statement_closure ( expression_node_ptr expression )

inlineprivate

Definition at line 31519 of file exprtk.hpp.

      {
         if (
              expression &&
              (
                (current_token().type == token_t::e_symbol) ||
                (current_token().type == token_t::e_number)
              )
            )
         {
            free_node(node_allocator_, expression);
 
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR240 - Invalid syntax '" + current_token().value  + "' possible missing operator or context",
               exprtk_error_location));
 
               return error_node();
         }
 
         return expression;
      }

Referenced by exprtk::parser< Type >::parse_symbol(), and exprtk::parser< Type >::parse_vararg_function().

Here is the caller graph for this function:

◆ clear_assert_check()

template<typename T>

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

inline

Definition at line 25215 of file exprtk.hpp.

      {
         assert_check_ = assert_check_ptr(0);
      }

◆ clear_compilation_timeout_check()

template<typename T>

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

inline

Definition at line 25210 of file exprtk.hpp.

      {
         compilation_check_ptr_ = compilation_check_ptr(0);
      }

◆ clear_loop_runtime_check()

template<typename T>

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

inline

Definition at line 25200 of file exprtk.hpp.

      {
         loop_runtime_check_ = loop_runtime_check_ptr(0);
      }

◆ clear_vector_access_runtime_check()

template<typename T>

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

inline

Definition at line 25205 of file exprtk.hpp.

      {
         vector_access_runtime_check_ = vector_access_runtime_check_ptr(0);
      }

◆ compile() [1/2]

template<typename T>

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

inline

Definition at line 24826 of file exprtk.hpp.

      {
         state_               .reset();
         error_list_          .clear();
         brkcnt_list_         .clear();
         synthesis_error_     .clear();
         immutable_memory_map_.reset();
         immutable_symtok_map_.clear();
         current_state_stack_ .clear();
         assert_ids_          .clear();
         sem_                 .cleanup();
 
         return_cleanup();
 
         if (!valid_settings())
         {
            return false;
         }
 
         expression_generator_.set_allocator(node_allocator_);
 
         if (expression_string.empty())
         {
            set_error(make_error(
               parser_error::e_syntax,
               "ERR001 - Empty expression!",
               exprtk_error_location));
 
            return false;
         }
 
         if (!init(expression_string))
         {
            process_lexer_errors();
            return false;
         }
 
         if (lexer().empty())
         {
            set_error(make_error(
               parser_error::e_syntax,
               "ERR002 - Empty expression!",
               exprtk_error_location));
 
            return false;
         }
 
         if (halt_compilation_check())
         {
            exprtk_debug(("halt_compilation_check() - compile checkpoint 0\n"));
            sem_.cleanup();
            return false;
         }
 
         if (!run_assemblies())
         {
            sem_.cleanup();
            return false;
         }
 
         if (halt_compilation_check())
         {
            exprtk_debug(("halt_compilation_check() - compile checkpoint 1\n"));
            sem_.cleanup();
            return false;
         }
 
         symtab_store_.symtab_list_ = expr.get_symbol_table_list();
         dec_.clear();
 
         lexer().begin();
 
         next_token();
 
         expression_node_ptr e = parse_corpus();
 
         if ((0 != e) && (token_t::e_eof == current_token().type))
         {
            bool* retinvk_ptr = 0;
 
            if (state_.return_stmt_present)
            {
               dec_.return_present_ = true;
 
               e = expression_generator_
                     .return_envelope(e, results_context_, retinvk_ptr);
            }
 
            expr.set_expression(e);
            expr.set_retinvk(retinvk_ptr);
 
            register_local_vars(expr);
            register_return_results(expr);
 
            return !(!expr);
         }
         else
         {
            if (error_list_.empty())
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR003 - Invalid expression encountered",
                  exprtk_error_location));
            }
 
            if ((0 != e) && branch_deletable(e))
            {
               destroy_node(e);
            }
 
            dec_.clear    ();
            sem_.cleanup  ();
            return_cleanup();
            expr = expression_t();
 
            return false;
         }
      }

Here is the caller graph for this function:

◆ compile() [2/2]

template<typename T>

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

inline

Definition at line 24947 of file exprtk.hpp.

      {
         expression_t expression;
         expression.register_symbol_table(symtab);
         compile(expression_string,expression);
         return expression;
      }

◆ construct_subexpr()

template<typename T>

std::string exprtk::parser< T >::construct_subexpr	(	lexer::token &	begin_token,
		lexer::token &	end_token,
		const bool	cleanup_whitespace = true )

inlineprivate

Definition at line 25395 of file exprtk.hpp.

      {
         std::string result = lexer().substr(begin_token.position,end_token.position);
         if (cleanup_whitespace)
         {
            for (std::size_t i = 0; i < result.size(); ++i)
            {
               if (details::is_whitespace(result[i])) result[i] = ' ';
            }
         }
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_corpus().

Here is the caller graph for this function:

◆ current_state()

template<typename T>

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

inlineprivate

Definition at line 25452 of file exprtk.hpp.

      {
         return (!current_state_stack_.empty()) ?
                current_state_stack_.back()     :
                state_t();
      }

◆ dec()

template<typename T>

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

inline

Definition at line 25129 of file exprtk.hpp.

      {
         return dec_;
      }

Referenced by exprtk::details::collector_helper< T >::collection_pass().

Here is the caller graph for this function:

◆ disable_unknown_symbol_resolver()

template<typename T>

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

inline

Definition at line 25174 of file exprtk.hpp.

      {
         resolve_unknown_symbol_  = false;
         unknown_symbol_resolver_ = &default_usr_;
      }

◆ enable_unknown_symbol_resolver() [1/2]

template<typename T>

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

inline

Definition at line 25169 of file exprtk.hpp.

      {
         enable_unknown_symbol_resolver(&usr);
      }

◆ 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

Definition at line 25159 of file exprtk.hpp.

      {
         resolve_unknown_symbol_ = true;
 
         if (usr)
            unknown_symbol_resolver_ = usr;
         else
            unknown_symbol_resolver_ = &default_usr_;
      }

Referenced by exprtk::details::collector_helper< T >::collection_pass(), exprtk::parser< Type >::enable_unknown_symbol_resolver(), and run_test20().

Here is the caller graph for this function:

◆ error()

template<typename T>

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

inline

Definition at line 25114 of file exprtk.hpp.

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

Referenced by load_expression(), main(), run_parse_benchmark(), run_test01(), run_test02(), run_test03(), run_test04(), run_test05(), run_test06(), run_test07(), run_test08(), run_test09(), run_test10(), run_test11(), run_test12(), run_test14(), run_test15(), run_test16(), run_test17(), run_test18(), run_test20(), test_expression(), and test_gen().

Here is the caller graph for this function:

◆ error_count()

template<typename T>

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

inline

Definition at line 25124 of file exprtk.hpp.

      {
         return error_list_.size();
      }

◆ error_node()

template<typename T>

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

inlinestaticprivate

Definition at line 25846 of file exprtk.hpp.

      {
         return reinterpret_cast<expression_node_ptr>(0);
      }

Here is the caller graph for this function:

◆ get_error()

template<typename T>

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

inline

Definition at line 25104 of file exprtk.hpp.

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

◆ halt_compilation_check()

template<typename T>

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

inlineprivate

Definition at line 25459 of file exprtk.hpp.

      {
         compilation_check::compilation_context context;
 
         if (compilation_check_ptr_ && !compilation_check_ptr_->continue_compilation(context))
         {
            const std::string error_message =
               !context.error_message.empty() ? " Details: " + context.error_message : "";
 
            set_error(make_error(
               parser_error::e_parser,
               token_t(),
               "ERR011 - Internal compilation check failed." + error_message,
               exprtk_error_location));
 
            return true;
         }
 
         return false;
      }

Referenced by exprtk::parser< Type >::compile(), and exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ handle_brkcnt_scope_exit()

template<typename T>

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

inlineprivate

Definition at line 26881 of file exprtk.hpp.

      {
         assert(!brkcnt_list_.empty());
         brkcnt_list_.pop_front();
      }

Referenced by exprtk::parser< Type >::parse_for_loop(), exprtk::parser< Type >::parse_repeat_until_loop(), and exprtk::parser< Type >::parse_while_loop().

Here is the caller graph for this function:

◆ init_precompilation()

template<typename T>

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

inline

Definition at line 24762 of file exprtk.hpp.

      {
         dec_.collect_variables() =
            settings_.collect_variables_enabled();
 
         dec_.collect_functions() =
            settings_.collect_functions_enabled();
 
         dec_.collect_assignments() =
            settings_.collect_assignments_enabled();
 
         if (settings_.replacer_enabled())
         {
            symbol_replacer_.clear();
            symbol_replacer_.add_replace("true" , "1", lexer::token::e_number);
            symbol_replacer_.add_replace("false", "0", lexer::token::e_number);
            helper_assembly_.token_modifier_list.clear();
            helper_assembly_.register_modifier(&symbol_replacer_);
         }
 
         if (settings_.commutative_check_enabled())
         {
            for (std::size_t i = 0; i < details::reserved_words_size; ++i)
            {
               commutative_inserter_.ignore_symbol(details::reserved_words[i]);
            }
 
            helper_assembly_.token_inserter_list.clear();
            helper_assembly_.register_inserter(&commutative_inserter_);
         }
 
         if (settings_.joiner_enabled())
         {
            helper_assembly_.token_joiner_list.clear();
            helper_assembly_.register_joiner(&operator_joiner_2_);
            helper_assembly_.register_joiner(&operator_joiner_3_);
         }
 
         if (
              settings_.numeric_check_enabled () ||
              settings_.bracket_check_enabled () ||
              settings_.sequence_check_enabled()
            )
         {
            helper_assembly_.token_scanner_list.clear();
 
            if (settings_.numeric_check_enabled())
            {
               helper_assembly_.register_scanner(&numeric_checker_);
            }
 
            if (settings_.bracket_check_enabled())
            {
               helper_assembly_.register_scanner(&bracket_checker_);
            }
 
            if (settings_.sequence_check_enabled())
            {
               helper_assembly_.register_scanner(&sequence_validator_      );
               helper_assembly_.register_scanner(&sequence_validator_3tkns_);
            }
         }
      }

Referenced by exprtk::parser< Type >::parser().

Here is the caller graph for this function:

◆ is_invalid_arithmetic_operation()

template<typename T>

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

inlineprivate

Definition at line 25268 of file exprtk.hpp.

      {
         return settings_.arithmetic_disabled(operation);
      }

Referenced by exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ is_invalid_assignment_operation()

template<typename T>

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

inlineprivate

Definition at line 25273 of file exprtk.hpp.

      {
         return settings_.assignment_disabled(operation);
      }

Referenced by exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ is_invalid_inequality_operation()

template<typename T>

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

inlineprivate

Definition at line 25278 of file exprtk.hpp.

      {
         return settings_.inequality_disabled(operation);
      }

Referenced by exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ is_invalid_logic_operation()

template<typename T>

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

inlineprivate

Definition at line 25263 of file exprtk.hpp.

      {
         return settings_.logic_disabled(operation);
      }

Referenced by exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ load_binary_operations_map()

template<typename T>

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

inlineprivate

Definition at line 42071 of file exprtk.hpp.

      {
         typedef typename binary_op_map_t::value_type value_type;
 
         #define register_binary_op(Op, BinaryFunctor)       \
         m.insert(value_type(Op,BinaryFunctor<T>::process)); \
 
         register_binary_op(details::e_add  , details::add_op )
         register_binary_op(details::e_sub  , details::sub_op )
         register_binary_op(details::e_mul  , details::mul_op )
         register_binary_op(details::e_div  , details::div_op )
         register_binary_op(details::e_mod  , details::mod_op )
         register_binary_op(details::e_pow  , details::pow_op )
         register_binary_op(details::e_lt   , details::lt_op  )
         register_binary_op(details::e_lte  , details::lte_op )
         register_binary_op(details::e_gt   , details::gt_op  )
         register_binary_op(details::e_gte  , details::gte_op )
         register_binary_op(details::e_eq   , details::eq_op  )
         register_binary_op(details::e_ne   , details::ne_op  )
         register_binary_op(details::e_and  , details::and_op )
         register_binary_op(details::e_nand , details::nand_op)
         register_binary_op(details::e_or   , details::or_op  )
         register_binary_op(details::e_nor  , details::nor_op )
         register_binary_op(details::e_xor  , details::xor_op )
         register_binary_op(details::e_xnor , details::xnor_op)
         #undef register_binary_op
      }

Referenced by exprtk::parser< Type >::parser().

Here is the caller graph for this function:

◆ load_inv_binary_operations_map()

template<typename T>

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

inlineprivate

Definition at line 42099 of file exprtk.hpp.

      {
         typedef typename inv_binary_op_map_t::value_type value_type;
 
         #define register_binary_op(Op, BinaryFunctor)       \
         m.insert(value_type(BinaryFunctor<T>::process,Op)); \
 
         register_binary_op(details::e_add  , details::add_op )
         register_binary_op(details::e_sub  , details::sub_op )
         register_binary_op(details::e_mul  , details::mul_op )
         register_binary_op(details::e_div  , details::div_op )
         register_binary_op(details::e_mod  , details::mod_op )
         register_binary_op(details::e_pow  , details::pow_op )
         register_binary_op(details::e_lt   , details::lt_op  )
         register_binary_op(details::e_lte  , details::lte_op )
         register_binary_op(details::e_gt   , details::gt_op  )
         register_binary_op(details::e_gte  , details::gte_op )
         register_binary_op(details::e_eq   , details::eq_op  )
         register_binary_op(details::e_ne   , details::ne_op  )
         register_binary_op(details::e_and  , details::and_op )
         register_binary_op(details::e_nand , details::nand_op)
         register_binary_op(details::e_or   , details::or_op  )
         register_binary_op(details::e_nor  , details::nor_op )
         register_binary_op(details::e_xor  , details::xor_op )
         register_binary_op(details::e_xnor , details::xnor_op)
         #undef register_binary_op
      }

Referenced by exprtk::parser< Type >::parser().

Here is the caller graph for this function:

◆ load_sf3_map()

template<typename T>

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

inlineprivate

Definition at line 42127 of file exprtk.hpp.

      {
         typedef std::pair<trinary_functor_t,details::operator_type> pair_t;
 
         #define register_sf3(Op)                                                                             \
         sf3_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
 
         register_sf3(00) register_sf3(01) register_sf3(02) register_sf3(03)
         register_sf3(04) register_sf3(05) register_sf3(06) register_sf3(07)
         register_sf3(08) register_sf3(09) register_sf3(10) register_sf3(11)
         register_sf3(12) register_sf3(13) register_sf3(14) register_sf3(15)
         register_sf3(16) register_sf3(17) register_sf3(18) register_sf3(19)
         register_sf3(20) register_sf3(21) register_sf3(22) register_sf3(23)
         register_sf3(24) register_sf3(25) register_sf3(26) register_sf3(27)
         register_sf3(28) register_sf3(29) register_sf3(30)
         #undef register_sf3
 
         #define register_sf3_extid(Id, Op)                                        \
         sf3_map[Id] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
 
         register_sf3_extid("(t-t)-t",23)  // (t-t)-t --> t-(t+t)
         #undef register_sf3_extid
      }

Referenced by exprtk::parser< Type >::parser().

Here is the caller graph for this function:

◆ load_sf4_map()

template<typename T>

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

inlineprivate

Definition at line 42151 of file exprtk.hpp.

      {
         typedef std::pair<quaternary_functor_t,details::operator_type> pair_t;
 
         #define register_sf4(Op)                                                                             \
         sf4_map[details::sf##Op##_op<T>::id()] = pair_t(details::sf##Op##_op<T>::process,details::e_sf##Op); \
 
         register_sf4(48) register_sf4(49) register_sf4(50) register_sf4(51)
         register_sf4(52) register_sf4(53) register_sf4(54) register_sf4(55)
         register_sf4(56) register_sf4(57) register_sf4(58) register_sf4(59)
         register_sf4(60) register_sf4(61) register_sf4(62) register_sf4(63)
         register_sf4(64) register_sf4(65) register_sf4(66) register_sf4(67)
         register_sf4(68) register_sf4(69) register_sf4(70) register_sf4(71)
         register_sf4(72) register_sf4(73) register_sf4(74) register_sf4(75)
         register_sf4(76) register_sf4(77) register_sf4(78) register_sf4(79)
         register_sf4(80) register_sf4(81) register_sf4(82) register_sf4(83)
         #undef register_sf4
 
         #define register_sf4ext(Op)                                                                                    \
         sf4_map[details::sfext##Op##_op<T>::id()] = pair_t(details::sfext##Op##_op<T>::process,details::e_sf4ext##Op); \
 
         register_sf4ext(00) register_sf4ext(01) register_sf4ext(02) register_sf4ext(03)
         register_sf4ext(04) register_sf4ext(05) register_sf4ext(06) register_sf4ext(07)
         register_sf4ext(08) register_sf4ext(09) register_sf4ext(10) register_sf4ext(11)
         register_sf4ext(12) register_sf4ext(13) register_sf4ext(14) register_sf4ext(15)
         register_sf4ext(16) register_sf4ext(17) register_sf4ext(18) register_sf4ext(19)
         register_sf4ext(20) register_sf4ext(21) register_sf4ext(22) register_sf4ext(23)
         register_sf4ext(24) register_sf4ext(25) register_sf4ext(26) register_sf4ext(27)
         register_sf4ext(28) register_sf4ext(29) register_sf4ext(30) register_sf4ext(31)
         register_sf4ext(32) register_sf4ext(33) register_sf4ext(34) register_sf4ext(35)
         register_sf4ext(36) register_sf4ext(37) register_sf4ext(38) register_sf4ext(39)
         register_sf4ext(40) register_sf4ext(41) register_sf4ext(42) register_sf4ext(43)
         register_sf4ext(44) register_sf4ext(45) register_sf4ext(46) register_sf4ext(47)
         register_sf4ext(48) register_sf4ext(49) register_sf4ext(50) register_sf4ext(51)
         register_sf4ext(52) register_sf4ext(53) register_sf4ext(54) register_sf4ext(55)
         register_sf4ext(56) register_sf4ext(57) register_sf4ext(58) register_sf4ext(59)
         register_sf4ext(60) register_sf4ext(61)
         #undef register_sf4ext
      }

Referenced by exprtk::parser< Type >::parser().

Here is the caller graph for this function:

◆ load_unary_operations_map()

template<typename T>

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

inlineprivate

Definition at line 42023 of file exprtk.hpp.

      {
         #define register_unary_op(Op, UnaryFunctor)            \
         m.insert(std::make_pair(Op,UnaryFunctor<T>::process)); \
 
         register_unary_op(details::e_abs   , details::abs_op  )
         register_unary_op(details::e_acos  , details::acos_op )
         register_unary_op(details::e_acosh , details::acosh_op)
         register_unary_op(details::e_asin  , details::asin_op )
         register_unary_op(details::e_asinh , details::asinh_op)
         register_unary_op(details::e_atan  , details::atan_op )
         register_unary_op(details::e_atanh , details::atanh_op)
         register_unary_op(details::e_ceil  , details::ceil_op )
         register_unary_op(details::e_cos   , details::cos_op  )
         register_unary_op(details::e_cosh  , details::cosh_op )
         register_unary_op(details::e_exp   , details::exp_op  )
         register_unary_op(details::e_expm1 , details::expm1_op)
         register_unary_op(details::e_floor , details::floor_op)
         register_unary_op(details::e_log   , details::log_op  )
         register_unary_op(details::e_log10 , details::log10_op)
         register_unary_op(details::e_log2  , details::log2_op )
         register_unary_op(details::e_log1p , details::log1p_op)
         register_unary_op(details::e_neg   , details::neg_op  )
         register_unary_op(details::e_pos   , details::pos_op  )
         register_unary_op(details::e_round , details::round_op)
         register_unary_op(details::e_sin   , details::sin_op  )
         register_unary_op(details::e_sinc  , details::sinc_op )
         register_unary_op(details::e_sinh  , details::sinh_op )
         register_unary_op(details::e_sqrt  , details::sqrt_op )
         register_unary_op(details::e_tan   , details::tan_op  )
         register_unary_op(details::e_tanh  , details::tanh_op )
         register_unary_op(details::e_cot   , details::cot_op  )
         register_unary_op(details::e_sec   , details::sec_op  )
         register_unary_op(details::e_csc   , details::csc_op  )
         register_unary_op(details::e_r2d   , details::r2d_op  )
         register_unary_op(details::e_d2r   , details::d2r_op  )
         register_unary_op(details::e_d2g   , details::d2g_op  )
         register_unary_op(details::e_g2d   , details::g2d_op  )
         register_unary_op(details::e_notl  , details::notl_op )
         register_unary_op(details::e_sgn   , details::sgn_op  )
         register_unary_op(details::e_erf   , details::erf_op  )
         register_unary_op(details::e_erfc  , details::erfc_op )
         register_unary_op(details::e_ncdf  , details::ncdf_op )
         register_unary_op(details::e_frac  , details::frac_op )
         register_unary_op(details::e_trunc , details::trunc_op)
         #undef register_unary_op
      }

Referenced by exprtk::parser< Type >::parser().

Here is the caller graph for this function:

◆ local_variable_is_shadowed()

template<typename T>

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

inlineprivate

Definition at line 30025 of file exprtk.hpp.

      {
         const scope_element& se = sem_.get_element(symbol);
         return (se.name == symbol) && se.active;
      }

Referenced by exprtk::parser< Type >::parse_define_constvar_statement(), and exprtk::parser< Type >::parse_define_var_statement().

Here is the caller graph for this function:

◆ lodge_immutable_symbol()

template<typename T>

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

inlineprivate

Definition at line 31175 of file exprtk.hpp.

      {
         immutable_memory_map_.add_interval(interval);
         immutable_symtok_map_[interval] = token;
      }

Referenced by exprtk::parser< Type >::parse_string(), exprtk::parser< Type >::parse_symtab_symbol(), and exprtk::parser< Type >::parse_vector().

Here is the caller graph for this function:

◆ lodge_symbol()

template<typename T>

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

inlineprivate

Definition at line 28264 of file exprtk.hpp.

      {
         dec_.add_symbol(symbol,st);
      }

Referenced by exprtk::parser< Type >::parse_define_constvar_statement(), exprtk::parser< Type >::parse_define_string_statement(), exprtk::parser< Type >::parse_define_var_statement(), exprtk::parser< Type >::parse_define_vector_statement(), exprtk::parser< Type >::parse_string(), exprtk::parser< Type >::parse_swap_statement(), exprtk::parser< Type >::parse_symtab_symbol(), exprtk::parser< Type >::parse_uninitialised_var_statement(), and exprtk::parser< Type >::parse_vararg_function().

Here is the caller graph for this function:

◆ make_memory_range() [1/3]

template<typename T>

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

inlineprivate

Definition at line 31158 of file exprtk.hpp.

      {
         const T* begin = reinterpret_cast<const T*>(&t);
         const T* end   = begin + 1;
         return interval_t(begin, end);
      }

Referenced by exprtk::parser< Type >::parse_string(), exprtk::parser< Type >::parse_symtab_symbol(), and exprtk::parser< Type >::parse_vector().

Here is the caller graph for this function:

◆ 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

Definition at line 31165 of file exprtk.hpp.

      {
         return interval_t(begin, begin + size);
      }

◆ 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

Definition at line 31170 of file exprtk.hpp.

      {
         return interval_t(begin, begin + size);
      }

◆ operator=()

template<typename T>

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

private

◆ parse_assert_statement()

template<typename T>

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

inlineprivate

Definition at line 30886 of file exprtk.hpp.

      {
         assert(details::imatch(current_token().value, "assert"));
 
         if (state_.parsing_assert_stmt)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR219 - Assert statement within an assert statement is not allowed",
               exprtk_error_location));
 
            return error_node();
         }
 
         scoped_bool_negator sbn(state_.parsing_assert_stmt);
 
         next_token();
 
         std::vector<expression_node_ptr> assert_arg_list(3, error_node());
         scoped_vec_delete<expression_node_t> svd((*this), assert_arg_list);
 
         expression_node_ptr& assert_condition = assert_arg_list[0];
         expression_node_ptr& assert_message   = assert_arg_list[1];
         expression_node_ptr& assert_id        = assert_arg_list[2];
 
         if (!token_is(token_t::e_lbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR220 - Expected '(' at start of assert statement",
               exprtk_error_location));
 
            return error_node();
         }
 
         const token_t start_token = current_token();
 
         // Parse the assert condition
         if (0 == (assert_condition = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR221 - Failed to parse condition for assert statement",
               exprtk_error_location));
 
            return error_node();
         }
 
         const token_t end_token = current_token();
 
         if (!token_is(token_t::e_rbracket))
         {
            if (!token_is(token_t::e_comma))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR222 - Expected ',' between condition and message for assert statement",
                  exprtk_error_location));
 
               return error_node();
            }
            // Parse the assert message
            else if (
                      (0 == (assert_message = parse_expression())) ||
                      !details::is_generally_string_node(assert_message)
                    )
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR223 - " +
                  (assert_message ?
                  std::string("Expected string for assert message") :
                  std::string("Failed to parse message for assert statement")),
                  exprtk_error_location));
 
               return error_node();
            }
            else if (!token_is(token_t::e_rbracket))
            {
               if (!token_is(token_t::e_comma))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR224 - Expected ',' between message and ID for assert statement",
                     exprtk_error_location));
 
                  return error_node();
               }
               // Parse assert ID
               else if (
                         (0 == (assert_id = parse_expression())) ||
                         !details::is_const_string_node(assert_id)
                       )
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR225 - " +
                     (assert_id ?
                     std::string("Expected literal string for assert ID") :
                     std::string("Failed to parse string for assert ID")),
                     exprtk_error_location));
 
                  return error_node();
               }
               else if (!token_is(token_t::e_rbracket))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR226 - Expected ')' at start of assert statement",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
         }
 
         exprtk::assert_check::assert_context context;
         context.condition = lexer().substr(start_token.position, end_token.position);
         context.offet     = start_token.position;
 
         if (0 == assert_check_)
         {
            exprtk_debug(("parse_assert_statement() - assert functionality is disabled. assert condition: %s\n",
                          context.condition.c_str()));
 
            return new details::null_node<T>();
         }
 
         #ifndef exprtk_disable_string_capabilities
         if (assert_message && details::is_const_string_node(assert_message))
         {
            context.message = dynamic_cast<details::string_base_node<T>*>(assert_message)->str();
         }
 
         if (assert_id && details::is_const_string_node(assert_id))
         {
            context.id = dynamic_cast<details::string_base_node<T>*>(assert_id)->str();
 
            if (assert_ids_.end() != assert_ids_.find(context.id))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR227 - Duplicate assert ID: " + context.id,
                  exprtk_error_location));
 
               return error_node();
            }
 
            assert_ids_.insert(context.id);
            free_node(node_allocator_, assert_id);
         }
         #endif
 
         expression_node_ptr result_node =
            expression_generator_.assert_call(
               assert_condition,
               assert_message,
               context);
 
         exprtk_debug(("parse_assert_statement() - assert condition: [%s]\n", context.condition.c_str()      ));
         exprtk_debug(("parse_assert_statement() - assert message:   [%s]\n", context.message  .c_str()      ));
         exprtk_debug(("parse_assert_statement() - assert id:        [%s]\n", context.id       .c_str()      ));
         exprtk_debug(("parse_assert_statement() - assert offset:    [%d]\n", static_cast<int>(context.offet)));
 
         if (0 == result_node)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR228 - Failed to synthesize assert",
               exprtk_error_location));
 
            return error_node();
         }
 
         svd.delete_ptr = false;
         return result_node;
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ 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

Definition at line 26201 of file exprtk.hpp.

      {
         std::fill_n(param_list, MaxNumberofParameters, reinterpret_cast<expression_node_ptr>(0));
 
         scoped_delete<expression_node_t,MaxNumberofParameters> sd((*this),param_list);
 
         next_token();
 
         if (!token_is(token_t::e_lbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR029 - Expected a '(' at start of function call to '" + function_name  +
               "', instead got: '" + current_token().value + "'",
               exprtk_error_location));
 
            return 0;
         }
 
         if (token_is(token_t::e_rbracket, e_hold))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR030 - Expected at least one input parameter for function call '" + function_name + "'",
               exprtk_error_location));
 
            return 0;
         }
 
         std::size_t param_index = 0;
 
         for (; param_index < MaxNumberofParameters; ++param_index)
         {
            param_list[param_index] = parse_expression();
 
            if (0 == param_list[param_index])
               return 0;
            else if (token_is(token_t::e_rbracket))
            {
               sd.delete_ptr = false;
               break;
            }
            else if (token_is(token_t::e_comma))
               continue;
            else
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR031 - Expected a ',' between function input parameters, instead got: '" + current_token().value + "'",
                  exprtk_error_location));
 
               return 0;
            }
         }
 
         if (sd.delete_ptr)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR032 - Invalid number of input parameters passed to function '" + function_name  + "'",
               exprtk_error_location));
 
            return 0;
         }
 
         return (param_index + 1);
      }

Referenced by exprtk::parser< Type >::parse_base_operation().

Here is the caller graph for this function:

◆ parse_base_operation()

template<typename T>

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

inlineprivate

Definition at line 26273 of file exprtk.hpp.

      {
         typedef std::pair<base_ops_map_t::iterator,base_ops_map_t::iterator> map_range_t;
 
         const std::string operation_name   = current_token().value;
         const token_t     diagnostic_token = current_token();
 
         map_range_t itr_range = base_ops_map_.equal_range(operation_name);
 
         if (0 == std::distance(itr_range.first,itr_range.second))
         {
            set_error(make_error(
               parser_error::e_syntax,
               diagnostic_token,
               "ERR033 - No entry found for base operation: " + operation_name,
               exprtk_error_location));
 
            return error_node();
         }
 
         static const std::size_t MaxNumberofParameters = 4;
         expression_node_ptr param_list[MaxNumberofParameters] = {0};
 
         const std::size_t parameter_count = parse_base_function_call(param_list, operation_name);
 
         if ((parameter_count > 0) && (parameter_count <= MaxNumberofParameters))
         {
            for (base_ops_map_t::iterator itr = itr_range.first; itr != itr_range.second; ++itr)
            {
               const details::base_operation_t& operation = itr->second;
 
               if (operation.num_params == parameter_count)
               {
                  switch (parameter_count)
                  {
                     #define base_opr_case(N)                                         \
                     case N : {                                                       \
                                 expression_node_ptr pl##N[N] = {0};                  \
                                 std::copy(param_list, param_list + N, pl##N);        \
                                 lodge_symbol(operation_name, e_st_function);         \
                                 return expression_generator_(operation.type, pl##N); \
                              }                                                       \
 
                     base_opr_case(1)
                     base_opr_case(2)
                     base_opr_case(3)
                     base_opr_case(4)
                     #undef base_opr_case
                  }
               }
            }
         }
 
         for (std::size_t i = 0; i < MaxNumberofParameters; ++i)
         {
            free_node(node_allocator_, param_list[i]);
         }
 
         set_error(make_error(
            parser_error::e_syntax,
            diagnostic_token,
            "ERR034 - Invalid number of input parameters for call to function: '" + operation_name + "'",
            exprtk_error_location));
 
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_not_statement(), and exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_branch()

template<typename T>

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

inlineprivate

Definition at line 31669 of file exprtk.hpp.

      {
         stack_limit_handler slh(*this);
 
         if (!slh)
         {
            return error_node();
         }
 
         expression_node_ptr branch = error_node();
 
         if (token_t::e_number == current_token().type)
         {
            T numeric_value = T(0);
 
            if (details::string_to_real(current_token().value, numeric_value))
            {
               expression_node_ptr literal_exp = expression_generator_(numeric_value);
 
               if (0 == literal_exp)
               {
                  set_error(make_error(
                     parser_error::e_numeric,
                     current_token(),
                     "ERR242 - Failed generate node for scalar: '" + current_token().value + "'",
                     exprtk_error_location));
 
                  return error_node();
               }
 
               next_token();
               branch = literal_exp;
            }
            else
            {
               set_error(make_error(
                  parser_error::e_numeric,
                  current_token(),
                  "ERR243 - Failed to convert '" + current_token().value + "' to a number",
                  exprtk_error_location));
 
               return error_node();
            }
         }
         else if (token_t::e_symbol == current_token().type)
         {
            branch = parse_symbol();
         }
         #ifndef exprtk_disable_string_capabilities
         else if (token_t::e_string == current_token().type)
         {
            branch = parse_const_string();
         }
         #endif
         else if (token_t::e_lbracket == current_token().type)
         {
            next_token();
 
            if (0 == (branch = parse_expression()))
            {
               return error_node();
            }
 
            token_is(token_t::e_eof);
 
            if (!token_is(token_t::e_rbracket))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR244 - Expected ')' instead of: '" + current_token().value + "'",
                  exprtk_error_location));
 
               details::free_node(node_allocator_, branch);
 
               return error_node();
            }
            else if (!post_bracket_process(token_t::e_lbracket,branch))
            {
               details::free_node(node_allocator_, branch);
 
               return error_node();
            }
 
            parse_pending_vector_index_operator(branch);
         }
         else if (token_t::e_lsqrbracket == current_token().type)
         {
            next_token();
 
            if (0 == (branch = parse_expression()))
               return error_node();
            else if (!token_is(token_t::e_rsqrbracket))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR245 - Expected ']' instead of: '" + current_token().value + "'",
                  exprtk_error_location));
 
               details::free_node(node_allocator_, branch);
 
               return error_node();
            }
            else if (!post_bracket_process(token_t::e_lsqrbracket,branch))
            {
               details::free_node(node_allocator_, branch);
 
               return error_node();
            }
         }
         else if (token_t::e_lcrlbracket == current_token().type)
         {
            next_token();
 
            if (0 == (branch = parse_expression()))
               return error_node();
            else if (!token_is(token_t::e_rcrlbracket))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR246 - Expected '}' instead of: '" + current_token().value + "'",
                  exprtk_error_location));
 
               details::free_node(node_allocator_, branch);
 
               return error_node();
            }
            else if (!post_bracket_process(token_t::e_lcrlbracket,branch))
            {
               details::free_node(node_allocator_, branch);
 
               return error_node();
            }
         }
         else if (token_t::e_sub == current_token().type)
         {
            next_token();
            branch = parse_expression(e_level11);
 
            if (
                 branch &&
                 !(
                    details::is_neg_unary_node    (branch) &&
                    simplify_unary_negation_branch(branch)
                  )
               )
            {
               expression_node_ptr result = expression_generator_(details::e_neg,branch);
 
               if (0 == result)
               {
                  details::free_node(node_allocator_, branch);
 
                  return error_node();
               }
               else
                  branch = result;
            }
         }
         else if (token_t::e_add == current_token().type)
         {
            next_token();
            branch = parse_expression(e_level13);
         }
         else if (token_t::e_eof == current_token().type)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR247 - Premature end of expression[1]",
               exprtk_error_location));
 
            return error_node();
         }
         else
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR248 - Premature end of expression[2]",
               exprtk_error_location));
 
            return error_node();
         }
 
         if (
              branch                    &&
              (e_level00 == precedence) &&
              token_is(token_t::e_ternary,prsrhlpr_t::e_hold)
            )
         {
            branch = parse_ternary_conditional_statement(branch);
         }
 
         parse_pending_string_rangesize(branch);
 
         return branch;
      }

Referenced by exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ parse_break_statement()

template<typename T>

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

inlineprivate

Definition at line 29366 of file exprtk.hpp.

      {
         if (state_.parsing_break_stmt)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR151 - Invoking 'break' within a break call is not allowed",
               exprtk_error_location));
 
            return error_node();
         }
         else if (0 == state_.parsing_loop_stmt_count)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR152 - Invalid use of 'break', allowed only in the scope of a loop",
               exprtk_error_location));
 
            return error_node();
         }
 
         scoped_bool_negator sbn(state_.parsing_break_stmt);
 
         if (!brkcnt_list_.empty())
         {
            next_token();
 
            brkcnt_list_.front() = true;
 
            expression_node_ptr return_expr = error_node();
 
            if (token_is(token_t::e_lsqrbracket))
            {
               if (0 == (return_expr = parse_expression()))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR153 - Failed to parse return expression for 'break' statement",
                     exprtk_error_location));
 
                  return error_node();
               }
               else if (!token_is(token_t::e_rsqrbracket))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR154 - Expected ']' at the completion of break's return expression",
                     exprtk_error_location));
 
                  free_node(node_allocator_, return_expr);
 
                  return error_node();
               }
            }
 
            state_.activate_side_effect("parse_break_statement()");
 
            return node_allocator_.allocate<details::break_node<T> >(return_expr);
         }
         else
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR155 - Invalid use of 'break', allowed only in the scope of a loop",
               exprtk_error_location));
         }
 
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_conditional_statement()

template<typename T>

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

inlineprivate

Definition at line 26682 of file exprtk.hpp.

      {
         expression_node_ptr condition = error_node();
 
         next_token();
 
         if (!token_is(token_t::e_lbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR053 - Expected '(' at start of if-statement, instead got: '" + current_token().value + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else if (0 == (condition = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR054 - Failed to parse condition for if-statement",
               exprtk_error_location));
 
            return error_node();
         }
         else if (token_is(token_t::e_comma,prsrhlpr_t::e_hold))
         {
            // if (x,y,z)
            return parse_conditional_statement_01(condition);
         }
         else if (token_is(token_t::e_rbracket))
         {
            /*
               00. if (x) y;
               01. if (x) y; else z;
               02. if (x) y; else {z0; ... zn;}
               03. if (x) y; else if (z) w;
               04. if (x) y; else if (z) w; else u;
               05. if (x) y; else if (z) w; else {u0; ... un;}
               06. if (x) y; else if (z) {w0; ... wn;}
               07. if (x) {y0; ... yn;}
               08. if (x) {y0; ... yn;} else z;
               09. if (x) {y0; ... yn;} else {z0; ... zn;};
               10. if (x) {y0; ... yn;} else if (z) w;
               11. if (x) {y0; ... yn;} else if (z) w; else u;
               12. if (x) {y0; ... nex;} else if (z) w; else {u0 ... un;}
               13. if (x) {y0; ... yn;} else if (z) {w0; ... wn;}
            */
            return parse_conditional_statement_02(condition);
         }
 
         set_error(make_error(
            parser_error::e_syntax,
            current_token(),
            "ERR055 - Invalid if-statement",
            exprtk_error_location));
 
         free_node(node_allocator_, condition);
 
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_conditional_statement_02(), and exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_conditional_statement_01()

template<typename T>

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

inlineprivate

Definition at line 26340 of file exprtk.hpp.

      {
         // Parse: [if][(][condition][,][consequent][,][alternative][)]
 
         expression_node_ptr consequent  = error_node();
         expression_node_ptr alternative = error_node();
 
         bool result = true;
 
         if (!token_is(token_t::e_comma))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR035 - Expected ',' between if-statement condition and consequent",
               exprtk_error_location));
 
            result = false;
         }
         else if (0 == (consequent = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR036 - Failed to parse consequent for if-statement",
               exprtk_error_location));
 
            result = false;
         }
         else if (!token_is(token_t::e_comma))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR037 - Expected ',' between if-statement consequent and alternative",
               exprtk_error_location));
 
            result = false;
         }
         else if (0 == (alternative = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR038 - Failed to parse alternative for if-statement",
               exprtk_error_location));
 
            result = false;
         }
         else if (!token_is(token_t::e_rbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR039 - Expected ')' at the end of if-statement",
               exprtk_error_location));
 
            result = false;
         }
 
         #ifndef exprtk_disable_string_capabilities
         if (result)
         {
            const bool consq_is_str = is_generally_string_node(consequent );
            const bool alter_is_str = is_generally_string_node(alternative);
 
            if (consq_is_str || alter_is_str)
            {
               if (consq_is_str && alter_is_str)
               {
                  expression_node_ptr result_node =
                     expression_generator_
                        .conditional_string(condition, consequent, alternative);
 
                  if (result_node && result_node->valid())
                  {
                     return result_node;
                  }
 
                  set_error(make_error(
                     parser_error::e_synthesis,
                     current_token(),
                     "ERR040 - Failed to synthesize node: conditional_string",
                     exprtk_error_location));
 
                  free_node(node_allocator_, result_node);
                  return error_node();
               }
 
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR041 - Return types of if-statement differ: string/non-string",
                  exprtk_error_location));
 
               result = false;
            }
         }
         #endif
 
         if (result)
         {
            const bool consq_is_vec = is_ivector_node(consequent );
            const bool alter_is_vec = is_ivector_node(alternative);
 
            if (consq_is_vec || alter_is_vec)
            {
               if (consq_is_vec && alter_is_vec)
               {
                  return expression_generator_
                           .conditional_vector(condition, consequent, alternative);
               }
 
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR042 - Return types of if-statement differ: vector/non-vector",
                  exprtk_error_location));
 
               result = false;
            }
         }
 
         if (!result)
         {
            free_node(node_allocator_, condition  );
            free_node(node_allocator_, consequent );
            free_node(node_allocator_, alternative);
 
            return error_node();
         }
         else
            return expression_generator_
                      .conditional(condition, consequent, alternative);
      }

Referenced by exprtk::parser< Type >::parse_conditional_statement().

Here is the caller graph for this function:

◆ parse_conditional_statement_02()

template<typename T>

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

inlineprivate

Definition at line 26476 of file exprtk.hpp.

      {
         expression_node_ptr consequent  = error_node();
         expression_node_ptr alternative = error_node();
 
         bool result = true;
 
         if (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold))
         {
            if (0 == (consequent = parse_multi_sequence("if-statement-01")))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR043 - Failed to parse body of consequent for if-statement",
                  exprtk_error_location));
 
               result = false;
            }
            else if
            (
              !settings_.commutative_check_enabled()           &&
              !token_is("else",prsrhlpr_t::e_hold)             &&
              !token_is_loop(prsrhlpr_t::e_hold)               &&
              !token_is_arithmetic_opr(prsrhlpr_t::e_hold)     &&
              !token_is_right_bracket (prsrhlpr_t::e_hold)     &&
              !token_is_ineq_opr      (prsrhlpr_t::e_hold)     &&
              !token_is(token_t::e_ternary,prsrhlpr_t::e_hold) &&
              !token_is(token_t::e_eof    ,prsrhlpr_t::e_hold)
            )
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR044 - Expected ';' at the end of the consequent for if-statement (1)",
                  exprtk_error_location));
 
               result = false;
            }
         }
         else
         {
            if (
                 settings_.commutative_check_enabled() &&
                 token_is(token_t::e_mul,prsrhlpr_t::e_hold)
               )
            {
               next_token();
            }
 
            if (0 != (consequent = parse_expression()))
            {
               if (!token_is(token_t::e_eof, prsrhlpr_t::e_hold))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR045 - Expected ';' at the end of the consequent for if-statement (2)",
                     exprtk_error_location));
 
                  result = false;
               }
            }
            else
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR046 - Failed to parse body of consequent for if-statement",
                  exprtk_error_location));
 
               result = false;
            }
         }
 
         if (result)
         {
            if (
                 details::imatch(current_token().value,"else") ||
                 (token_is(token_t::e_eof, prsrhlpr_t::e_hold) && peek_token_is("else"))
               )
            {
               next_token();
 
               if (details::imatch(current_token().value,"else"))
               {
                  next_token();
               }
 
               if (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold))
               {
                  if (0 == (alternative = parse_multi_sequence("else-statement-01")))
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR047 - Failed to parse body of the 'else' for if-statement",
                        exprtk_error_location));
 
                     result = false;
                  }
               }
               else if (details::imatch(current_token().value,"if"))
               {
                  if (0 == (alternative = parse_conditional_statement()))
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR048 - Failed to parse body of if-else statement",
                        exprtk_error_location));
 
                     result = false;
                  }
               }
               else if (0 != (alternative = parse_expression()))
               {
                  if (
                       !token_is(token_t::e_ternary    , prsrhlpr_t::e_hold) &&
                       !token_is(token_t::e_rcrlbracket, prsrhlpr_t::e_hold) &&
                       !token_is(token_t::e_eof)
                     )
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR049 - Expected ';' at the end of the 'else-if' for the if-statement",
                        exprtk_error_location));
 
                     result = false;
                  }
               }
               else
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR050 - Failed to parse body of the 'else' for if-statement",
                     exprtk_error_location));
 
                  result = false;
               }
            }
         }
 
         #ifndef exprtk_disable_string_capabilities
         if (result)
         {
            const bool consq_is_str = is_generally_string_node(consequent );
            const bool alter_is_str = is_generally_string_node(alternative);
 
            if (consq_is_str || alter_is_str)
            {
               if (consq_is_str && alter_is_str)
               {
                  return expression_generator_
                           .conditional_string(condition, consequent, alternative);
               }
 
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR051 - Return types of if-statement differ: string/non-string",
                  exprtk_error_location));
 
               result = false;
            }
         }
         #endif
 
         if (result)
         {
            const bool consq_is_vec = is_ivector_node(consequent );
            const bool alter_is_vec = is_ivector_node(alternative);
 
            if (consq_is_vec || alter_is_vec)
            {
               if (consq_is_vec && alter_is_vec)
               {
                  return expression_generator_
                           .conditional_vector(condition, consequent, alternative);
               }
 
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR052 - Return types of if-statement differ: vector/non-vector",
                  exprtk_error_location));
 
               result = false;
            }
         }
 
         if (!result)
         {
            free_node(node_allocator_, condition  );
            free_node(node_allocator_, consequent );
            free_node(node_allocator_, alternative);
 
            return error_node();
         }
         else
            return expression_generator_
                      .conditional(condition, consequent, alternative);
      }

Referenced by exprtk::parser< Type >::parse_conditional_statement().

Here is the caller graph for this function:

◆ parse_const_string()

template<typename T>

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

inlineprivate

Definition at line 28377 of file exprtk.hpp.

      {
         const std::string   const_str = current_token().value;
         expression_node_ptr result    = expression_generator_(const_str);
 
         if (peek_token_is(token_t::e_lsqrbracket))
         {
            next_token();
 
            if (peek_token_is(token_t::e_rsqrbracket))
            {
               next_token();
               next_token();
 
               free_node(node_allocator_, result);
 
               return expression_generator_(T(const_str.size()));
            }
 
            range_t rp;
 
            if (!parse_range(rp))
            {
               free_node(node_allocator_, result);
               rp.free();
 
               return error_node();
            }
 
            free_node(node_allocator_, result);
 
            if (rp.n1_c.first && (rp.n1_c.second == std::numeric_limits<std::size_t>::max()))
            {
               rp.n1_c.second  = const_str.size();
               rp.cache.second = rp.n1_c.second;
            }
 
            if (
                 (rp.n0_c.first && (rp.n0_c.second >= const_str.size())) ||
                 (rp.n1_c.first && (rp.n1_c.second >  const_str.size()))
               )
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR122 - Overflow in range for string: '" + const_str + "'[" +
                  (rp.n0_c.first ? details::to_str(static_cast<int>(rp.n0_c.second)) : "?") + ":" +
                  (rp.n1_c.first ? details::to_str(static_cast<int>(rp.n1_c.second)) : "?") + "]",
                  exprtk_error_location));
 
               rp.free();
 
               return error_node();
            }
 
            result = expression_generator_(const_str,rp);
 
            if (result)
               rp.clear();
         }
         else
            next_token();
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_branch().

Here is the caller graph for this function:

◆ parse_continue_statement()

template<typename T>

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

inlineprivate

Definition at line 29441 of file exprtk.hpp.

      {
         if (0 == state_.parsing_loop_stmt_count)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR156 - Invalid use of 'continue', allowed only in the scope of a loop",
               exprtk_error_location));
 
            return error_node();
         }
         else
         {
            next_token();
 
            brkcnt_list_.front() = true;
            state_.activate_side_effect("parse_continue_statement()");
 
            return node_allocator_.allocate<details::continue_node<T> >();
         }
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_corpus()

template<typename T>

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

inlineprivate

Definition at line 25301 of file exprtk.hpp.

      {
         std::vector<expression_node_ptr> arg_list;
         std::vector<bool> side_effect_list;
 
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         lexer::token begin_token;
         lexer::token end_token;
 
         for ( ; ; )
         {
            state_.side_effect_present = false;
 
            begin_token = current_token();
 
            expression_node_ptr arg = parse_expression();
 
            if (0 == arg)
            {
               if (error_list_.empty())
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR009 - Invalid expression encountered",
                     exprtk_error_location));
               }
 
               return error_node();
            }
            else
            {
               arg_list.push_back(arg);
 
               side_effect_list.push_back(state_.side_effect_present);
 
               end_token = current_token();
 
               const std::string sub_expr = construct_subexpr(begin_token, end_token);
 
               exprtk_debug(("parse_corpus(%02d) Subexpr: %s\n",
                             static_cast<int>(arg_list.size() - 1),
                             sub_expr.c_str()));
 
               exprtk_debug(("parse_corpus(%02d) - Side effect present: %s\n",
                             static_cast<int>(arg_list.size() - 1),
                             state_.side_effect_present ? "true" : "false"));
 
               exprtk_debug(("-------------------------------------------------\n"));
            }
 
            if (token_is(token_t::e_eof,prsrhlpr_t::e_hold))
            {
               if (lexer().finished())
                  break;
               else
                  next_token();
            }
            else if (
                      !settings_.commutative_check_enabled() &&
                      (
                        current_token().type == token_t::e_symbol ||
                        current_token().type == token_t::e_number ||
                        current_token().type == token_t::e_string ||
                        token_is_bracket(prsrhlpr_t::e_hold)
                      )
                    )
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR010 - Invalid syntax '" + current_token().value  + "' possible missing operator or context",
                  exprtk_error_location));
 
               return error_node();
            }
         }
 
         if (
              !arg_list.empty() &&
              is_return_node(arg_list.back())
            )
         {
            dec_.final_stmt_return_ = true;
         }
 
         const expression_node_ptr result = simplify(arg_list,side_effect_list);
 
         svd.delete_ptr = (0 == result);
 
         return result;
      }

Referenced by exprtk::parser< Type >::compile().

Here is the caller graph for this function:

◆ parse_define_constvar_statement()

template<typename T>

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

inlineprivate

Definition at line 30233 of file exprtk.hpp.

      {
         if (settings_.vardef_disabled())
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR187 - Illegal const variable definition",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!token_is("const"))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR188 - Expected 'const' keyword for const-variable definition",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!token_is("var"))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR189 - Expected 'var' keyword for const-variable definition",
               exprtk_error_location));
 
            return error_node();
         }
 
         const std::string var_name = current_token().value;
 
         expression_node_ptr initialisation_expression = error_node();
 
         if (!token_is(token_t::e_symbol))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR190 - Expected a symbol for const-variable definition",
               exprtk_error_location));
 
            return error_node();
         }
         else if (details::is_reserved_symbol(var_name))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR191 - Illegal redefinition of reserved keyword: '" + var_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else if (symtab_store_.symbol_exists(var_name))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR192 - Illegal redefinition of variable '" + var_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else if (local_variable_is_shadowed(var_name))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR193 - Illegal redefinition of local variable: '" + var_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!token_is(token_t::e_assign))
         {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR194 - Expected assignment operator after const-variable: '" + var_name + "' definition",
                  exprtk_error_location));
 
               return error_node();
         }
         else if (0 == (initialisation_expression = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR195 - Failed to parse initialisation expression for const-variable: '" + var_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
 
         if (!details::is_literal_node(initialisation_expression))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR196 - initialisation expression for const-variable: '" + var_name + "' must be a constant/literal",
               exprtk_error_location));
 
            free_node(node_allocator_, initialisation_expression);
 
            return error_node();
         }
 
         assert(initialisation_expression);
 
         const T init_value = initialisation_expression->value();
 
         free_node(node_allocator_, initialisation_expression);
 
         expression_node_ptr var_node = reinterpret_cast<expression_node_ptr>(0);
 
         scope_element& se = sem_.get_element(var_name);
 
         if (se.name == var_name)
         {
            if (se.active)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR197 - Illegal redefinition of local variable: '" + var_name + "'",
                  exprtk_error_location));
 
               return error_node();
            }
            else if (scope_element::e_literal == se.type)
            {
               var_node  = se.var_node;
               se.active = true;
               se.depth  = state_.scope_depth;
               se.ref_count++;
            }
         }
 
         if (0 == var_node)
         {
            const std::size_t predicted_total_lclsymb_size = sizeof(T) + sem_.total_local_symb_size_bytes();
 
            if (predicted_total_lclsymb_size > settings().max_total_local_symbol_size_bytes())
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR198 - Adding variable '" + var_name + "' "
                  "will exceed max total local symbol size of: " + details::to_str(settings().max_total_local_symbol_size_bytes()) + " bytes, "
                  "current total size: " + details::to_str(sem_.total_local_symb_size_bytes()) + " bytes",
                  exprtk_error_location));
 
               return error_node();
            }
 
            scope_element nse;
            nse.name      = var_name;
            nse.active    = true;
            nse.ref_count = 1;
            nse.type      = scope_element::e_literal;
            nse.depth     = state_.scope_depth;
            nse.data      = 0;
            nse.var_node  = node_allocator_.allocate<literal_node_t>(init_value);
 
            if (!sem_.add_element(nse))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR199 - Failed to add new local const-variable '" + var_name + "' to SEM",
                  exprtk_error_location));
 
               sem_.free_element(nse);
 
               return error_node();
            }
 
            assert(sem_.total_local_symb_size_bytes() <= settings().max_total_local_symbol_size_bytes());
 
            var_node = nse.var_node;
 
            exprtk_debug(("parse_define_constvar_statement() - INFO - Added new local const-variable: %s\n", nse.name.c_str()));
         }
 
         state_.activate_side_effect("parse_define_constvar_statement()");
 
         lodge_symbol(var_name, e_st_local_variable);
 
         return expression_generator_(var_node->value());
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ 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

Definition at line 29945 of file exprtk.hpp.

      {
         stringvar_node_t* str_node = reinterpret_cast<stringvar_node_t*>(0);
 
         scope_element& se = sem_.get_element(str_name);
 
         if (se.name == str_name)
         {
            if (se.active)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR175 - Illegal redefinition of local variable: '" + str_name + "'",
                  exprtk_error_location));
 
               free_node(node_allocator_, initialisation_expression);
 
               return error_node();
            }
            else if (scope_element::e_string == se.type)
            {
               str_node  = se.str_node;
               se.active = true;
               se.depth  = state_.scope_depth;
               se.ref_count++;
            }
         }
 
         if (0 == str_node)
         {
            scope_element nse;
            nse.name      = str_name;
            nse.active    = true;
            nse.ref_count = 1;
            nse.type      = scope_element::e_string;
            nse.depth     = state_.scope_depth;
            nse.data      = new std::string;
            nse.str_node  = new stringvar_node_t(*reinterpret_cast<std::string*>(nse.data));
 
            if (!sem_.add_element(nse))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR176 - Failed to add new local string variable '" + str_name + "' to SEM",
                  exprtk_error_location));
 
               free_node(node_allocator_, initialisation_expression);
 
               sem_.free_element(nse);
 
               return error_node();
            }
 
            assert(sem_.total_local_symb_size_bytes() <= settings().max_total_local_symbol_size_bytes());
 
            str_node = nse.str_node;
 
            exprtk_debug(("parse_define_string_statement() - INFO - Added new local string variable: %s\n", nse.name.c_str()));
         }
 
         lodge_symbol(str_name, e_st_local_string);
 
         state_.activate_side_effect("parse_define_string_statement()");
 
         expression_node_ptr branch[2] = {0};
 
         branch[0] = str_node;
         branch[1] = initialisation_expression;
 
         return expression_generator_(details::e_assign,branch);
      }

Referenced by exprtk::parser< Type >::parse_define_var_statement().

Here is the caller graph for this function:

◆ parse_define_var_statement()

template<typename T>

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

inlineprivate

Definition at line 30031 of file exprtk.hpp.

      {
         if (settings_.vardef_disabled())
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR177 - Illegal variable definition",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!details::imatch(current_token().value,"var"))
         {
            return error_node();
         }
         else
            next_token();
 
         const std::string var_name = current_token().value;
 
         expression_node_ptr initialisation_expression = error_node();
 
         if (!token_is(token_t::e_symbol))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR178 - Expected a symbol for variable definition",
               exprtk_error_location));
 
            return error_node();
         }
         else if (details::is_reserved_symbol(var_name))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR179 - Illegal redefinition of reserved keyword: '" + var_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else if (symtab_store_.symbol_exists(var_name))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR180 - Illegal redefinition of variable '" + var_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else if (local_variable_is_shadowed(var_name))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR181 - Illegal redefinition of local variable: '" + var_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else if (token_is(token_t::e_lsqrbracket,prsrhlpr_t::e_hold))
         {
            return parse_define_vector_statement(var_name);
         }
         else if (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold))
         {
            return parse_uninitialised_var_statement(var_name);
         }
         else if (token_is(token_t::e_assign))
         {
            if (0 == (initialisation_expression = parse_expression()))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR182 - Failed to parse initialisation expression for variable '" + var_name + "'",
                  exprtk_error_location));
 
               return error_node();
            }
         }
 
         if (
              !token_is(token_t::e_rbracket   , prsrhlpr_t::e_hold) &&
              !token_is(token_t::e_rcrlbracket, prsrhlpr_t::e_hold) &&
              !token_is(token_t::e_rsqrbracket, prsrhlpr_t::e_hold)
            )
         {
            if (!token_is(token_t::e_eof,prsrhlpr_t::e_hold))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR183 - Expected ';' after variable '" + var_name + "' definition",
                  exprtk_error_location));
 
               free_node(node_allocator_, initialisation_expression);
 
               return error_node();
            }
         }
 
         if (
              (0 != initialisation_expression) &&
              details::is_generally_string_node(initialisation_expression)
            )
         {
            return parse_define_string_statement(var_name,initialisation_expression);
         }
 
         expression_node_ptr var_node = reinterpret_cast<expression_node_ptr>(0);
 
         scope_element& se = sem_.get_element(var_name);
 
         if (se.name == var_name)
         {
            if (se.active)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR184 - Illegal redefinition of local variable: '" + var_name + "'",
                  exprtk_error_location));
 
               free_node(node_allocator_, initialisation_expression);
 
               return error_node();
            }
            else if (scope_element::e_variable == se.type)
            {
               var_node  = se.var_node;
               se.active = true;
               se.depth  = state_.scope_depth;
               se.ref_count++;
            }
         }
 
         if (0 == var_node)
         {
            const std::size_t predicted_total_lclsymb_size = sizeof(T) + sem_.total_local_symb_size_bytes();
 
            if (predicted_total_lclsymb_size > settings().max_total_local_symbol_size_bytes())
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR185 - Adding variable '" + var_name + "' "
                  "will exceed max total local symbol size of: " + details::to_str(settings().max_total_local_symbol_size_bytes()) + " bytes, "
                  "current total size: " + details::to_str(sem_.total_local_symb_size_bytes()) + " bytes",
                  exprtk_error_location));
 
               free_node(node_allocator_, initialisation_expression);
 
               return error_node();
            }
 
            scope_element nse;
            nse.name      = var_name;
            nse.active    = true;
            nse.ref_count = 1;
            nse.type      = scope_element::e_variable;
            nse.depth     = state_.scope_depth;
            nse.data      = new T(T(0));
            nse.var_node  = node_allocator_.allocate<variable_node_t>(*reinterpret_cast<T*>(nse.data));
 
            if (!sem_.add_element(nse))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR186 - Failed to add new local variable '" + var_name + "' to SEM",
                  exprtk_error_location));
 
               free_node(node_allocator_, initialisation_expression);
 
               sem_.free_element(nse);
 
               return error_node();
            }
 
            assert(sem_.total_local_symb_size_bytes() <= settings().max_total_local_symbol_size_bytes());
 
            var_node = nse.var_node;
 
            exprtk_debug(("parse_define_var_statement() - INFO - Added new local variable: %s\n", nse.name.c_str()));
         }
 
         state_.activate_side_effect("parse_define_var_statement()");
 
         lodge_symbol(var_name, e_st_local_variable);
 
         expression_node_ptr branch[2] = {0};
 
         branch[0] = var_node;
         branch[1] = initialisation_expression ? initialisation_expression : expression_generator_(T(0));
 
         return expression_generator_(details::e_assign,branch);
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_define_vector_statement()

template<typename T>

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

inlineprivate

Definition at line 29465 of file exprtk.hpp.

      {
         expression_node_ptr size_expression_node = error_node();
 
         if (!token_is(token_t::e_lsqrbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR157 - Expected '[' as part of vector size definition",
               exprtk_error_location));
 
            return error_node();
         }
         else if (0 == (size_expression_node = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR158 - Failed to determine size of vector '" + vec_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!is_constant_node(size_expression_node))
         {
            const bool is_rebaseble_vector =
               (size_expression_node->type() == details::expression_node<T>::e_vecsize) &&
               static_cast<details::vector_size_node<T>*>(size_expression_node)->vec_holder()->rebaseable();
 
            free_node(node_allocator_, size_expression_node);
 
            const std::string error_msg = (is_rebaseble_vector) ?
                                          std::string("Rebasable/Resizable vector cannot be used to define the size of vector") :
                                          std::string("Expected a constant literal number as size of vector");
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR159 - " + error_msg + " '" + vec_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
 
         const T vector_size = size_expression_node->value();
 
         free_node(node_allocator_, size_expression_node);
 
         const std::size_t max_vector_size = settings_.max_local_vector_size();
 
         if (
              (vector_size <= T(0)) ||
              std::not_equal_to<T>()
              (T(0),vector_size - details::numeric::trunc(vector_size)) ||
              (static_cast<std::size_t>(vector_size) > max_vector_size)
            )
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR160 - Invalid vector size. Must be an integer in the "
               "range [0," + details::to_str(static_cast<std::size_t>(max_vector_size)) + "], size: " +
               details::to_str(details::numeric::to_int32(vector_size)),
               exprtk_error_location));
 
            return error_node();
         }
 
         typename symbol_table_t::vector_holder_ptr vec_holder = typename symbol_table_t::vector_holder_ptr(0);
 
         const std::size_t vec_size = static_cast<std::size_t>(details::numeric::to_int32(vector_size));
         const std::size_t predicted_total_lclsymb_size = sizeof(T) * vec_size + sem_.total_local_symb_size_bytes();
 
         if (predicted_total_lclsymb_size > settings().max_total_local_symbol_size_bytes())
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR161 - Adding vector '" + vec_name + "' of size " + details::to_str(vec_size) + " bytes "
               "will exceed max total local symbol size of: " + details::to_str(settings().max_total_local_symbol_size_bytes())  + " bytes, "
               "current total size: " + details::to_str(sem_.total_local_symb_size_bytes()) + " bytes",
               exprtk_error_location));
 
            return error_node();
         }
 
         scope_element& se = sem_.get_element(vec_name);
 
         if (se.name == vec_name)
         {
            if (se.active)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR162 - Illegal redefinition of local vector: '" + vec_name + "'",
                  exprtk_error_location));
 
               return error_node();
            }
            else if (
                      (se.size == vec_size) &&
                      (scope_element::e_vector == se.type)
                    )
            {
               vec_holder = se.vec_node;
               se.active  = true;
               se.depth   = state_.scope_depth;
               se.ref_count++;
            }
         }
 
         if (0 == vec_holder)
         {
            scope_element nse;
            nse.name      = vec_name;
            nse.active    = true;
            nse.ref_count = 1;
            nse.type      = scope_element::e_vector;
            nse.depth     = state_.scope_depth;
            nse.size      = vec_size;
            nse.data      = new T[vec_size];
            nse.vec_node  = new typename scope_element::vector_holder_t(reinterpret_cast<T*>(nse.data),nse.size);
 
            details::set_zero_value(reinterpret_cast<T*>(nse.data),vec_size);
 
            if (!sem_.add_element(nse))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR163 - Failed to add new local vector '" + vec_name + "' to SEM",
                  exprtk_error_location));
 
               sem_.free_element(nse);
 
               return error_node();
            }
 
            assert(sem_.total_local_symb_size_bytes() <= settings().max_total_local_symbol_size_bytes());
 
            vec_holder = nse.vec_node;
 
            exprtk_debug(("parse_define_vector_statement() - INFO - Added new local vector: %s[%d]\n",
                          nse.name.c_str(),
                          static_cast<int>(nse.size)));
         }
 
         state_.activate_side_effect("parse_define_vector_statement()");
 
         lodge_symbol(vec_name, e_st_local_vector);
 
         std::vector<expression_node_ptr> vec_initilizer_list;
 
         scoped_vec_delete<expression_node_t> svd((*this), vec_initilizer_list);
 
         bool single_value_initialiser = false;
         bool range_value_initialiser  = false;
         bool vec_to_vec_initialiser   = false;
         bool null_initialisation      = false;
 
         if (!token_is(token_t::e_rsqrbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR164 - Expected ']' as part of vector size definition",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!token_is(token_t::e_eof, prsrhlpr_t::e_hold))
         {
            if (!token_is(token_t::e_assign))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR165 - Expected ':=' as part of vector definition",
                  exprtk_error_location));
 
               return error_node();
            }
            else if (token_is(token_t::e_lsqrbracket))
            {
               expression_node_ptr initialiser_component = parse_expression();
 
               if (0 == initialiser_component)
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR166 - Failed to parse first component of vector initialiser for vector: " + vec_name,
                     exprtk_error_location));
 
                  return error_node();
               }
 
               vec_initilizer_list.push_back(initialiser_component);
 
               if (token_is(token_t::e_colon))
               {
                  initialiser_component = parse_expression();
 
                  if (0 == initialiser_component)
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR167 - Failed to parse second component of vector initialiser for vector: " + vec_name,
                        exprtk_error_location));
 
                     return error_node();
                  }
 
                  vec_initilizer_list.push_back(initialiser_component);
               }
 
               if (!token_is(token_t::e_rsqrbracket))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR168 - Expected ']' to close single value vector initialiser",
                     exprtk_error_location));
 
                  return error_node();
               }
 
               switch (vec_initilizer_list.size())
               {
                  case 1 : single_value_initialiser = true; break;
                  case 2 : range_value_initialiser  = true; break;
               }
            }
            else if (!token_is(token_t::e_lcrlbracket))
            {
               expression_node_ptr initialiser = error_node();
 
               // Is this a vector to vector assignment and initialisation?
               if (token_t::e_symbol == current_token().type)
               {
                  // Is it a locally defined vector?
                  const scope_element& lcl_se = sem_.get_active_element(current_token().value);
 
                  if (scope_element::e_vector == lcl_se.type)
                  {
                     if (0 != (initialiser = parse_expression()))
                        vec_initilizer_list.push_back(initialiser);
                     else
                        return error_node();
                  }
                  // Are we dealing with a user defined vector?
                  else if (symtab_store_.is_vector(current_token().value))
                  {
                     lodge_symbol(current_token().value, e_st_vector);
 
                     if (0 != (initialiser = parse_expression()))
                        vec_initilizer_list.push_back(initialiser);
                     else
                        return error_node();
                  }
                  // Are we dealing with a null initialisation vector definition?
                  else if (token_is(token_t::e_symbol,"null"))
                     null_initialisation = true;
               }
 
               if (!null_initialisation)
               {
                  if (0 == initialiser)
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR169 - Expected '{' as part of vector initialiser list",
                        exprtk_error_location));
 
                     return error_node();
                  }
                  else
                     vec_to_vec_initialiser = true;
               }
            }
            else if (!token_is(token_t::e_rcrlbracket))
            {
               for ( ; ; )
               {
                  expression_node_ptr initialiser = parse_expression();
 
                  if (0 == initialiser)
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR170 - Expected '{' as part of vector initialiser list",
                        exprtk_error_location));
 
                     return error_node();
                  }
                  else
                     vec_initilizer_list.push_back(initialiser);
 
                  if (token_is(token_t::e_rcrlbracket))
                     break;
 
                  const bool is_next_close = peek_token_is(token_t::e_rcrlbracket);
 
                  if (!token_is(token_t::e_comma) && is_next_close)
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR171 - Expected ',' between vector initialisers",
                        exprtk_error_location));
 
                     return error_node();
                  }
 
                  if (token_is(token_t::e_rcrlbracket))
                     break;
               }
            }
 
            if (
                 !token_is(token_t::e_rbracket   , prsrhlpr_t::e_hold) &&
                 !token_is(token_t::e_rcrlbracket, prsrhlpr_t::e_hold) &&
                 !token_is(token_t::e_rsqrbracket, prsrhlpr_t::e_hold)
               )
            {
               if (!token_is(token_t::e_eof,prsrhlpr_t::e_hold))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR172 - Expected ';' at end of vector definition",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
 
            if (
                 !single_value_initialiser &&
                 !range_value_initialiser  &&
                 (T(vec_initilizer_list.size()) > vector_size)
               )
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR173 - Initialiser list larger than the number of elements in the vector: '" + vec_name + "'",
                  exprtk_error_location));
 
               return error_node();
            }
         }
 
         expression_node_ptr result = error_node();
 
         if (
              (vec_initilizer_list.size() == 1) &&
              single_value_initialiser
            )
         {
            if (details::is_constant_node(vec_initilizer_list[0]))
            {
              // vector_init_zero_value_node   var v[10] := [0]
               if (T(0) == vec_initilizer_list[0]->value())
               {
                  result = node_allocator_
                              .allocate<details::vector_init_zero_value_node<T> >(
                                 (*vec_holder)[0],
                                 vec_size,
                                 vec_initilizer_list);
               }
               else
               {
                  // vector_init_single_constvalue_node   var v[10] := [123]
                  result = node_allocator_
                              .allocate<details::vector_init_single_constvalue_node<T> >(
                                 (*vec_holder)[0],
                                 vec_size,
                                 vec_initilizer_list);
               }
            }
            else
            {
               // vector_init_single_value_node   var v[10] := [123 + (x / y)]
               result = node_allocator_
                           .allocate<details::vector_init_single_value_node<T> >(
                              (*vec_holder)[0],
                              vec_size,
                              vec_initilizer_list);
            }
         }
         else if (
                   (vec_initilizer_list.size() == 2) &&
                   range_value_initialiser
                 )
         {
            bool base_const = details::is_constant_node(vec_initilizer_list[0]);
            bool inc_const  = details::is_constant_node(vec_initilizer_list[1]);
 
            if (base_const && inc_const)
            {
               // vector_init_single_value_node   var v[10] := [1 : 3.5]
               result = node_allocator_
                           .allocate<details::vector_init_iota_constconst_node<T> >(
                              (*vec_holder)[0],
                              vec_size,
                              vec_initilizer_list);
            }
            else if (base_const && !inc_const)
            {
               // vector_init_single_value_node   var v[10] := [1 : x + y]
               result = node_allocator_
                           .allocate<details::vector_init_iota_constnconst_node<T> >(
                              (*vec_holder)[0],
                              vec_size,
                              vec_initilizer_list);
            }
            else if (!base_const && inc_const)
            {
               // vector_init_single_value_node   var v[10] := [x + y : 3]
               result = node_allocator_
                           .allocate<details::vector_init_iota_nconstconst_node<T> >(
                              (*vec_holder)[0],
                              vec_size,
                              vec_initilizer_list);
            }
            else if (!base_const && !inc_const)
            {
               // vector_init_single_value_node   var v[10] := [x + y :  z / w]
               result = node_allocator_
                           .allocate<details::vector_init_iota_nconstnconst_node<T> >(
                              (*vec_holder)[0],
                              vec_size,
                              vec_initilizer_list);
            }
         }
         else if (null_initialisation)
            result = expression_generator_(T(0.0));
         else if (vec_to_vec_initialiser)
         {
            expression_node_ptr vec_node = node_allocator_.allocate<vector_node_t>(vec_holder);
 
            result = expression_generator_(
                        details::e_assign,
                        vec_node,
                        vec_initilizer_list[0]);
         }
         else
         {
            result = node_allocator_
                        .allocate<details::vector_initialisation_node<T> >(
                           (*vec_holder)[0],
                           vec_size,
                           vec_initilizer_list,
                           single_value_initialiser);
         }
 
         svd.delete_ptr = false;
 
         if (result && result->valid())
         {
            return result;
         }
 
         details::free_node(node_allocator_, result);
 
         set_error(make_error(
            parser_error::e_synthesis,
            current_token(),
            "ERR174 - Failed to generate initialisation node for vector: " + vec_name,
            exprtk_error_location));
 
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_define_var_statement().

Here is the caller graph for this function:

◆ parse_expression()

template<typename T>

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

inlineprivate

Definition at line 25480 of file exprtk.hpp.

      {
         if (halt_compilation_check())
         {
            exprtk_debug(("halt_compilation_check() - parse_expression checkpoint 2\n"));
            return error_node();
         }
 
         stack_limit_handler slh(*this);
 
         if (!slh)
         {
            return error_node();
         }
 
         expression_node_ptr expression = parse_branch(precedence);
 
         if (0 == expression)
         {
            return error_node();
         }
 
         if (token_is(token_t::e_eof,prsrhlpr_t::e_hold))
         {
            return expression;
         }
 
         bool break_loop = false;
 
         state_t current_state;
 
         for ( ; ; )
         {
            current_state.reset();
 
            switch (current_token().type)
            {
               case token_t::e_assign : current_state.set(e_level00, e_level00, details::e_assign, current_token()); break;
               case token_t::e_addass : current_state.set(e_level00, e_level00, details::e_addass, current_token()); break;
               case token_t::e_subass : current_state.set(e_level00, e_level00, details::e_subass, current_token()); break;
               case token_t::e_mulass : current_state.set(e_level00, e_level00, details::e_mulass, current_token()); break;
               case token_t::e_divass : current_state.set(e_level00, e_level00, details::e_divass, current_token()); break;
               case token_t::e_modass : current_state.set(e_level00, e_level00, details::e_modass, current_token()); break;
               case token_t::e_swap   : current_state.set(e_level00, e_level00, details::e_swap  , current_token()); break;
               case token_t::e_lt     : current_state.set(e_level05, e_level06, details::e_lt    , current_token()); break;
               case token_t::e_lte    : current_state.set(e_level05, e_level06, details::e_lte   , current_token()); break;
               case token_t::e_eq     : current_state.set(e_level05, e_level06, details::e_eq    , current_token()); break;
               case token_t::e_ne     : current_state.set(e_level05, e_level06, details::e_ne    , current_token()); break;
               case token_t::e_gte    : current_state.set(e_level05, e_level06, details::e_gte   , current_token()); break;
               case token_t::e_gt     : current_state.set(e_level05, e_level06, details::e_gt    , current_token()); break;
               case token_t::e_add    : current_state.set(e_level07, e_level08, details::e_add   , current_token()); break;
               case token_t::e_sub    : current_state.set(e_level07, e_level08, details::e_sub   , current_token()); break;
               case token_t::e_div    : current_state.set(e_level10, e_level11, details::e_div   , current_token()); break;
               case token_t::e_mul    : current_state.set(e_level10, e_level11, details::e_mul   , current_token()); break;
               case token_t::e_mod    : current_state.set(e_level10, e_level11, details::e_mod   , current_token()); break;
               case token_t::e_pow    : current_state.set(e_level12, e_level12, details::e_pow   , current_token()); break;
               default                :
                  if (token_t::e_symbol == current_token().type)
                  {
                     static const std::string s_and   = "and"  ;
                     static const std::string s_nand  = "nand" ;
                     static const std::string s_or    = "or"   ;
                     static const std::string s_nor   = "nor"  ;
                     static const std::string s_xor   = "xor"  ;
                     static const std::string s_xnor  = "xnor" ;
                     static const std::string s_in    = "in"   ;
                     static const std::string s_like  = "like" ;
                     static const std::string s_ilike = "ilike";
                     static const std::string s_and1  = "&"    ;
                     static const std::string s_or1   = "|"    ;
                     static const std::string s_not   = "not"  ;
 
                     if (details::imatch(current_token().value,s_and))
                     {
                        current_state.set(e_level03, e_level04, details::e_and, current_token());
                        break;
                     }
                     else if (details::imatch(current_token().value,s_and1))
                     {
                        #ifndef exprtk_disable_sc_andor
                        current_state.set(e_level03, e_level04, details::e_scand, current_token());
                        #else
                        current_state.set(e_level03, e_level04, details::e_and, current_token());
                        #endif
                        break;
                     }
                     else if (details::imatch(current_token().value,s_nand))
                     {
                        current_state.set(e_level03, e_level04, details::e_nand, current_token());
                        break;
                     }
                     else if (details::imatch(current_token().value,s_or))
                     {
                        current_state.set(e_level01, e_level02, details::e_or, current_token());
                        break;
                     }
                     else if (details::imatch(current_token().value,s_or1))
                     {
                        #ifndef exprtk_disable_sc_andor
                        current_state.set(e_level01, e_level02, details::e_scor, current_token());
                        #else
                        current_state.set(e_level01, e_level02, details::e_or, current_token());
                        #endif
                        break;
                     }
                     else if (details::imatch(current_token().value,s_nor))
                     {
                        current_state.set(e_level01, e_level02, details::e_nor, current_token());
                        break;
                     }
                     else if (details::imatch(current_token().value,s_xor))
                     {
                        current_state.set(e_level01, e_level02, details::e_xor, current_token());
                        break;
                     }
                     else if (details::imatch(current_token().value,s_xnor))
                     {
                        current_state.set(e_level01, e_level02, details::e_xnor, current_token());
                        break;
                     }
                     else if (details::imatch(current_token().value,s_in))
                     {
                        current_state.set(e_level04, e_level04, details::e_in, current_token());
                        break;
                     }
                     else if (details::imatch(current_token().value,s_like))
                     {
                        current_state.set(e_level04, e_level04, details::e_like, current_token());
                        break;
                     }
                     else if (details::imatch(current_token().value,s_ilike))
                     {
                        current_state.set(e_level04, e_level04, details::e_ilike, current_token());
                        break;
                     }
                     else if (details::imatch(current_token().value,s_not))
                     {
                        break;
                     }
                  }
 
                  break_loop = true;
            }
 
            if (break_loop)
            {
               parse_pending_string_rangesize(expression);
               break;
            }
            else if (current_state.left < precedence)
               break;
 
            const lexer::token prev_token = current_token();
 
            next_token();
 
            expression_node_ptr right_branch   = error_node();
            expression_node_ptr new_expression = error_node();
 
            if (is_invalid_logic_operation(current_state.operation))
            {
               free_node(node_allocator_, expression);
 
               set_error(make_error(
                  parser_error::e_syntax,
                  prev_token,
                  "ERR012 - Invalid or disabled logic operation '" + details::to_str(current_state.operation) + "'",
                  exprtk_error_location));
 
               return error_node();
            }
            else if (is_invalid_arithmetic_operation(current_state.operation))
            {
               free_node(node_allocator_, expression);
 
               set_error(make_error(
                  parser_error::e_syntax,
                  prev_token,
                  "ERR013 - Invalid or disabled arithmetic operation '" + details::to_str(current_state.operation) + "'",
                  exprtk_error_location));
 
               return error_node();
            }
            else if (is_invalid_inequality_operation(current_state.operation))
            {
               free_node(node_allocator_, expression);
 
               set_error(make_error(
                  parser_error::e_syntax,
                  prev_token,
                  "ERR014 - Invalid inequality operation '" + details::to_str(current_state.operation) + "'",
                  exprtk_error_location));
 
               return error_node();
            }
            else if (is_invalid_assignment_operation(current_state.operation))
            {
               free_node(node_allocator_, expression);
 
               set_error(make_error(
                  parser_error::e_syntax,
                  prev_token,
                  "ERR015 - Invalid or disabled assignment operation '" + details::to_str(current_state.operation) + "'",
                  exprtk_error_location));
 
               return error_node();
            }
 
            if (0 != (right_branch = parse_expression(current_state.right)))
            {
               if (
                    details::is_return_node(expression  ) ||
                    details::is_return_node(right_branch)
                  )
               {
                  free_node(node_allocator_, expression  );
                  free_node(node_allocator_, right_branch);
 
                  set_error(make_error(
                     parser_error::e_syntax,
                     prev_token,
                     "ERR016 - Return statements cannot be part of sub-expressions",
                     exprtk_error_location));
 
                  return error_node();
               }
 
               push_current_state(current_state);
 
               new_expression = expression_generator_
                                  (
                                    current_state.operation,
                                    expression,
                                    right_branch
                                  );
 
               pop_current_state();
            }
 
            if (0 == new_expression)
            {
               if (error_list_.empty())
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     prev_token,
                     !synthesis_error_.empty() ?
                     synthesis_error_ :
                     "ERR017 - General parsing error at token: '" + prev_token.value + "'",
                     exprtk_error_location));
               }
 
               free_node(node_allocator_, expression  );
               free_node(node_allocator_, right_branch);
 
               return error_node();
            }
            else
            {
               if (
                    token_is(token_t::e_ternary,prsrhlpr_t::e_hold) &&
                    (e_level00 == precedence)
                  )
               {
                  expression = parse_ternary_conditional_statement(new_expression);
               }
               else
                  expression = new_expression;
 
               parse_pending_string_rangesize(expression);
            }
         }
 
         if ((0 != expression) && (expression->node_depth() > settings_.max_node_depth_))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR018 - Expression depth of " + details::to_str(static_cast<int>(expression->node_depth())) +
               " exceeds maximum allowed expression depth of " + details::to_str(static_cast<int>(settings_.max_node_depth_)),
               exprtk_error_location));
 
            free_node(node_allocator_, expression);
 
            return error_node();
         }
         else if (
                   !settings_.commutative_check_enabled()          &&
                   !details::is_logic_opr(current_token().value)   &&
                   (current_state.operation == details::e_default) &&
                   (
                     current_token().type == token_t::e_symbol ||
                     current_token().type == token_t::e_number ||
                     current_token().type == token_t::e_string
                   )
                 )
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR019 - Invalid syntax '" + current_token().value  + "' possible missing operator or context",
               exprtk_error_location));
 
            free_node(node_allocator_, expression);
 
            return error_node();
         }
 
         return expression;
      }

Here is the caller graph for this function:

◆ parse_for_loop()

template<typename T>

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

inlineprivate

Definition at line 27144 of file exprtk.hpp.

      {
         expression_node_ptr initialiser = error_node();
         expression_node_ptr condition   = error_node();
         expression_node_ptr incrementor = error_node();
         expression_node_ptr loop_body   = error_node();
 
         scope_element* se = 0;
         bool result       = true;
 
         next_token();
 
         scope_handler sh(*this);
 
         if (!token_is(token_t::e_lbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR077 - Expected '(' at start of for-loop",
               exprtk_error_location));
 
            return error_node();
         }
 
         if (!token_is(token_t::e_eof))
         {
            if (
                 !token_is(token_t::e_symbol,prsrhlpr_t::e_hold) &&
                 details::imatch(current_token().value,"var")
               )
            {
               next_token();
 
               if (!token_is(token_t::e_symbol,prsrhlpr_t::e_hold))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR078 - Expected a variable at the start of initialiser section of for-loop",
                     exprtk_error_location));
 
                  return error_node();
               }
               else if (!peek_token_is(token_t::e_assign))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR079 - Expected variable assignment of initialiser section of for-loop",
                     exprtk_error_location));
 
                  return error_node();
               }
 
               const std::string loop_counter_symbol = current_token().value;
 
               se = &sem_.get_element(loop_counter_symbol);
 
               if ((se->name == loop_counter_symbol) && se->active)
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR080 - For-loop variable '" + loop_counter_symbol+ "' is being shadowed by a previous declaration",
                     exprtk_error_location));
 
                  return error_node();
               }
               else if (!symtab_store_.is_variable(loop_counter_symbol))
               {
                  if (
                       !se->active &&
                       (se->name == loop_counter_symbol) &&
                       (se->type == scope_element::e_variable)
                     )
                  {
                     se->active = true;
                     se->ref_count++;
                  }
                  else
                  {
                     scope_element nse;
                     nse.name      = loop_counter_symbol;
                     nse.active    = true;
                     nse.ref_count = 1;
                     nse.type      = scope_element::e_variable;
                     nse.depth     = state_.scope_depth;
                     nse.data      = new T(T(0));
                     nse.var_node  = node_allocator_.allocate<variable_node_t>(*reinterpret_cast<T*>(nse.data));
 
                     if (!sem_.add_element(nse))
                     {
                        set_error(make_error(
                           parser_error::e_syntax,
                           current_token(),
                           "ERR081 - Failed to add new local variable '" + loop_counter_symbol + "' to SEM",
                           exprtk_error_location));
 
                        sem_.free_element(nse);
 
                        result = false;
                     }
                     else
                     {
                        exprtk_debug(("parse_for_loop() - INFO - Added new local variable: %s\n", nse.name.c_str()));
 
                        state_.activate_side_effect("parse_for_loop()");
                     }
                  }
               }
            }
 
            if (0 == (initialiser = parse_expression()))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR082 - Failed to parse initialiser of for-loop",
                  exprtk_error_location));
 
               result = false;
            }
            else if (!token_is(token_t::e_eof))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR083 - Expected ';' after initialiser of for-loop",
                  exprtk_error_location));
 
               result = false;
            }
         }
 
         if (!token_is(token_t::e_eof))
         {
            if (0 == (condition = parse_expression()))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR084 - Failed to parse condition of for-loop",
                  exprtk_error_location));
 
               result = false;
            }
            else if (!token_is(token_t::e_eof))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR085 - Expected ';' after condition section of for-loop",
                  exprtk_error_location));
 
               result = false;
            }
         }
 
         if (!token_is(token_t::e_rbracket))
         {
            if (0 == (incrementor = parse_expression()))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR086 - Failed to parse incrementor of for-loop",
                  exprtk_error_location));
 
               result = false;
            }
            else if (!token_is(token_t::e_rbracket))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR087 - Expected ')' after incrementor section of for-loop",
                  exprtk_error_location));
 
               result = false;
            }
         }
 
         if (result)
         {
            brkcnt_list_.push_front(false);
 
            scoped_inc_dec sid(state_.parsing_loop_stmt_count);
 
            if (0 == (loop_body = parse_multi_sequence("for-loop", true)))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR088 - Failed to parse body of for-loop",
                  exprtk_error_location));
 
               result = false;
            }
         }
 
         if (!result)
         {
            if (se)
            {
               se->ref_count--;
            }
 
            free_node(node_allocator_, initialiser);
            free_node(node_allocator_, condition  );
            free_node(node_allocator_, incrementor);
            free_node(node_allocator_, loop_body  );
            return error_node();
         }
 
         expression_node_ptr result_node =
            expression_generator_.for_loop(initialiser,
                                           condition,
                                           incrementor,
                                           loop_body,
                                           brkcnt_list_.front());
         handle_brkcnt_scope_exit();
 
         if (result_node && result_node->valid())
         {
            return result_node;
         }
 
         set_error(make_error(
            parser_error::e_synthesis,
            current_token(),
            "ERR089 - Failed to synthesize 'valid' for-loop",
            exprtk_error_location));
 
         free_node(node_allocator_, result_node);
 
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ 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

Definition at line 26086 of file exprtk.hpp.

      {
         #ifdef _MSC_VER
            #pragma warning(push)
            #pragma warning(disable: 4127)
         #endif
         if (0 == NumberofParameters)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR023 - Expecting ifunction '" + function_name + "' to have non-zero parameter count",
               exprtk_error_location));
 
            return error_node();
         }
         #ifdef _MSC_VER
            #pragma warning(pop)
         #endif
 
         expression_node_ptr branch[NumberofParameters];
         expression_node_ptr result  = error_node();
 
         std::fill_n(branch, NumberofParameters, reinterpret_cast<expression_node_ptr>(0));
 
         scoped_delete<expression_node_t,NumberofParameters> sd((*this),branch);
 
         next_token();
 
         if (!token_is(token_t::e_lbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR024 - Expecting argument list for function: '" + function_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
 
         for (int i = 0; i < static_cast<int>(NumberofParameters); ++i)
         {
            branch[i] = parse_expression();
 
            if (0 == branch[i])
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR025 - Failed to parse argument " + details::to_str(i) + " for function: '" + function_name + "'",
                  exprtk_error_location));
 
               return error_node();
            }
            else if (i < static_cast<int>(NumberofParameters - 1))
            {
               if (!token_is(token_t::e_comma))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR026 - Invalid number of arguments for function: '" + function_name + "'",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
         }
 
         if (!token_is(token_t::e_rbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR027 - Invalid number of arguments for function: '" + function_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else
            result = expression_generator_.function(function,branch);
 
         sd.delete_ptr = (0 == result);
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_function_invocation().

Here is the caller graph for this function:

◆ 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

Definition at line 26173 of file exprtk.hpp.

      {
         expression_node_ptr result = expression_generator_.function(function);
 
         state_.side_effect_present = function->has_side_effects();
 
         next_token();
 
         if (
               token_is(token_t::e_lbracket) &&
              !token_is(token_t::e_rbracket)
            )
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR028 - Expecting '()' to proceed call to function: '" + function_name + "'",
               exprtk_error_location));
 
            free_node(node_allocator_, result);
 
            return error_node();
         }
         else
            return result;
      }

Referenced by exprtk::parser< Type >::parse_function_invocation().

Here is the caller graph for this function:

◆ parse_function_invocation()

template<typename T>

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

inlineprivate

Definition at line 26033 of file exprtk.hpp.

      {
         expression_node_ptr func_node = reinterpret_cast<expression_node_ptr>(0);
 
         switch (function->param_count)
         {
            case  0 : func_node = parse_function_call_0  (function,function_name); break;
            case  1 : func_node = parse_function_call< 1>(function,function_name); break;
            case  2 : func_node = parse_function_call< 2>(function,function_name); break;
            case  3 : func_node = parse_function_call< 3>(function,function_name); break;
            case  4 : func_node = parse_function_call< 4>(function,function_name); break;
            case  5 : func_node = parse_function_call< 5>(function,function_name); break;
            case  6 : func_node = parse_function_call< 6>(function,function_name); break;
            case  7 : func_node = parse_function_call< 7>(function,function_name); break;
            case  8 : func_node = parse_function_call< 8>(function,function_name); break;
            case  9 : func_node = parse_function_call< 9>(function,function_name); break;
            case 10 : func_node = parse_function_call<10>(function,function_name); break;
            case 11 : func_node = parse_function_call<11>(function,function_name); break;
            case 12 : func_node = parse_function_call<12>(function,function_name); break;
            case 13 : func_node = parse_function_call<13>(function,function_name); break;
            case 14 : func_node = parse_function_call<14>(function,function_name); break;
            case 15 : func_node = parse_function_call<15>(function,function_name); break;
            case 16 : func_node = parse_function_call<16>(function,function_name); break;
            case 17 : func_node = parse_function_call<17>(function,function_name); break;
            case 18 : func_node = parse_function_call<18>(function,function_name); break;
            case 19 : func_node = parse_function_call<19>(function,function_name); break;
            case 20 : func_node = parse_function_call<20>(function,function_name); break;
            default : {
                         set_error(make_error(
                           parser_error::e_syntax,
                           current_token(),
                           "ERR021 - Invalid number of parameters for function: '" + function_name + "'",
                           exprtk_error_location));
 
                         return error_node();
                      }
         }
 
         if (func_node)
            return func_node;
         else
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR022 - Failed to generate call to function: '" + function_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
      }

Referenced by exprtk::parser< Type >::parse_symtab_symbol().

Here is the caller graph for this function:

◆ 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

Definition at line 28937 of file exprtk.hpp.

      {
         std::vector<expression_node_ptr> arg_list;
 
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         next_token();
 
         std::string param_type_list;
 
         type_checker tc(
            (*this),
            function_name,
            function->parameter_sequence,
            type_checker::e_string);
 
         if (tc.invalid())
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR136 - Type checker instantiation failure for generic function: " + function_name,
               exprtk_error_location));
 
            return error_node();
         }
 
         if (token_is(token_t::e_lbracket))
         {
            if (token_is(token_t::e_rbracket))
            {
               if (
                    !function->allow_zero_parameters() &&
                    !tc       .allow_zero_parameters()
                  )
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR137 - Zero parameter call to generic function: "
                     + function_name + " not allowed",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
            else
            {
               for ( ; ; )
               {
                  expression_node_ptr arg = parse_expression();
 
                  if (0 == arg)
                     return error_node();
 
                  if (is_ivector_node(arg))
                     param_type_list += 'V';
                  else if (is_generally_string_node(arg))
                     param_type_list += 'S';
                  else // Everything else is assumed to be a scalar returning expression
                     param_type_list += 'T';
 
                  arg_list.push_back(arg);
 
                  if (token_is(token_t::e_rbracket))
                     break;
                  else if (!token_is(token_t::e_comma))
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR138 - Expected ',' for call to generic function: " + function_name,
                        exprtk_error_location));
 
                     return error_node();
                  }
               }
            }
         }
         else if (
                   !function->parameter_sequence.empty() &&
                   function->allow_zero_parameters    () &&
                   !tc      .allow_zero_parameters    ()
                 )
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR139 - Zero parameter call to generic function: "
               + function_name + " not allowed",
               exprtk_error_location));
 
            return error_node();
         }
 
         std::size_t param_seq_index = 0;
 
         if (
              state_.type_check_enabled &&
              !tc.verify(param_type_list, param_seq_index)
            )
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR140 - Invalid input parameter sequence for call to generic function: " + function_name,
               exprtk_error_location));
 
            return error_node();
         }
 
         expression_node_ptr result =
            (tc.paramseq_count() <= 1) ?
               expression_generator_
                  .generic_function_call(function, arg_list) :
               expression_generator_
                  .generic_function_call(function, arg_list, param_seq_index);
 
         svd.delete_ptr = (0 == result);
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_symtab_symbol().

Here is the caller graph for this function:

◆ 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

Definition at line 29060 of file exprtk.hpp.

      {
         if (token_is(token_t::e_lbracket))
         {
            if (token_is(token_t::e_rbracket))
            {
               if (
                    !function->allow_zero_parameters() &&
                    !tc       .allow_zero_parameters()
                  )
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR141 - Zero parameter call to generic function: "
                     + function_name + " not allowed",
                     exprtk_error_location));
 
                  return false;
               }
            }
            else
            {
               for ( ; ; )
               {
                  expression_node_ptr arg = parse_expression();
 
                  if (0 == arg)
                     return false;
 
                  if (is_ivector_node(arg))
                     param_type_list += 'V';
                  else if (is_generally_string_node(arg))
                     param_type_list += 'S';
                  else // Everything else is a scalar returning expression
                     param_type_list += 'T';
 
                  arg_list.push_back(arg);
 
                  if (token_is(token_t::e_rbracket))
                     break;
                  else if (!token_is(token_t::e_comma))
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR142 - Expected ',' for call to string function: " + function_name,
                        exprtk_error_location));
 
                     return false;
                  }
               }
            }
 
            return true;
         }
         else
            return false;
      }

Referenced by exprtk::parser< Type >::parse_overload_function_call(), and exprtk::parser< Type >::parse_string_function_call().

Here is the caller graph for this function:

◆ 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

Definition at line 27999 of file exprtk.hpp.

      {
         token_t::token_type open_bracket  = token_t::e_lcrlbracket;
         token_t::token_type close_bracket = token_t::e_rcrlbracket;
         token_t::token_type separator     = token_t::e_eof;
 
         if (!token_is(open_bracket))
         {
            if (!enforce_crlbrackets && token_is(token_t::e_lbracket))
            {
               open_bracket  = token_t::e_lbracket;
               close_bracket = token_t::e_rbracket;
               separator     = token_t::e_comma;
            }
            else
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR111 - Expected '" + token_t::to_str(open_bracket) + "' for call to multi-sequence" +
                  ((!source.empty()) ? std::string(" section of " + source): ""),
                  exprtk_error_location));
 
               return error_node();
            }
         }
         else if (token_is(close_bracket))
         {
            return node_allocator_.allocate<details::null_node<T> >();
         }
 
         std::vector<expression_node_ptr> arg_list;
         std::vector<bool> side_effect_list;
 
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         scope_handler sh(*this);
 
         scoped_bool_or_restorer sbr(state_.side_effect_present);
 
         for ( ; ; )
         {
            state_.side_effect_present = false;
 
            expression_node_ptr arg = parse_expression();
 
            if (0 == arg)
               return error_node();
            else
            {
               arg_list.push_back(arg);
               side_effect_list.push_back(state_.side_effect_present);
            }
 
            if (token_is(close_bracket))
               break;
 
            const bool is_next_close = peek_token_is(close_bracket);
 
            if (!token_is(separator) && is_next_close)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR112 - Expected '" + lexer::token::seperator_to_str(separator) + "' for call to multi-sequence section of " + source,
                  exprtk_error_location));
 
               return error_node();
            }
 
            if (token_is(close_bracket))
               break;
         }
 
         expression_node_ptr result = simplify(arg_list, side_effect_list, source.empty());
 
         svd.delete_ptr = (0 == result);
         return result;
      }

Referenced by exprtk::parser< Type >::parse_conditional_statement_02(), exprtk::parser< Type >::parse_for_loop(), exprtk::parser< Type >::parse_multi_switch_statement(), exprtk::parser< Type >::parse_switch_statement(), exprtk::parser< Type >::parse_vararg_function(), and exprtk::parser< Type >::parse_while_loop().

Here is the caller graph for this function:

◆ parse_multi_switch_statement()

template<typename T>

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

inlineprivate

Definition at line 27555 of file exprtk.hpp.

      {
         std::vector<expression_node_ptr> arg_list;
 
         if (!details::imatch(current_token().value,"[*]"))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR098 - Expected token '[*]'",
               exprtk_error_location));
 
            return error_node();
         }
 
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         next_token();
 
         if (!token_is(token_t::e_lcrlbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR099 - Expected '{' for call to [*] statement",
               exprtk_error_location));
 
            return error_node();
         }
 
         for ( ; ; )
         {
            if (!details::imatch("case",current_token().value))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR100 - Expected a 'case' statement for multi-switch",
                  exprtk_error_location));
 
               return error_node();
            }
 
            next_token();
 
            expression_node_ptr condition = parse_expression();
 
            if (0 == condition)
               return error_node();
 
            if (!token_is(token_t::e_colon))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR101 - Expected ':' for case of [*] statement",
                  exprtk_error_location));
 
               free_node(node_allocator_, condition);
 
               return error_node();
            }
 
            expression_node_ptr consequent =
               (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold)) ?
               parse_multi_sequence("multi-switch-consequent") :
               parse_expression();
 
            if (0 == consequent)
            {
               free_node(node_allocator_, condition);
               return error_node();
            }
 
            if (!token_is(token_t::e_eof))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR102 - Expected ';' at end of case for [*] statement",
                  exprtk_error_location));
 
               free_node(node_allocator_, condition );
               free_node(node_allocator_, consequent);
 
               return error_node();
            }
 
            // Can we optimise away the case statement?
            if (is_constant_node(condition) && is_false(condition))
            {
               free_node(node_allocator_, condition );
               free_node(node_allocator_, consequent);
            }
            else
            {
               arg_list.push_back(condition );
               arg_list.push_back(consequent);
            }
 
            if (token_is(token_t::e_rcrlbracket,prsrhlpr_t::e_hold))
            {
               break;
            }
         }
 
         if (!token_is(token_t::e_rcrlbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR103 - Expected '}' at end of [*] statement",
               exprtk_error_location));
 
            return error_node();
         }
 
         const expression_node_ptr result = expression_generator_.multi_switch_statement(arg_list);
 
         svd.delete_ptr = (0 == result);
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_vararg_function().

Here is the caller graph for this function:

◆ parse_not_statement()

template<typename T>

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

inlineprivate

Definition at line 26865 of file exprtk.hpp.

      {
         if (settings_.logic_disabled("not"))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR063 - Invalid or disabled logic operation 'not'",
               exprtk_error_location));
 
            return error_node();
         }
 
         return parse_base_operation();
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_null_statement()

template<typename T>

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

inlineprivate

Definition at line 29359 of file exprtk.hpp.

      {
         next_token();
         return node_allocator_.allocate<details::null_node<T> >();
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ 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

Definition at line 29175 of file exprtk.hpp.

      {
         // Move pass the function name
         next_token();
 
         std::string param_type_list;
 
         type_checker tc((*this), function_name, function->parameter_sequence, type_checker::e_overload);
 
         if (
              (!function->parameter_sequence.empty()) &&
              (0 == tc.paramseq_count())
            )
         {
            return error_node();
         }
 
         std::vector<expression_node_ptr> arg_list;
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         if (!parse_igeneric_function_params(param_type_list, arg_list, function_name, function, tc))
         {
            return error_node();
         }
 
         std::size_t param_seq_index = 0;
 
         if (!tc.verify(param_type_list, param_seq_index))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR144 - Invalid input parameter sequence for call to overloaded function: " + function_name,
               exprtk_error_location));
 
            return error_node();
         }
 
         expression_node_ptr result = error_node();
 
         if (type_checker::e_numeric == tc.return_type(param_seq_index))
         {
            if (tc.paramseq_count() <= 1)
               result = expression_generator_
                          .generic_function_call(function, arg_list);
            else
               result = expression_generator_
                          .generic_function_call(function, arg_list, param_seq_index);
         }
         else if (type_checker::e_string == tc.return_type(param_seq_index))
         {
            if (tc.paramseq_count() <= 1)
               result = expression_generator_
                          .string_function_call(function, arg_list);
            else
               result = expression_generator_
                          .string_function_call(function, arg_list, param_seq_index);
         }
         else
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR145 - Invalid return type for call to overloaded function: " + function_name,
               exprtk_error_location));
         }
 
         svd.delete_ptr = (0 == result);
         return result;
      }

Referenced by exprtk::parser< Type >::parse_symtab_symbol().

Here is the caller graph for this function:

◆ parse_pending_string_rangesize()

template<typename T>

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

inlineprivate

Definition at line 27838 of file exprtk.hpp.

      {
         // Allow no more than 100 range calls, eg: s[][][]...[][]
         const std::size_t max_rangesize_parses = 100;
 
         std::size_t i = 0;
 
         while
            (
              (0 != expression)                     &&
              (i++ < max_rangesize_parses)          &&
              error_list_.empty()                   &&
              is_generally_string_node(expression)  &&
              token_is(token_t::e_lsqrbracket,prsrhlpr_t::e_hold)
            )
         {
            expression = parse_string_range_statement(expression);
         }
 
         return (i > 1);
      }

Referenced by exprtk::parser< Type >::parse_branch(), and exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ parse_pending_vector_index_operator()

template<typename T>

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

inlineprivate

Definition at line 27860 of file exprtk.hpp.

      {
         if
            (
              (0 != expression)           &&
              error_list_.empty()         &&
              is_ivector_node(expression)
            )
         {
            if (
                 settings_.commutative_check_enabled()       &&
                 token_is(token_t::e_mul,prsrhlpr_t::e_hold) &&
                 peek_token_is(token_t::e_lsqrbracket)
               )
            {
               token_is(token_t::e_mul);
               token_is(token_t::e_lsqrbracket);
            }
            else if (token_is(token_t::e_lsqrbracket,prsrhlpr_t::e_hold))
            {
               token_is(token_t::e_lsqrbracket);
            }
            else if (
                      token_is(token_t::e_rbracket,prsrhlpr_t::e_hold) &&
                      peek_token_is(token_t::e_lsqrbracket)
                    )
            {
               token_is(token_t::e_rbracket   );
               token_is(token_t::e_lsqrbracket);
            }
            else
               return;
 
            details::vector_interface<T>* vi = dynamic_cast<details::vector_interface<T>*>(expression);
 
            if (vi)
            {
               details::vector_holder<T>& vec = vi->vec()->vec_holder();
               const std::string vector_name  = sem_.get_vector_name(vec.data());
               expression_node_ptr index      = parse_vector_index(vector_name);
 
               if (index)
               {
                  expression = synthesize_vector_element(vector_name, &vec, expression, index);
                  return;
               }
            }
 
            free_node(node_allocator_, expression);
            expression = error_node();
         }
      }

Referenced by exprtk::parser< Type >::parse_branch().

Here is the caller graph for this function:

◆ parse_range()

template<typename T>

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

inlineprivate

Definition at line 28080 of file exprtk.hpp.

      {
         // Examples of valid ranges:
         // 1. [1:5]     -> [1,5)
         // 2. [ :5]     -> [0,5)
         // 3. [1: ]     -> [1,end)
         // 4. [x:y]     -> [x,y) where x <= y
         // 5. [x+1:y/2] -> [x+1,y/2) where x+1 <= y/2
         // 6. [ :y]     -> [0,y) where 0 <= y
         // 7. [x: ]     -> [x,end) where x <= end
 
         rp.clear();
 
         if (!skip_lsqr && !token_is(token_t::e_lsqrbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR113 - Expected '[' for start of range",
               exprtk_error_location));
 
            return false;
         }
 
         if (token_is(token_t::e_colon))
         {
            rp.n0_c.first  = true;
            rp.n0_c.second = 0;
            rp.cache.first = 0;
         }
         else
         {
            expression_node_ptr r0 = parse_expression();
 
            if (0 == r0)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR114 - Failed parse begin section of range",
                  exprtk_error_location));
 
               return false;
            }
            else if (is_constant_node(r0))
            {
               const T r0_value = r0->value();
 
               if (r0_value >= T(0))
               {
                  rp.n0_c.first  = true;
                  rp.n0_c.second = static_cast<std::size_t>(details::numeric::to_int64(r0_value));
                  rp.cache.first = rp.n0_c.second;
               }
 
               free_node(node_allocator_, r0);
 
               if (r0_value < T(0))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR115 - Range lower bound less than zero! Constraint: r0 >= 0",
                     exprtk_error_location));
 
                  return false;
               }
            }
            else
            {
               rp.n0_e.first  = true;
               rp.n0_e.second = r0;
            }
 
            if (!token_is(token_t::e_colon))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR116 - Expected ':' for break  in range",
                  exprtk_error_location));
 
               rp.free();
 
               return false;
            }
         }
 
         if (token_is(token_t::e_rsqrbracket))
         {
            rp.n1_c.first  = true;
            rp.n1_c.second = std::numeric_limits<std::size_t>::max();
         }
         else
         {
            expression_node_ptr r1 = parse_expression();
 
            if (0 == r1)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR117 - Failed parse end section of range",
                  exprtk_error_location));
 
               rp.free();
 
               return false;
            }
            else if (is_constant_node(r1))
            {
               const T r1_value = r1->value();
 
               if (r1_value >= T(0))
               {
                  rp.n1_c.first   = true;
                  rp.n1_c.second  = static_cast<std::size_t>(details::numeric::to_int64(r1_value));
                  rp.cache.second = rp.n1_c.second;
               }
 
               free_node(node_allocator_, r1);
 
               if (r1_value < T(0))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR118 - Range upper bound less than zero! Constraint: r1 >= 0",
                     exprtk_error_location));
 
                  rp.free();
 
                  return false;
               }
            }
            else
            {
               rp.n1_e.first  = true;
               rp.n1_e.second = r1;
            }
 
            if (!token_is(token_t::e_rsqrbracket))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR119 - Expected ']' for start of range",
                  exprtk_error_location));
 
               rp.free();
 
               return false;
            }
         }
 
         if (rp.const_range())
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;
 
            bool rp_result = false;
 
            try
            {
               rp_result = rp(r0, r1, typename range_t::size_holder_t());
            }
            catch (std::runtime_error&)
            {}
 
            if (!rp_result || (r0 > r1))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR120 - Invalid range, Constraint: r0 <= r1",
                  exprtk_error_location));
 
               return false;
            }
         }
 
         return true;
      }

Referenced by exprtk::parser< Type >::parse_const_string(), exprtk::parser< Type >::parse_string(), and exprtk::parser< Type >::parse_string_range_statement().

Here is the caller graph for this function:

◆ parse_repeat_until_loop()

template<typename T>

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

inlineprivate

Definition at line 26984 of file exprtk.hpp.

      {
         // Parse: [repeat][{][expression][}][until][(][test expr][)]
         expression_node_ptr condition = error_node();
         expression_node_ptr branch    = error_node();
         next_token();
 
         std::vector<expression_node_ptr> arg_list;
         std::vector<bool> side_effect_list;
 
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         brkcnt_list_.push_front(false);
 
         if (details::imatch(current_token().value,"until"))
         {
            next_token();
            branch = node_allocator_.allocate<details::null_node<T> >();
         }
         else
         {
            const token_t::token_type separator = token_t::e_eof;
 
            scope_handler sh(*this);
 
            scoped_bool_or_restorer sbr(state_.side_effect_present);
 
            scoped_inc_dec sid(state_.parsing_loop_stmt_count);
 
            for ( ; ; )
            {
               state_.side_effect_present = false;
 
               expression_node_ptr arg = parse_expression();
 
               if (0 == arg)
                  return error_node();
               else
               {
                  arg_list.push_back(arg);
                  side_effect_list.push_back(state_.side_effect_present);
               }
 
               if (details::imatch(current_token().value,"until"))
               {
                  next_token();
                  break;
               }
 
               const bool is_next_until = peek_token_is(token_t::e_symbol) &&
                                          peek_token_is("until");
 
               if (!token_is(separator) && is_next_until)
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR070 - Expected '" + token_t::to_str(separator) + "' in body of repeat until loop",
                     exprtk_error_location));
 
                  return error_node();
               }
 
               if (details::imatch(current_token().value,"until"))
               {
                  next_token();
                  break;
               }
            }
 
            branch = simplify(arg_list,side_effect_list);
 
            svd.delete_ptr = (0 == branch);
 
            if (svd.delete_ptr)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR071 - Failed to parse body of repeat until loop",
                  exprtk_error_location));
 
               return error_node();
            }
         }
 
         if (!token_is(token_t::e_lbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR072 - Expected '(' before condition statement of repeat until loop",
               exprtk_error_location));
 
            free_node(node_allocator_, branch);
            return error_node();
         }
         else if (0 == (condition = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR073 - Failed to parse condition for repeat until loop",
               exprtk_error_location));
 
            free_node(node_allocator_, branch);
            return error_node();
         }
         else if (!token_is(token_t::e_rbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR074 - Expected ')' after condition of repeat until loop",
               exprtk_error_location));
 
            free_node(node_allocator_, branch   );
            free_node(node_allocator_, condition);
 
            return error_node();
         }
 
         expression_node_ptr result_node =
            expression_generator_
               .repeat_until_loop(
                  condition,
                  branch,
                  brkcnt_list_.front());
 
         if (0 == result_node)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR075 - Failed to synthesize repeat until loop",
               exprtk_error_location));
 
            free_node(node_allocator_, condition);
 
            return error_node();
         }
 
         handle_brkcnt_scope_exit();
 
         if (result_node && result_node->valid())
         {
            return result_node;
         }
 
         set_error(make_error(
            parser_error::e_synthesis,
            current_token(),
            "ERR076 - Failed to synthesize 'valid' repeat until loop",
            exprtk_error_location));
 
         free_node(node_allocator_, result_node);
 
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_return_statement()

template<typename T>

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

inlineprivate

Definition at line 30765 of file exprtk.hpp.

      {
         if (state_.parsing_return_stmt)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR214 - Return call within a return call is not allowed",
               exprtk_error_location));
 
            return error_node();
         }
 
         scoped_bool_negator sbn(state_.parsing_return_stmt);
 
         std::vector<expression_node_ptr> arg_list;
 
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         if (!details::imatch(current_token().value,"return"))
         {
            return error_node();
         }
         else
            next_token();
 
         if (!token_is(token_t::e_lsqrbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR215 - Expected '[' at start of return statement",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!token_is(token_t::e_rsqrbracket))
         {
            for ( ; ; )
            {
               expression_node_ptr arg = parse_expression();
 
               if (0 == arg)
                  return error_node();
 
               arg_list.push_back(arg);
 
               if (token_is(token_t::e_rsqrbracket))
                  break;
               else if (!token_is(token_t::e_comma))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR216 - Expected ',' between values during call to return",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
         }
         else if (settings_.zero_return_disabled())
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR217 - Zero parameter return statement not allowed",
               exprtk_error_location));
 
            return error_node();
         }
 
         const lexer::token prev_token = current_token();
 
         if (token_is(token_t::e_rsqrbracket))
         {
            if (!arg_list.empty())
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  prev_token,
                  "ERR218 - Invalid ']' found during return call",
                  exprtk_error_location));
 
               return error_node();
            }
         }
 
         std::string ret_param_type_list;
 
         for (std::size_t i = 0; i < arg_list.size(); ++i)
         {
            if (0 == arg_list[i])
               return error_node();
            else if (is_ivector_node(arg_list[i]))
               ret_param_type_list += 'V';
            else if (is_generally_string_node(arg_list[i]))
               ret_param_type_list += 'S';
            else
               ret_param_type_list += 'T';
         }
 
         dec_.retparam_list_.push_back(ret_param_type_list);
 
         expression_node_ptr result = expression_generator_.return_call(arg_list);
 
         svd.delete_ptr = (0 == result);
 
         state_.return_stmt_present = true;
 
         state_.activate_side_effect("parse_return_statement()");
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_special_function()

template<typename T>

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

inlineprivate

Definition at line 29314 of file exprtk.hpp.

      {
         const std::string sf_name = current_token().value;
 
         // Expect: $fDD(expr0,expr1,expr2) or $fDD(expr0,expr1,expr2,expr3)
         if (
              !details::is_digit(sf_name[2]) ||
              !details::is_digit(sf_name[3])
            )
         {
            set_error(make_error(
               parser_error::e_token,
               current_token(),
               "ERR149 - Invalid special function[1]: " + sf_name,
               exprtk_error_location));
 
            return error_node();
         }
 
         const int id = (sf_name[2] - '0') * 10 +
                        (sf_name[3] - '0');
 
         if (id >= details::e_sffinal)
         {
            set_error(make_error(
               parser_error::e_token,
               current_token(),
               "ERR150 - Invalid special function[2]: " + sf_name,
               exprtk_error_location));
 
            return error_node();
         }
 
         const int sf_3_to_4                   = details::e_sf48;
         const details::operator_type opt_type = details::operator_type(id + 1000);
         const std::size_t NumberOfParameters  = (id < (sf_3_to_4 - 1000)) ? 3U : 4U;
 
         switch (NumberOfParameters)
         {
            case 3  : return parse_special_function_impl<T,3>::process((*this), opt_type, sf_name);
            case 4  : return parse_special_function_impl<T,4>::process((*this), opt_type, sf_name);
            default : return error_node();
         }
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_string()

template<typename T>

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

inlineprivate

Definition at line 28271 of file exprtk.hpp.

      {
         const std::string symbol = current_token().value;
 
         typedef details::stringvar_node<T>* strvar_node_t;
 
         expression_node_ptr result   = error_node();
         strvar_node_t const_str_node = static_cast<strvar_node_t>(0);
 
         scope_element& se = sem_.get_active_element(symbol);
 
         if (scope_element::e_string == se.type)
         {
            se.active = true;
            result    = se.str_node;
            lodge_symbol(symbol, e_st_local_string);
         }
         else
         {
            typedef typename symtab_store::string_context str_ctxt_t;
            str_ctxt_t str_ctx = symtab_store_.get_string_context(symbol);
 
            if ((0 == str_ctx.str_var) || !symtab_store_.is_conststr_stringvar(symbol))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR121 - Unknown string symbol",
                  exprtk_error_location));
 
               return error_node();
            }
 
            assert(str_ctx.str_var != 0);
            assert(str_ctx.symbol_table != 0);
 
            result = str_ctx.str_var;
 
            if (symtab_store_.is_constant_string(symbol))
            {
               const_str_node = static_cast<strvar_node_t>(result);
               result = expression_generator_(const_str_node->str());
            }
            else if (symbol_table_t::e_immutable == str_ctx.symbol_table->mutability())
            {
               lodge_immutable_symbol(
                  current_token(),
                  make_memory_range(str_ctx.str_var->base(), str_ctx.str_var->size()));
            }
 
            lodge_symbol(symbol, e_st_string);
         }
 
         if (peek_token_is(token_t::e_lsqrbracket))
         {
            next_token();
 
            if (peek_token_is(token_t::e_rsqrbracket))
            {
               next_token();
               next_token();
 
               if (const_str_node)
               {
                  free_node(node_allocator_, result);
 
                  return expression_generator_(T(const_str_node->size()));
               }
               else
                  return node_allocator_.allocate<details::stringvar_size_node<T> >
                            (static_cast<details::stringvar_node<T>*>(result)->ref());
            }
 
            range_t rp;
 
            if (!parse_range(rp))
            {
               free_node(node_allocator_, result);
 
               return error_node();
            }
            else if (const_str_node)
            {
               free_node(node_allocator_, result);
               result = expression_generator_(const_str_node->ref(),rp);
            }
            else
               result = expression_generator_(static_cast<details::stringvar_node<T>*>
                           (result)->ref(), rp);
 
            if (result)
               rp.clear();
         }
         else
            next_token();
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_symtab_symbol().

Here is the caller graph for this function:

◆ 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

Definition at line 29125 of file exprtk.hpp.

      {
         // Move pass the function name
         next_token();
 
         std::string param_type_list;
 
         type_checker tc((*this), function_name, function->parameter_sequence, type_checker::e_string);
 
         if (
              (!function->parameter_sequence.empty()) &&
              (0 == tc.paramseq_count())
            )
         {
            return error_node();
         }
 
         std::vector<expression_node_ptr> arg_list;
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         if (!parse_igeneric_function_params(param_type_list, arg_list, function_name, function, tc))
         {
            return error_node();
         }
 
         std::size_t param_seq_index = 0;
 
         if (!tc.verify(param_type_list, param_seq_index))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR143 - Invalid input parameter sequence for call to string function: " + function_name,
               exprtk_error_location));
 
            return error_node();
         }
 
         expression_node_ptr result =
            (tc.paramseq_count() <= 1) ?
               expression_generator_
                  .string_function_call(function, arg_list) :
               expression_generator_
                  .string_function_call(function, arg_list, param_seq_index);
 
         svd.delete_ptr = (0 == result);
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_symtab_symbol().

Here is the caller graph for this function:

◆ parse_string_range_statement()

template<typename T>

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

inlineprivate

Definition at line 27772 of file exprtk.hpp.

      {
         if (!token_is(token_t::e_lsqrbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR108 - Expected '[' as start of string range definition",
               exprtk_error_location));
 
            free_node(node_allocator_, expression);
 
            return error_node();
         }
         else if (token_is(token_t::e_rsqrbracket))
         {
            return node_allocator_.allocate<details::string_size_node<T> >(expression);
         }
 
         range_t rp;
 
         if (!parse_range(rp,true))
         {
            free_node(node_allocator_, expression);
 
            return error_node();
         }
 
         expression_node_ptr result = expression_generator_(expression,rp);
 
         if (0 == result)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR109 - Failed to generate string range node",
               exprtk_error_location));
 
            free_node(node_allocator_, expression);
            rp.free();
         }
 
         rp.clear();
 
         if (result && result->valid())
         {
            return result;
         }
 
         set_error(make_error(
            parser_error::e_synthesis,
            current_token(),
            "ERR110 - Failed to synthesize node: string_range_node",
            exprtk_error_location));
 
         free_node(node_allocator_, result);
         rp.free();
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_pending_string_rangesize().

Here is the caller graph for this function:

◆ parse_swap_statement()

template<typename T>

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

inlineprivate

Definition at line 30531 of file exprtk.hpp.

      {
         if (!details::imatch(current_token().value,"swap"))
         {
            return error_node();
         }
         else
            next_token();
 
         if (!token_is(token_t::e_lbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR205 - Expected '(' at start of swap statement",
               exprtk_error_location));
 
            return error_node();
         }
 
         expression_node_ptr variable0 = error_node();
         expression_node_ptr variable1 = error_node();
 
         bool variable0_generated = false;
         bool variable1_generated = false;
 
         const std::string var0_name = current_token().value;
 
         if (!token_is(token_t::e_symbol,prsrhlpr_t::e_hold))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR206 - Expected a symbol for variable or vector element definition",
               exprtk_error_location));
 
            return error_node();
         }
         else if (peek_token_is(token_t::e_lsqrbracket))
         {
            if (0 == (variable0 = parse_vector()))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR207 - First parameter to swap is an invalid vector element: '" + var0_name + "'",
                  exprtk_error_location));
 
               return error_node();
            }
 
            variable0_generated = true;
         }
         else
         {
            if (symtab_store_.is_variable(var0_name))
            {
               variable0 = symtab_store_.get_variable(var0_name);
            }
 
            const scope_element& se = sem_.get_element(var0_name);
 
            if (
                 (se.active)            &&
                 (se.name == var0_name) &&
                 (scope_element::e_variable == se.type)
               )
            {
               variable0 = se.var_node;
            }
 
            lodge_symbol(var0_name, e_st_variable);
 
            if (0 == variable0)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR208 - First parameter to swap is an invalid variable: '" + var0_name + "'",
                  exprtk_error_location));
 
               return error_node();
            }
            else
               next_token();
         }
 
         if (!token_is(token_t::e_comma))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR209 - Expected ',' between parameters to swap",
               exprtk_error_location));
 
            if (variable0_generated)
            {
               free_node(node_allocator_, variable0);
            }
 
            return error_node();
         }
 
         const std::string var1_name = current_token().value;
 
         if (!token_is(token_t::e_symbol,prsrhlpr_t::e_hold))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR210 - Expected a symbol for variable or vector element definition",
               exprtk_error_location));
 
            if (variable0_generated)
            {
               free_node(node_allocator_, variable0);
            }
 
            return error_node();
         }
         else if (peek_token_is(token_t::e_lsqrbracket))
         {
            if (0 == (variable1 = parse_vector()))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR211 - Second parameter to swap is an invalid vector element: '" + var1_name + "'",
                  exprtk_error_location));
 
               if (variable0_generated)
               {
                  free_node(node_allocator_, variable0);
               }
 
               return error_node();
            }
 
            variable1_generated = true;
         }
         else
         {
            if (symtab_store_.is_variable(var1_name))
            {
               variable1 = symtab_store_.get_variable(var1_name);
            }
 
            const scope_element& se = sem_.get_element(var1_name);
 
            if (
                 (se.active) &&
                 (se.name == var1_name) &&
                 (scope_element::e_variable == se.type)
               )
            {
               variable1 = se.var_node;
            }
 
            lodge_symbol(var1_name, e_st_variable);
 
            if (0 == variable1)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR212 - Second parameter to swap is an invalid variable: '" + var1_name + "'",
                  exprtk_error_location));
 
               if (variable0_generated)
               {
                  free_node(node_allocator_, variable0);
               }
 
               return error_node();
            }
            else
               next_token();
         }
 
         if (!token_is(token_t::e_rbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR213 - Expected ')' at end of swap statement",
               exprtk_error_location));
 
            if (variable0_generated)
            {
               free_node(node_allocator_, variable0);
            }
 
            if (variable1_generated)
            {
               free_node(node_allocator_, variable1);
            }
 
            return error_node();
         }
 
         typedef details::variable_node<T>* variable_node_ptr;
 
         variable_node_ptr v0 = variable_node_ptr(0);
         variable_node_ptr v1 = variable_node_ptr(0);
 
         expression_node_ptr result = error_node();
 
         if (
              (0 != (v0 = dynamic_cast<variable_node_ptr>(variable0))) &&
              (0 != (v1 = dynamic_cast<variable_node_ptr>(variable1)))
            )
         {
            result = node_allocator_.allocate<details::swap_node<T> >(v0, v1);
 
            if (variable0_generated)
            {
               free_node(node_allocator_, variable0);
            }
 
            if (variable1_generated)
            {
               free_node(node_allocator_, variable1);
            }
         }
         else
            result = node_allocator_.allocate<details::swap_generic_node<T> >
                        (variable0, variable1);
 
         state_.activate_side_effect("parse_swap_statement()");
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_switch_statement()

template<typename T>

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

inlineprivate

Definition at line 27383 of file exprtk.hpp.

      {
         std::vector<expression_node_ptr> arg_list;
 
         if (!details::imatch(current_token().value,"switch"))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR090 - Expected keyword 'switch'",
               exprtk_error_location));
 
            return error_node();
         }
 
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         next_token();
 
         if (!token_is(token_t::e_lcrlbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR091 - Expected '{' for call to switch statement",
               exprtk_error_location));
 
            return error_node();
         }
 
         expression_node_ptr default_statement = error_node();
 
         scoped_expression_delete defstmt_delete((*this), default_statement);
 
         for ( ; ; )
         {
            if (details::imatch("case",current_token().value))
            {
               next_token();
 
               expression_node_ptr condition = parse_expression();
 
               if (0 == condition)
                  return error_node();
               else if (!token_is(token_t::e_colon))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR092 - Expected ':' for case of switch statement",
                     exprtk_error_location));
 
                  free_node(node_allocator_, condition);
 
                  return error_node();
               }
 
               expression_node_ptr consequent =
                  (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold)) ?
                  parse_multi_sequence("switch-consequent") :
                  parse_expression();
 
               if (0 == consequent)
               {
                  free_node(node_allocator_, condition);
 
                  return error_node();
               }
               else if (!token_is(token_t::e_eof))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR093 - Expected ';' at end of case for switch statement",
                     exprtk_error_location));
 
                  free_node(node_allocator_, condition );
                  free_node(node_allocator_, consequent);
 
                  return error_node();
               }
 
               // Can we optimise away the case statement?
               if (is_constant_node(condition) && is_false(condition))
               {
                  free_node(node_allocator_, condition );
                  free_node(node_allocator_, consequent);
               }
               else
               {
                  arg_list.push_back(condition );
                  arg_list.push_back(consequent);
               }
 
            }
            else if (details::imatch("default",current_token().value))
            {
               if (0 != default_statement)
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR094 - Multiple default cases for switch statement",
                     exprtk_error_location));
 
                  return error_node();
               }
 
               next_token();
 
               if (!token_is(token_t::e_colon))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR095 - Expected ':' for default of switch statement",
                     exprtk_error_location));
 
                  return error_node();
               }
 
               default_statement =
                  (token_is(token_t::e_lcrlbracket,prsrhlpr_t::e_hold)) ?
                  parse_multi_sequence("switch-default"):
                  parse_expression();
 
               if (0 == default_statement)
                  return error_node();
               else if (!token_is(token_t::e_eof))
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR096 - Expected ';' at end of default for switch statement",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
            else if (token_is(token_t::e_rcrlbracket))
               break;
            else
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR097 - Expected '}' at end of switch statement",
                  exprtk_error_location));
 
               return error_node();
            }
         }
 
         const bool default_statement_present = (0 != default_statement);
 
         if (default_statement_present)
         {
            arg_list.push_back(default_statement);
         }
         else
         {
            arg_list.push_back(node_allocator_.allocate_c<literal_node_t>(std::numeric_limits<T>::quiet_NaN()));
         }
 
         expression_node_ptr result = expression_generator_.switch_statement(arg_list, (0 != default_statement));
 
         svd.delete_ptr = (0 == result);
         defstmt_delete.delete_ptr = (0 == result);
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ parse_symbol()

template<typename T>

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

inlineprivate

Definition at line 31543 of file exprtk.hpp.

      {
         static const std::string symbol_if       = "if"      ;
         static const std::string symbol_while    = "while"   ;
         static const std::string symbol_repeat   = "repeat"  ;
         static const std::string symbol_for      = "for"     ;
         static const std::string symbol_switch   = "switch"  ;
         static const std::string symbol_null     = "null"    ;
         static const std::string symbol_break    = "break"   ;
         static const std::string symbol_continue = "continue";
         static const std::string symbol_var      = "var"     ;
         static const std::string symbol_const    = "const"   ;
         static const std::string symbol_swap     = "swap"    ;
         static const std::string symbol_return   = "return"  ;
         static const std::string symbol_not      = "not"     ;
         static const std::string symbol_assert   = "assert"  ;
 
         const std::string symbol = current_token().value;
 
         if (valid_vararg_operation(symbol))
         {
            return parse_vararg_function();
         }
         else if (details::imatch(symbol, symbol_not))
         {
            return parse_not_statement();
         }
         else if (valid_base_operation(symbol))
         {
            return parse_base_operation();
         }
         else if (
                   details::imatch(symbol, symbol_if) &&
                   settings_.control_struct_enabled(symbol)
                 )
         {
            return parse_conditional_statement();
         }
         else if (
                   details::imatch(symbol, symbol_while) &&
                   settings_.control_struct_enabled(symbol)
                 )
         {
            return check_block_statement_closure(parse_while_loop());
         }
         else if (
                   details::imatch(symbol, symbol_repeat) &&
                   settings_.control_struct_enabled(symbol)
                 )
         {
            return check_block_statement_closure(parse_repeat_until_loop());
         }
         else if (
                   details::imatch(symbol, symbol_for) &&
                   settings_.control_struct_enabled(symbol)
                 )
         {
            return check_block_statement_closure(parse_for_loop());
         }
         else if (
                   details::imatch(symbol, symbol_switch) &&
                   settings_.control_struct_enabled(symbol)
                 )
         {
            return check_block_statement_closure(parse_switch_statement());
         }
         else if (details::is_valid_sf_symbol(symbol))
         {
            return parse_special_function();
         }
         else if (details::imatch(symbol, symbol_null))
         {
            return parse_null_statement();
         }
         #ifndef exprtk_disable_break_continue
         else if (details::imatch(symbol, symbol_break))
         {
            return parse_break_statement();
         }
         else if (details::imatch(symbol, symbol_continue))
         {
            return parse_continue_statement();
         }
         #endif
         else if (details::imatch(symbol, symbol_var))
         {
            return parse_define_var_statement();
         }
         else if (details::imatch(symbol, symbol_const))
         {
            return parse_define_constvar_statement();
         }
         else if (details::imatch(symbol, symbol_swap))
         {
            return parse_swap_statement();
         }
         #ifndef exprtk_disable_return_statement
         else if (
                   details::imatch(symbol, symbol_return) &&
                   settings_.control_struct_enabled(symbol)
                 )
         {
            return check_block_statement_closure(parse_return_statement());
         }
         #endif
         else if (details::imatch(symbol, symbol_assert))
         {
            return parse_assert_statement();
         }
         else if (symtab_store_.valid() || !sem_.empty())
         {
            return parse_symtab_symbol();
         }
         else
         {
            set_error(make_error(
               parser_error::e_symtab,
               current_token(),
               "ERR241 - Unknown variable or function encountered. Symbol table(s) "
               "is either invalid or does not contain symbol: '" + symbol + "'",
               exprtk_error_location));
 
            return error_node();
         }
      }

Referenced by exprtk::parser< Type >::parse_branch().

Here is the caller graph for this function:

◆ parse_symtab_symbol()

template<typename T>

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

inlineprivate

Definition at line 31181 of file exprtk.hpp.

      {
         const std::string symbol = current_token().value;
 
         // Are we dealing with a variable or a special constant?
         typedef typename symtab_store::variable_context var_ctxt_t;
         var_ctxt_t var_ctx = symtab_store_.get_variable_context(symbol);
 
         if (var_ctx.variable)
         {
            assert(var_ctx.symbol_table);
 
            expression_node_ptr result_variable = var_ctx.variable;
 
            if (symtab_store_.is_constant_node(symbol))
            {
               result_variable = expression_generator_(var_ctx.variable->value());
            }
            else if (symbol_table_t::e_immutable == var_ctx.symbol_table->mutability())
            {
               lodge_immutable_symbol(current_token(), make_memory_range(var_ctx.variable->ref()));
               result_variable = var_ctx.variable;
            }
 
            if (!post_variable_process(symbol))
            {
               free_node(node_allocator_, result_variable);
 
               return error_node();
            }
 
            lodge_symbol(symbol, e_st_variable);
 
            next_token();
 
            return result_variable;
         }
 
         // Are we dealing with a locally defined variable, vector or string?
         if (!sem_.empty())
         {
            scope_element& se = sem_.get_active_element(symbol);
 
            if (se.active && details::imatch(se.name, symbol))
            {
               if (
                    (scope_element::e_variable == se.type) ||
                    (scope_element::e_literal  == se.type)
                  )
               {
                  se.active = true;
                  lodge_symbol(symbol, e_st_local_variable);
 
                  if (!post_variable_process(symbol))
                     return error_node();
 
                  next_token();
 
                  return (scope_element::e_variable == se.type) ?
                           se.var_node :
                           expression_generator_(se.var_node->value());
               }
               else if (scope_element::e_vector == se.type)
               {
                  return parse_vector();
               }
               #ifndef exprtk_disable_string_capabilities
               else if (scope_element::e_string == se.type)
               {
                  return parse_string();
               }
               #endif
            }
         }
 
         #ifndef exprtk_disable_string_capabilities
         // Are we dealing with a string variable?
         if (symtab_store_.is_stringvar(symbol))
         {
            return parse_string();
         }
         #endif
 
         {
            // Are we dealing with a function?
            ifunction<T>* function = symtab_store_.get_function(symbol);
 
            if (function)
            {
               lodge_symbol(symbol, e_st_function);
 
               expression_node_ptr func_node =
                                      parse_function_invocation(function,symbol);
 
               if (func_node)
                  return func_node;
               else
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR231 - Failed to generate node for function: '" + symbol + "'",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
         }
 
         {
            // Are we dealing with a vararg function?
            ivararg_function<T>* vararg_function = symtab_store_.get_vararg_function(symbol);
 
            if (vararg_function)
            {
               lodge_symbol(symbol, e_st_function);
 
               expression_node_ptr vararg_func_node =
                                      parse_vararg_function_call(vararg_function, symbol);
 
               if (vararg_func_node)
                  return vararg_func_node;
               else
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR232 - Failed to generate node for vararg function: '" + symbol + "'",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
         }
 
         {
            // Are we dealing with a vararg generic function?
            igeneric_function<T>* generic_function = symtab_store_.get_generic_function(symbol);
 
            if (generic_function)
            {
               lodge_symbol(symbol, e_st_function);
 
               expression_node_ptr genericfunc_node =
                                      parse_generic_function_call(generic_function, symbol);
 
               if (genericfunc_node)
                  return genericfunc_node;
               else
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR233 - Failed to generate node for generic function: '" + symbol + "'",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
         }
 
         #ifndef exprtk_disable_string_capabilities
         {
            // Are we dealing with a vararg string returning function?
            igeneric_function<T>* string_function = symtab_store_.get_string_function(symbol);
 
            if (string_function)
            {
               lodge_symbol(symbol, e_st_function);
 
               expression_node_ptr stringfunc_node =
                                      parse_string_function_call(string_function, symbol);
 
               if (stringfunc_node)
                  return stringfunc_node;
               else
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR234 - Failed to generate node for string function: '" + symbol + "'",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
         }
 
         {
            // Are we dealing with a vararg overloaded scalar/string returning function?
            igeneric_function<T>* overload_function = symtab_store_.get_overload_function(symbol);
 
            if (overload_function)
            {
               lodge_symbol(symbol, e_st_function);
 
               expression_node_ptr overloadfunc_node =
                                      parse_overload_function_call(overload_function, symbol);
 
               if (overloadfunc_node)
                  return overloadfunc_node;
               else
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR235 - Failed to generate node for overload function: '" + symbol + "'",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
         }
         #endif
 
         // Are we dealing with a vector?
         if (symtab_store_.is_vector(symbol))
         {
            lodge_symbol(symbol, e_st_vector);
            return parse_vector();
         }
 
         if (details::is_reserved_symbol(symbol))
         {
               if (
                    settings_.function_enabled(symbol) ||
                    !details::is_base_function(symbol)
                  )
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR236 - Invalid use of reserved symbol '" + symbol + "'",
                     exprtk_error_location));
 
                  return error_node();
               }
         }
 
         // Should we handle unknown symbols?
         if (resolve_unknown_symbol_ && unknown_symbol_resolver_)
         {
            if (!(settings_.rsrvd_sym_usr_disabled() && details::is_reserved_symbol(symbol)))
            {
               symbol_table_t& symtab = symtab_store_.get_symbol_table();
 
               std::string error_message;
 
               if (unknown_symbol_resolver::e_usrmode_default == unknown_symbol_resolver_->mode)
               {
                  T default_value = T(0);
 
                  typename unknown_symbol_resolver::usr_symbol_type usr_symbol_type = unknown_symbol_resolver::e_usr_unknown_type;
 
                  if (unknown_symbol_resolver_->process(symbol, usr_symbol_type, default_value, error_message))
                  {
                     bool create_result = false;
 
                     switch (usr_symbol_type)
                     {
                        case unknown_symbol_resolver::e_usr_variable_type :
                           create_result = symtab.create_variable(symbol, default_value);
                           break;
 
                        case unknown_symbol_resolver::e_usr_constant_type :
                           create_result = symtab.add_constant(symbol, default_value);
                           break;
 
                        default                                           : create_result = false;
                     }
 
                     if (create_result)
                     {
                        expression_node_ptr var = symtab_store_.get_variable(symbol);
 
                        if (var)
                        {
                           if (symtab_store_.is_constant_node(symbol))
                           {
                              var = expression_generator_(var->value());
                           }
 
                           lodge_symbol(symbol, e_st_variable);
 
                           if (!post_variable_process(symbol))
                           {
                              free_node(node_allocator_, var);
                              return error_node();
                           }
 
                           next_token();
 
                           return var;
                        }
                     }
                  }
 
                  set_error(make_error(
                     parser_error::e_symtab,
                     current_token(),
                     "ERR237 - Failed to create variable: '" + symbol + "'" +
                     (error_message.empty() ? "" : " - " + error_message),
                     exprtk_error_location));
 
               }
               else if (unknown_symbol_resolver::e_usrmode_extended == unknown_symbol_resolver_->mode)
               {
                  if (unknown_symbol_resolver_->process(symbol, symtab, error_message))
                  {
                     expression_node_ptr result = parse_symtab_symbol();
 
                     if (result)
                     {
                        return result;
                     }
                  }
 
                  set_error(make_error(
                     parser_error::e_symtab,
                     current_token(),
                     "ERR238 - Failed to resolve symbol: '" + symbol + "'" +
                     (error_message.empty() ? "" : " - " + error_message),
                     exprtk_error_location));
               }
 
               return error_node();
            }
         }
 
         set_error(make_error(
            parser_error::e_syntax,
            current_token(),
            "ERR239 - Undefined symbol: '" + symbol + "'",
            exprtk_error_location));
 
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_symbol(), and exprtk::parser< Type >::parse_symtab_symbol().

Here is the caller graph for this function:

◆ parse_ternary_conditional_statement()

template<typename T>

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

inlineprivate

Definition at line 26745 of file exprtk.hpp.

      {
         // Parse: [condition][?][consequent][:][alternative]
         expression_node_ptr consequent  = error_node();
         expression_node_ptr alternative = error_node();
 
         bool result = true;
 
         if (0 == condition)
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR056 - Encountered invalid condition branch for ternary if-statement",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!token_is(token_t::e_ternary))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR057 - Expected '?' after condition of ternary if-statement",
               exprtk_error_location));
 
            result = false;
         }
         else if (0 == (consequent = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR058 - Failed to parse consequent for ternary if-statement",
               exprtk_error_location));
 
            result = false;
         }
         else if (!token_is(token_t::e_colon))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR059 - Expected ':' between ternary if-statement consequent and alternative",
               exprtk_error_location));
 
            result = false;
         }
         else if (0 == (alternative = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR060 - Failed to parse alternative for ternary if-statement",
               exprtk_error_location));
 
            result = false;
         }
 
         #ifndef exprtk_disable_string_capabilities
         if (result)
         {
            const bool consq_is_str = is_generally_string_node(consequent );
            const bool alter_is_str = is_generally_string_node(alternative);
 
            if (consq_is_str || alter_is_str)
            {
               if (consq_is_str && alter_is_str)
               {
                  return expression_generator_
                           .conditional_string(condition, consequent, alternative);
               }
 
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR061 - Return types of ternary differ: string/non-string",
                  exprtk_error_location));
 
               result = false;
            }
         }
         #endif
 
         if (result)
         {
            const bool consq_is_vec = is_ivector_node(consequent );
            const bool alter_is_vec = is_ivector_node(alternative);
 
            if (consq_is_vec || alter_is_vec)
            {
               if (consq_is_vec && alter_is_vec)
               {
                  return expression_generator_
                           .conditional_vector(condition, consequent, alternative);
               }
 
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR062 - Return types of ternary differ: vector/non-vector",
                  exprtk_error_location));
 
               result = false;
            }
         }
 
         if (!result)
         {
            free_node(node_allocator_, condition  );
            free_node(node_allocator_, consequent );
            free_node(node_allocator_, alternative);
 
            return error_node();
         }
         else
            return expression_generator_
                      .conditional(condition, consequent, alternative);
      }

Referenced by exprtk::parser< Type >::parse_branch(), and exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ parse_uninitialised_var_statement()

template<typename T>

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

inlineprivate

Definition at line 30428 of file exprtk.hpp.

      {
         if (
              !token_is(token_t::e_lcrlbracket) ||
              !token_is(token_t::e_rcrlbracket)
            )
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR200 - Expected a '{}' for uninitialised var definition",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!token_is(token_t::e_eof,prsrhlpr_t::e_hold))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR201 - Expected ';' after uninitialised variable definition",
               exprtk_error_location));
 
            return error_node();
         }
 
         expression_node_ptr var_node = reinterpret_cast<expression_node_ptr>(0);
 
         scope_element& se = sem_.get_element(var_name);
 
         if (se.name == var_name)
         {
            if (se.active)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR202 - Illegal redefinition of local variable: '" + var_name + "'",
                  exprtk_error_location));
 
               return error_node();
            }
            else if (scope_element::e_variable == se.type)
            {
               var_node  = se.var_node;
               se.active = true;
               se.ref_count++;
            }
         }
 
         if (0 == var_node)
         {
            const std::size_t predicted_total_lclsymb_size = sizeof(T) + sem_.total_local_symb_size_bytes();
 
            if (predicted_total_lclsymb_size > settings().max_total_local_symbol_size_bytes())
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR203 - Adding variable '" + var_name + "' "
                  "will exceed max total local symbol size of: " + details::to_str(settings().max_total_local_symbol_size_bytes()) + " bytes, "
                  "current total size: " + details::to_str(sem_.total_local_symb_size_bytes()) + " bytes",
                  exprtk_error_location));
 
               return error_node();
            }
 
            scope_element nse;
            nse.name      = var_name;
            nse.active    = true;
            nse.ref_count = 1;
            nse.type      = scope_element::e_variable;
            nse.depth     = state_.scope_depth;
            nse.ip_index  = sem_.next_ip_index();
            nse.data      = new T(T(0));
            nse.var_node  = node_allocator_.allocate<variable_node_t>(*reinterpret_cast<T*>(nse.data));
 
            if (!sem_.add_element(nse))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR204 - Failed to add new local variable '" + var_name + "' to SEM",
                  exprtk_error_location));
 
               sem_.free_element(nse);
 
               return error_node();
            }
 
            assert(sem_.total_local_symb_size_bytes() <= settings().max_total_local_symbol_size_bytes());
 
            exprtk_debug(("parse_uninitialised_var_statement() - INFO - Added new local variable: %s\n",
                          nse.name.c_str()));
         }
 
         lodge_symbol(var_name, e_st_local_variable);
 
         state_.activate_side_effect("parse_uninitialised_var_statement()");
 
         return expression_generator_(T(0));
      }

Referenced by exprtk::parser< Type >::parse_define_var_statement().

Here is the caller graph for this function:

◆ parse_vararg_function()

template<typename T>

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

inlineprivate

Definition at line 27679 of file exprtk.hpp.

      {
         std::vector<expression_node_ptr> arg_list;
 
         details::operator_type opt_type = details::e_default;
         const std::string symbol = current_token().value;
 
         if (details::imatch(symbol,"~"))
         {
            next_token();
            return check_block_statement_closure(parse_multi_sequence());
         }
         else if (details::imatch(symbol,"[*]"))
         {
            return check_block_statement_closure(parse_multi_switch_statement());
         }
         else if (details::imatch(symbol, "avg" )) opt_type = details::e_avg ;
         else if (details::imatch(symbol, "mand")) opt_type = details::e_mand;
         else if (details::imatch(symbol, "max" )) opt_type = details::e_max ;
         else if (details::imatch(symbol, "min" )) opt_type = details::e_min ;
         else if (details::imatch(symbol, "mor" )) opt_type = details::e_mor ;
         else if (details::imatch(symbol, "mul" )) opt_type = details::e_prod;
         else if (details::imatch(symbol, "sum" )) opt_type = details::e_sum ;
         else
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR104 - Unsupported built-in vararg function: " + symbol,
               exprtk_error_location));
 
            return error_node();
         }
 
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         lodge_symbol(symbol, e_st_function);
 
         next_token();
 
         if (!token_is(token_t::e_lbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR105 - Expected '(' for call to vararg function: " + symbol,
               exprtk_error_location));
 
            return error_node();
         }
 
         if (token_is(token_t::e_rbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR106 - vararg function: " + symbol +
               " requires at least one input parameter",
               exprtk_error_location));
 
            return error_node();
         }
 
         for ( ; ; )
         {
            expression_node_ptr arg = parse_expression();
 
            if (0 == arg)
               return error_node();
            else
               arg_list.push_back(arg);
 
            if (token_is(token_t::e_rbracket))
               break;
            else if (!token_is(token_t::e_comma))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR107 - Expected ',' for call to vararg function: " + symbol,
                  exprtk_error_location));
 
               return error_node();
            }
         }
 
         const expression_node_ptr result = expression_generator_.vararg_function(opt_type,arg_list);
 
         svd.delete_ptr = (0 == result);
         return result;
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ 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

Definition at line 28581 of file exprtk.hpp.

      {
         std::vector<expression_node_ptr> arg_list;
 
         scoped_vec_delete<expression_node_t> svd((*this), arg_list);
 
         next_token();
 
         if (token_is(token_t::e_lbracket))
         {
            if (token_is(token_t::e_rbracket))
            {
               if (!vararg_function->allow_zero_parameters())
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR127 - Zero parameter call to vararg function: "
                     + vararg_function_name + " not allowed",
                     exprtk_error_location));
 
                  return error_node();
               }
            }
            else
            {
               for ( ; ; )
               {
                  expression_node_ptr arg = parse_expression();
 
                  if (0 == arg)
                     return error_node();
                  else
                     arg_list.push_back(arg);
 
                  if (token_is(token_t::e_rbracket))
                     break;
                  else if (!token_is(token_t::e_comma))
                  {
                     set_error(make_error(
                        parser_error::e_syntax,
                        current_token(),
                        "ERR128 - Expected ',' for call to vararg function: "
                        + vararg_function_name,
                        exprtk_error_location));
 
                     return error_node();
                  }
               }
            }
         }
         else if (!vararg_function->allow_zero_parameters())
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR129 - Zero parameter call to vararg function: "
               + vararg_function_name + " not allowed",
               exprtk_error_location));
 
            return error_node();
         }
 
         if (arg_list.size() < vararg_function->min_num_args())
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR130 - Invalid number of parameters to call to vararg function: "
               + vararg_function_name + ", require at least "
               + details::to_str(static_cast<int>(vararg_function->min_num_args())) + " parameters",
               exprtk_error_location));
 
            return error_node();
         }
         else if (arg_list.size() > vararg_function->max_num_args())
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR131 - Invalid number of parameters to call to vararg function: "
               + vararg_function_name + ", require no more than "
               + details::to_str(static_cast<int>(vararg_function->max_num_args())) + " parameters",
               exprtk_error_location));
 
            return error_node();
         }
 
         expression_node_ptr result = expression_generator_.vararg_function_call(vararg_function,arg_list);
 
         svd.delete_ptr = (0 == result);
 
         return result;
      }

Referenced by exprtk::parser< Type >::parse_symtab_symbol().

Here is the caller graph for this function:

◆ parse_vector()

template<typename T>

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

inlineprivate

Definition at line 28479 of file exprtk.hpp.

      {
         const std::string vector_name = current_token().value;
 
         vector_holder_ptr vec = vector_holder_ptr(0);
 
         const scope_element& se = sem_.get_active_element(vector_name);
 
         if (
              !details::imatch(se.name, vector_name) ||
              (se.depth > state_.scope_depth)   ||
              (scope_element::e_vector != se.type)
            )
         {
            typedef typename symtab_store::vector_context vec_ctxt_t;
            vec_ctxt_t vec_ctx = symtab_store_.get_vector_context(vector_name);
 
            if (0 == vec_ctx.vector_holder)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR125 - Symbol '" + vector_name + " not a vector",
                  exprtk_error_location));
 
               return error_node();
            }
 
            assert(0 != vec_ctx.vector_holder);
            assert(0 != vec_ctx.symbol_table );
 
            vec = vec_ctx.vector_holder;
 
            if (symbol_table_t::e_immutable == vec_ctx.symbol_table->mutability())
            {
               lodge_immutable_symbol(
                  current_token(),
                  make_memory_range(vec->data(), vec->size()));
            }
         }
         else
         {
            vec = se.vec_node;
         }
 
         assert(0 != vec);
 
         next_token();
 
         if (!token_is(token_t::e_lsqrbracket))
         {
            return node_allocator_.allocate<vector_node_t>(vec);
         }
         else if (token_is(token_t::e_rsqrbracket))
         {
            return (vec->rebaseable()) ?
               node_allocator_.allocate<vector_size_node_t>(vec) :
               expression_generator_(T(vec->size()));
         }
 
         expression_node_ptr index_expr = parse_vector_index(vector_name);
 
         if (index_expr)
         {
            expression_node_ptr vec_node = node_allocator_.allocate<vector_node_t>(vec);
 
            return synthesize_vector_element(vector_name, vec, vec_node, index_expr);
         }
 
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_swap_statement(), and exprtk::parser< Type >::parse_symtab_symbol().

Here is the caller graph for this function:

◆ parse_vector_index()

template<typename T>

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

inlineprivate

Definition at line 28449 of file exprtk.hpp.

      {
         expression_node_ptr index_expr = error_node();
 
         if (0 == (index_expr = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR123 - Failed to parse index for vector: '" + vector_name + "'",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!token_is(token_t::e_rsqrbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR124 - Expected ']' for index of vector: '" + vector_name + "'",
               exprtk_error_location));
 
            free_node(node_allocator_, index_expr);
 
            return error_node();
         }
 
         return index_expr;
      }

Referenced by exprtk::parser< Type >::parse_pending_vector_index_operator(), and exprtk::parser< Type >::parse_vector().

Here is the caller graph for this function:

◆ parse_while_loop()

template<typename T>

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

inlineprivate

Definition at line 26887 of file exprtk.hpp.

      {
         // Parse: [while][(][test expr][)][{][expression][}]
         expression_node_ptr condition   = error_node();
         expression_node_ptr branch      = error_node();
         expression_node_ptr result_node = error_node();
 
         bool result = true;
 
         next_token();
 
         if (!token_is(token_t::e_lbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR064 - Expected '(' at start of while-loop condition statement",
               exprtk_error_location));
 
            return error_node();
         }
         else if (0 == (condition = parse_expression()))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR065 - Failed to parse condition for while-loop",
               exprtk_error_location));
 
            return error_node();
         }
         else if (!token_is(token_t::e_rbracket))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR066 - Expected ')' at end of while-loop condition statement",
               exprtk_error_location));
 
            result = false;
         }
 
         brkcnt_list_.push_front(false);
 
         if (result)
         {
            scoped_inc_dec sid(state_.parsing_loop_stmt_count);
 
            if (0 == (branch = parse_multi_sequence("while-loop", true)))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR067 - Failed to parse body of while-loop"));
               result = false;
            }
            else if (0 == (result_node = expression_generator_.while_loop(condition,
                                                                          branch,
                                                                          brkcnt_list_.front())))
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR068 - Failed to synthesize while-loop",
                  exprtk_error_location));
 
               result = false;
            }
         }
 
         handle_brkcnt_scope_exit();
 
         if (!result)
         {
            free_node(node_allocator_, branch     );
            free_node(node_allocator_, condition  );
            free_node(node_allocator_, result_node);
 
            return error_node();
         }
 
         if (result_node && result_node->valid())
         {
            return result_node;
         }
 
         set_error(make_error(
            parser_error::e_synthesis,
            current_token(),
            "ERR069 - Failed to synthesize 'valid' while-loop",
            exprtk_error_location));
 
         free_node(node_allocator_, result_node);
 
         return error_node();
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ pop_current_state()

template<typename T>

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

inlineprivate

Definition at line 25444 of file exprtk.hpp.

      {
         if (!current_state_stack_.empty())
         {
            current_state_stack_.pop_back();
         }
      }

Referenced by exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ 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

Definition at line 31099 of file exprtk.hpp.

      {
         bool implied_mul = false;
 
         if (details::is_generally_string_node(branch))
            return true;
 
         if (details::is_ivector_node(branch))
            return true;
 
         const lexer::parser_helper::token_advance_mode hold = prsrhlpr_t::e_hold;
 
         switch (token)
         {
            case token_t::e_lcrlbracket : implied_mul = token_is(token_t::e_lbracket   , hold) ||
                                                        token_is(token_t::e_lcrlbracket, hold) ||
                                                        token_is(token_t::e_lsqrbracket, hold) ;
                                          break;
 
            case token_t::e_lbracket    : implied_mul = token_is(token_t::e_lbracket   , hold) ||
                                                        token_is(token_t::e_lcrlbracket, hold) ||
                                                        token_is(token_t::e_lsqrbracket, hold) ;
                                          break;
 
            case token_t::e_lsqrbracket : implied_mul = token_is(token_t::e_lbracket   , hold) ||
                                                        token_is(token_t::e_lcrlbracket, hold) ||
                                                        token_is(token_t::e_lsqrbracket, hold) ;
                                          break;
 
            default                     : return true;
         }
 
         if (implied_mul)
         {
            if (!settings_.commutative_check_enabled())
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR230 - Invalid sequence of brackets",
                  exprtk_error_location));
 
               return false;
            }
            else if (token_t::e_eof != current_token().type)
            {
               lexer().insert_front(current_token().type);
               lexer().insert_front(token_t::e_mul);
               next_token();
            }
         }
 
         return true;
      }

Referenced by exprtk::parser< Type >::parse_branch().

Here is the caller graph for this function:

◆ post_variable_process()

template<typename T>

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

inlineprivate

Definition at line 31074 of file exprtk.hpp.

      {
         if (
              peek_token_is(token_t::e_lbracket   ) ||
              peek_token_is(token_t::e_lcrlbracket) ||
              peek_token_is(token_t::e_lsqrbracket)
            )
         {
            if (!settings_.commutative_check_enabled())
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR229 - Invalid sequence of variable '" + symbol + "' and bracket",
                  exprtk_error_location));
 
               return false;
            }
 
            lexer().insert_front(token_t::e_mul);
         }
 
         return true;
      }

Referenced by exprtk::parser< Type >::parse_symtab_symbol().

Here is the caller graph for this function:

◆ process_lexer_errors()

template<typename T>

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

inline

Definition at line 24955 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < lexer().size(); ++i)
         {
            if (lexer()[i].is_error())
            {
               std::string diagnostic = "ERR004 - ";
 
               switch (lexer()[i].type)
               {
                  case lexer::token::e_error      : diagnostic += "General token error";
                                                    break;
 
                  case lexer::token::e_err_symbol : diagnostic += "Symbol error";
                                                    break;
 
                  case lexer::token::e_err_number : diagnostic += "Invalid numeric token";
                                                    break;
 
                  case lexer::token::e_err_string : diagnostic += "Invalid string token";
                                                    break;
 
                  case lexer::token::e_err_sfunc  : diagnostic += "Invalid special function token";
                                                    break;
 
                  default                         : diagnostic += "Unknown compiler error";
               }
 
               set_error(make_error(
                  parser_error::e_lexer,
                  lexer()[i],
                  diagnostic + ": " + lexer()[i].value,
                  exprtk_error_location));
            }
         }
      }

Referenced by exprtk::parser< Type >::compile().

Here is the caller graph for this function:

◆ push_current_state()

template<typename T>

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

inlineprivate

Definition at line 25439 of file exprtk.hpp.

      {
         current_state_stack_.push_back(current_state);
      }

Referenced by exprtk::parser< Type >::parse_expression().

Here is the caller graph for this function:

◆ register_assert_check()

template<typename T>

void exprtk::parser< T >::register_assert_check ( assert_check & assrt_chck )

inline

Definition at line 25195 of file exprtk.hpp.

      {
         assert_check_ = &assrt_chck;
      }

◆ register_compilation_timeout_check()

template<typename T>

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

inline

Definition at line 25190 of file exprtk.hpp.

      {
         compilation_check_ptr_ = &compchk;
      }

◆ register_local_vars()

template<typename T>

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

inlineprivate

Definition at line 41955 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < sem_.size(); ++i)
         {
            scope_element& se = sem_.get_element(i);
 
            exprtk_debug(("register_local_vars() - se[%s]\n", se.name.c_str()));
 
            if (
                 (scope_element::e_variable == se.type) ||
                 (scope_element::e_literal  == se.type) ||
                 (scope_element::e_vecelem  == se.type)
               )
            {
               if (se.var_node)
               {
                  e.register_local_var(se.var_node);
               }
 
               if (se.data)
               {
                  e.register_local_data(se.data, 1, 0);
               }
            }
            else if (scope_element::e_vector == se.type)
            {
               if (se.vec_node)
               {
                  e.register_local_var(se.vec_node);
               }
 
               if (se.data)
               {
                  e.register_local_data(se.data, se.size, 1);
               }
            }
            #ifndef exprtk_disable_string_capabilities
            else if (scope_element::e_string == se.type)
            {
               if (se.str_node)
               {
                  e.register_local_var(se.str_node);
               }
 
               if (se.data)
               {
                  e.register_local_data(se.data, se.size, 2);
               }
            }
            #endif
 
            se.var_node  = 0;
            se.vec_node  = 0;
            #ifndef exprtk_disable_string_capabilities
            se.str_node  = 0;
            #endif
            se.data      = 0;
            se.ref_count = 0;
            se.active    = false;
         }
      }

Referenced by exprtk::parser< Type >::compile().

Here is the caller graph for this function:

◆ register_loop_runtime_check()

template<typename T>

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

inline

Definition at line 25180 of file exprtk.hpp.

      {
         loop_runtime_check_ = &lrtchk;
      }

◆ register_return_results()

template<typename T>

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

inlineprivate

Definition at line 42017 of file exprtk.hpp.

      {
         e.register_return_results(results_context_);
         results_context_ = 0;
      }

Referenced by exprtk::parser< Type >::compile().

Here is the caller graph for this function:

◆ register_vector_access_runtime_check()

template<typename T>

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

inline

Definition at line 25185 of file exprtk.hpp.

      {
         vector_access_runtime_check_ = &vartchk;
      }

◆ remove_last_error()

template<typename T>

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

inlineprivate

Definition at line 41939 of file exprtk.hpp.

      {
         if (!error_list_.empty())
         {
            error_list_.pop_back();
         }
      }

◆ remove_replace_symbol()

template<typename T>

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

inline

Definition at line 25149 of file exprtk.hpp.

      {
         if (!settings_.replacer_enabled())
            return false;
         else if (details::is_reserved_word(symbol))
            return false;
         else
            return symbol_replacer_.remove(symbol);
      }

◆ replace_symbol()

template<typename T>

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

inline

Definition at line 25139 of file exprtk.hpp.

      {
         if (!settings_.replacer_enabled())
            return false;
         else if (details::is_reserved_word(old_symbol))
            return false;
         else
            return symbol_replacer_.add_replace(old_symbol,new_symbol,lexer::token::e_symbol);
      }

◆ results_ctx()

template<typename T>

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

inlineprivate

Definition at line 42191 of file exprtk.hpp.

      {
         if (0 == results_context_)
         {
            results_context_ = new results_context_t();
         }
 
         return (*results_context_);
      }

◆ return_cleanup()

template<typename T>

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

inlineprivate

Definition at line 42201 of file exprtk.hpp.

      {
         #ifndef exprtk_disable_return_statement
         if (results_context_)
         {
            delete results_context_;
            results_context_ = 0;
         }
 
         state_.return_stmt_present = false;
         #endif
      }

Referenced by exprtk::parser< Type >::compile().

Here is the caller graph for this function:

◆ run_assemblies()

template<typename T>

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

inline

Definition at line 24992 of file exprtk.hpp.

      {
         if (settings_.commutative_check_enabled())
         {
            helper_assembly_.run_inserters(lexer());
         }
 
         if (settings_.joiner_enabled())
         {
            helper_assembly_.run_joiners(lexer());
         }
 
         if (settings_.replacer_enabled())
         {
            helper_assembly_.run_modifiers(lexer());
         }
 
         if (
              settings_.numeric_check_enabled () ||
              settings_.bracket_check_enabled () ||
              settings_.sequence_check_enabled()
            )
         {
            if (!helper_assembly_.run_scanners(lexer()))
            {
               if (helper_assembly_.error_token_scanner)
               {
                  lexer::helper::bracket_checker*            bracket_checker_ptr     = 0;
                  lexer::helper::numeric_checker<T>*         numeric_checker_ptr     = 0;
                  lexer::helper::sequence_validator*         sequence_validator_ptr  = 0;
                  lexer::helper::sequence_validator_3tokens* sequence_validator3_ptr = 0;
 
                  if (0 != (bracket_checker_ptr = dynamic_cast<lexer::helper::bracket_checker*>(helper_assembly_.error_token_scanner)))
                  {
                     set_error(make_error(
                        parser_error::e_token,
                        bracket_checker_ptr->error_token(),
                        "ERR005 - Mismatched brackets: '" + bracket_checker_ptr->error_token().value + "'",
                        exprtk_error_location));
                  }
                  else if (0 != (numeric_checker_ptr = dynamic_cast<lexer::helper::numeric_checker<T>*>(helper_assembly_.error_token_scanner)))
                  {
                     for (std::size_t i = 0; i < numeric_checker_ptr->error_count(); ++i)
                     {
                        lexer::token error_token = lexer()[numeric_checker_ptr->error_index(i)];
 
                        set_error(make_error(
                           parser_error::e_token,
                           error_token,
                           "ERR006 - Invalid numeric token: '" + error_token.value + "'",
                           exprtk_error_location));
                     }
 
                     if (numeric_checker_ptr->error_count())
                     {
                        numeric_checker_ptr->clear_errors();
                     }
                  }
                  else if (0 != (sequence_validator_ptr = dynamic_cast<lexer::helper::sequence_validator*>(helper_assembly_.error_token_scanner)))
                  {
                     for (std::size_t i = 0; i < sequence_validator_ptr->error_count(); ++i)
                     {
                        std::pair<lexer::token,lexer::token> error_token = sequence_validator_ptr->error(i);
 
                        set_error(make_error(
                           parser_error::e_token,
                           error_token.first,
                           "ERR007 - Invalid token sequence: '" +
                           error_token.first.value  + "' and '" +
                           error_token.second.value + "'",
                           exprtk_error_location));
                     }
 
                     if (sequence_validator_ptr->error_count())
                     {
                        sequence_validator_ptr->clear_errors();
                     }
                  }
                  else if (0 != (sequence_validator3_ptr = dynamic_cast<lexer::helper::sequence_validator_3tokens*>(helper_assembly_.error_token_scanner)))
                  {
                     for (std::size_t i = 0; i < sequence_validator3_ptr->error_count(); ++i)
                     {
                        std::pair<lexer::token,lexer::token> error_token = sequence_validator3_ptr->error(i);
 
                        set_error(make_error(
                           parser_error::e_token,
                           error_token.first,
                           "ERR008 - Invalid token sequence: '" +
                           error_token.first.value  + "' and '" +
                           error_token.second.value + "'",
                           exprtk_error_location));
                     }
 
                     if (sequence_validator3_ptr->error_count())
                     {
                        sequence_validator3_ptr->clear_errors();
                     }
                  }
               }
 
               return false;
            }
         }
 
         return true;
      }

Referenced by exprtk::parser< Type >::compile().

Here is the caller graph for this function:

◆ set_error()

template<typename T>

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

inlineprivate

Definition at line 41934 of file exprtk.hpp.

      {
         error_list_.push_back(error_type);
      }

Here is the caller graph for this function:

◆ set_synthesis_error()

template<typename T>

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

inlineprivate

Definition at line 41947 of file exprtk.hpp.

      {
         if (synthesis_error_.empty())
         {
            synthesis_error_ = synthesis_error_message;
         }
      }

◆ settings()

template<typename T>

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

inline

Definition at line 25099 of file exprtk.hpp.

      {
         return settings_;
      }

Referenced by exprtk::parser< Type >::parse_define_constvar_statement(), exprtk::parser< Type >::parse_define_var_statement(), exprtk::parser< Type >::parse_define_vector_statement(), and exprtk::parser< Type >::parse_uninitialised_var_statement().

Here is the caller graph for this function:

◆ 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

Definition at line 27916 of file exprtk.hpp.

      {
         if (expression_list.empty())
            return error_node();
         else if (1 == expression_list.size())
            return expression_list[0];
 
         Sequence<expression_node_ptr,Allocator1> tmp_expression_list;
 
         exprtk_debug(("simplify() - expression_list.size: %d  side_effect_list.size(): %d\n",
                       static_cast<int>(expression_list .size()),
                       static_cast<int>(side_effect_list.size())));
 
         bool return_node_present = false;
 
         for (std::size_t i = 0; i < (expression_list.size() - 1); ++i)
         {
            if (is_variable_node(expression_list[i]))
               continue;
            else if (
                      is_return_node  (expression_list[i]) ||
                      is_break_node   (expression_list[i]) ||
                      is_continue_node(expression_list[i])
                    )
            {
               tmp_expression_list.push_back(expression_list[i]);
 
               // Remove all subexpressions after first short-circuit
               // node has been encountered.
 
               for (std::size_t j = i + 1; j < expression_list.size(); ++j)
               {
                  free_node(node_allocator_, expression_list[j]);
               }
 
               return_node_present = true;
 
               break;
            }
            else if (
                      is_constant_node(expression_list[i]) ||
                      is_null_node    (expression_list[i]) ||
                      !side_effect_list[i]
                    )
            {
               free_node(node_allocator_, expression_list[i]);
               continue;
            }
            else
               tmp_expression_list.push_back(expression_list[i]);
         }
 
         if (!return_node_present)
         {
            tmp_expression_list.push_back(expression_list.back());
         }
 
         expression_list.swap(tmp_expression_list);
 
         if (tmp_expression_list.size() > expression_list.size())
         {
            exprtk_debug(("simplify() - Reduced subexpressions from %d to %d\n",
                          static_cast<int>(tmp_expression_list.size()),
                          static_cast<int>(expression_list    .size())));
         }
 
         if (
              return_node_present     ||
              side_effect_list.back() ||
              (expression_list.size() > 1)
            )
            state_.activate_side_effect("simplify()");
 
         if (1 == expression_list.size())
            return expression_list[0];
         else if (specialise_on_final_type && is_generally_string_node(expression_list.back()))
            return expression_generator_.vararg_function(details::e_smulti,expression_list);
         else
            return expression_generator_.vararg_function(details::e_multi,expression_list);
      }

Referenced by exprtk::parser< Type >::parse_corpus(), exprtk::parser< Type >::parse_multi_sequence(), and exprtk::parser< Type >::parse_repeat_until_loop().

Here is the caller graph for this function:

◆ simplify_unary_negation_branch()

template<typename T>

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

inlineprivate

Definition at line 25791 of file exprtk.hpp.

      {
         {
            typedef details::unary_branch_node<T,details::neg_op<T> > ubn_t;
            ubn_t* n = dynamic_cast<ubn_t*>(node);
 
            if (n)
            {
               expression_node_ptr un_r = n->branch(0);
               n->release();
               free_node(node_allocator_, node);
               node = un_r;
 
               return true;
            }
         }
 
         {
            typedef details::unary_variable_node<T,details::neg_op<T> > uvn_t;
 
            uvn_t* n = dynamic_cast<uvn_t*>(node);
 
            if (n)
            {
               const T& v = n->v();
               expression_node_ptr return_node = error_node();
 
               if (
                    (0 != (return_node = symtab_store_.get_variable(v))) ||
                    (0 != (return_node = sem_         .get_variable(v)))
                  )
               {
                  free_node(node_allocator_, node);
                  node = return_node;
 
                  return true;
               }
               else
               {
                  set_error(make_error(
                     parser_error::e_syntax,
                     current_token(),
                     "ERR020 - Failed to find variable node in symbol table",
                     exprtk_error_location));
 
                  free_node(node_allocator_, node);
 
                  return false;
               }
            }
         }
 
         return false;
      }

Referenced by exprtk::parser< Type >::parse_branch(), and exprtk::parser< T >::expression_generator< Type >::synthesize_binary_ext_expression::process().

Here is the caller graph for this function:

◆ 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

Definition at line 28551 of file exprtk.hpp.

      {
         // Perform compile-time range check
         if (details::is_constant_node(index_expr))
         {
            const std::size_t index    = static_cast<std::size_t>(details::numeric::to_int32(index_expr->value()));
            const std::size_t vec_size = vec->size();
 
            if (index >= vec_size)
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR126 - Index of " + details::to_str(index) + " out of range for "
                  "vector '" + vector_name + "' of size " + details::to_str(vec_size),
                  exprtk_error_location));
 
               free_node(node_allocator_, vec_node  );
               free_node(node_allocator_, index_expr);
 
               return error_node();
            }
         }
 
         return expression_generator_.vector_element(vector_name, vec, vec_node, index_expr);
      }

Referenced by exprtk::parser< Type >::parse_pending_vector_index_operator(), and exprtk::parser< Type >::parse_vector().

Here is the caller graph for this function:

◆ total_local_symbol_size_bytes()

template<typename T>

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

inline

Definition at line 25134 of file exprtk.hpp.

      {
         return sem_.total_local_symb_size_bytes();
      }

◆ valid_base_operation()

template<typename T>

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

inlineprivate

Definition at line 25222 of file exprtk.hpp.

      {
         const std::size_t length = symbol.size();
 
         if (
              (length < 3) || // Shortest base op symbol length
              (length > 9)    // Longest base op symbol length
            )
            return false;
         else
            return settings_.function_enabled(symbol) &&
                   (base_ops_map_.end() != base_ops_map_.find(symbol));
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ valid_settings()

template<typename T>

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

inlineprivate

Definition at line 42214 of file exprtk.hpp.

      {
         const std::size_t max_local_vector_size_bytes = sizeof(T) * settings_.max_local_vector_size();
 
         if (max_local_vector_size_bytes > settings_.max_total_local_symbol_size_bytes())
         {
            set_error(make_error(
               parser_error::e_parser,
               "ERR284 - Max local vector size of " + details::to_str(max_local_vector_size_bytes) + " bytes "
               "is larger than max total local symbol size of " + details::to_str(settings_.max_total_local_symbol_size_bytes()) + " bytes",
               exprtk_error_location));
 
            return false;
         }
 
         return true;
      }

Referenced by exprtk::parser< Type >::compile().

Here is the caller graph for this function:

◆ valid_vararg_operation()

template<typename T>

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

inlineprivate

Definition at line 25236 of file exprtk.hpp.

      {
         static const std::string s_sum     = "sum" ;
         static const std::string s_mul     = "mul" ;
         static const std::string s_avg     = "avg" ;
         static const std::string s_min     = "min" ;
         static const std::string s_max     = "max" ;
         static const std::string s_mand    = "mand";
         static const std::string s_mor     = "mor" ;
         static const std::string s_multi   = "~"   ;
         static const std::string s_mswitch = "[*]" ;
 
         return
               (
                  details::imatch(symbol,s_sum    ) ||
                  details::imatch(symbol,s_mul    ) ||
                  details::imatch(symbol,s_avg    ) ||
                  details::imatch(symbol,s_min    ) ||
                  details::imatch(symbol,s_max    ) ||
                  details::imatch(symbol,s_mand   ) ||
                  details::imatch(symbol,s_mor    ) ||
                  details::imatch(symbol,s_multi  ) ||
                  details::imatch(symbol,s_mswitch)
               ) &&
               settings_.function_enabled(symbol);
      }

Referenced by exprtk::parser< Type >::parse_symbol().

Here is the caller graph for this function:

◆ details::disable_type_checking

template<typename T>

template<typename ParserType>

void details::disable_type_checking ( ParserType & p )

friend

Member Data Documentation

◆ assert_check_

template<typename T>

assert_check_ptr exprtk::parser< T >::assert_check_

private

Definition at line 42276 of file exprtk.hpp.

◆ assert_ids_

template<typename T>

std::set<std::string> exprtk::parser< T >::assert_ids_

private

Definition at line 42277 of file exprtk.hpp.

◆ base_ops_map_

template<typename T>

base_ops_map_t exprtk::parser< T >::base_ops_map_

private

Definition at line 42249 of file exprtk.hpp.

◆ binary_op_map_

template<typename T>

binary_op_map_t exprtk::parser< T >::binary_op_map_

private

Definition at line 42251 of file exprtk.hpp.

◆ bracket_checker_

template<typename T>

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

private

Definition at line 42268 of file exprtk.hpp.

◆ brkcnt_list_

template<typename T>

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

private

Definition at line 42243 of file exprtk.hpp.

◆ commutative_inserter_

template<typename T>

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

private

Definition at line 42264 of file exprtk.hpp.

◆ compilation_check_ptr_

template<typename T>

compilation_check_ptr exprtk::parser< T >::compilation_check_ptr_

private

Definition at line 42275 of file exprtk.hpp.

◆ current_state_stack_

template<typename T>

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

private

Definition at line 42257 of file exprtk.hpp.

◆ dec_

template<typename T>

dependent_entity_collector exprtk::parser< T >::dec_

private

Definition at line 42241 of file exprtk.hpp.

◆ default_precedence

template<typename T>

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

staticprivate

Definition at line 25411 of file exprtk.hpp.

◆ default_usr_

template<typename T>

unknown_symbol_resolver exprtk::parser< T >::default_usr_

private

Definition at line 42248 of file exprtk.hpp.

◆ error_list_

template<typename T>

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

private

Definition at line 42242 of file exprtk.hpp.

◆ expression_generator_

template<typename T>

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

private

Definition at line 42238 of file exprtk.hpp.

◆ helper_assembly_

template<typename T>

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

private

Definition at line 42262 of file exprtk.hpp.

◆ immutable_memory_map_

template<typename T>

immutable_memory_map_t exprtk::parser< T >::immutable_memory_map_

private

Definition at line 42259 of file exprtk.hpp.

◆ immutable_symtok_map_

template<typename T>

immutable_symtok_map_t exprtk::parser< T >::immutable_symtok_map_

private

Definition at line 42260 of file exprtk.hpp.

◆ inv_binary_op_map_

template<typename T>

inv_binary_op_map_t exprtk::parser< T >::inv_binary_op_map_

private

Definition at line 42252 of file exprtk.hpp.

◆ loop_runtime_check_

template<typename T>

loop_runtime_check_ptr exprtk::parser< T >::loop_runtime_check_

private

Definition at line 42273 of file exprtk.hpp.

◆ node_allocator_

template<typename T>

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

private

Definition at line 42239 of file exprtk.hpp.

◆ numeric_checker_

template<typename T>

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

private

Definition at line 42269 of file exprtk.hpp.

◆ operator_joiner_2_

template<typename T>

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

private

Definition at line 42265 of file exprtk.hpp.

◆ operator_joiner_3_

template<typename T>

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

private

Definition at line 42266 of file exprtk.hpp.

◆ resolve_unknown_symbol_

template<typename T>

bool exprtk::parser< T >::resolve_unknown_symbol_

private

Definition at line 42245 of file exprtk.hpp.

◆ results_context_

template<typename T>

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

private

Definition at line 42246 of file exprtk.hpp.

◆ sem_

template<typename T>

scope_element_manager exprtk::parser< T >::sem_

private

Definition at line 42256 of file exprtk.hpp.

◆ sequence_validator_

template<typename T>

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

private

Definition at line 42270 of file exprtk.hpp.

◆ sequence_validator_3tkns_

template<typename T>

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

private

Definition at line 42271 of file exprtk.hpp.

◆ settings_

template<typename T>

settings_store exprtk::parser< T >::settings_

private

Definition at line 42237 of file exprtk.hpp.

◆ sf3_map_

template<typename T>

sf3_map_t exprtk::parser< T >::sf3_map_

private

Definition at line 42253 of file exprtk.hpp.

◆ sf4_map_

template<typename T>

sf4_map_t exprtk::parser< T >::sf4_map_

private

Definition at line 42254 of file exprtk.hpp.

◆ state_

template<typename T>

parser_state exprtk::parser< T >::state_

private

Definition at line 42244 of file exprtk.hpp.

◆ symbol_replacer_

template<typename T>

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

private

Definition at line 42267 of file exprtk.hpp.

◆ symtab_store_

template<typename T>

symtab_store exprtk::parser< T >::symtab_store_

private

Definition at line 42240 of file exprtk.hpp.

◆ synthesis_error_

template<typename T>

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

private

Definition at line 42255 of file exprtk.hpp.

◆ unary_op_map_

template<typename T>

unary_op_map_t exprtk::parser< T >::unary_op_map_

private

Definition at line 42250 of file exprtk.hpp.

◆ unknown_symbol_resolver_

template<typename T>

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

private

Definition at line 42247 of file exprtk.hpp.

◆ vector_access_runtime_check_

template<typename T>

vector_access_runtime_check_ptr exprtk::parser< T >::vector_access_runtime_check_

private

Definition at line 42274 of file exprtk.hpp.

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

exprtk/exprtk.hpp

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

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