Namespaces
namespace	constant

namespace	loop_unroll

namespace	numeric

Classes
struct	abs_op

struct	acos_op

struct	acosh_op

struct	add_op

struct	and_op

struct	asin_op

struct	asinh_op

struct	asn_addassignment

struct	asn_assignment

class	assert_node

class	assignment_node

class	assignment_op_node

class	assignment_rebasevec_celem_node

class	assignment_rebasevec_celem_op_node

class	assignment_rebasevec_celem_op_rtc_node

class	assignment_rebasevec_elem_node

class	assignment_rebasevec_elem_op_node

class	assignment_rebasevec_elem_op_rtc_node

class	assignment_rebasevec_elem_rtc_node

class	assignment_string_node

class	assignment_string_range_node

class	assignment_vec_celem_op_rtc_node

class	assignment_vec_elem_node

class	assignment_vec_elem_op_node

class	assignment_vec_elem_op_rtc_node

class	assignment_vec_elem_rtc_node

class	assignment_vec_node

class	assignment_vec_op_node

class	assignment_vecvec_node

class	assignment_vecvec_op_node

struct	atan_op

struct	atanh_op

struct	base_operation_t

class	binary_ext_node

class	binary_node

class	bipow_node

class	bipowinv_node

class	boc_base_node

class	boc_node

class	bov_base_node

class	bov_node

class	break_exception

class	break_node

class	build_string

struct	ceil_op

struct	cis_match

class	cob_base_node

class	cob_node

struct	collector_helper

class	conditional_node

class	conditional_string_node

class	conditional_vector_node

class	cons_conditional_node

class	cons_conditional_str_node

class	const_string_range_node

class	continue_exception

class	continue_node

struct	cos_op

struct	cosh_op

struct	cot_op

class	cov_base_node

class	cov_node

struct	cs_match

struct	csc_op

struct	d2g_op

struct	d2r_op

struct	div_op

struct	eq_op

struct	equal_op

struct	erf_op

struct	erfc_op

struct	exp_op

struct	expm1_op

class	expression_node

struct	floor_op

class	for_loop_bc_node

class	for_loop_bc_rtc_node

class	for_loop_node

class	for_loop_rtc_node

struct	frac_op

class	function_N_node

class	function_N_node< T, IFunction, 0 >

struct	functor_t

struct	g2d_op

class	generic_function_node

class	generic_string_range_node

struct	gt_op

struct	gte_op

struct	ilesscompare

struct	ilike_op

struct	in_op

struct	inrange_op

class	ipow_node

class	ipowinv_node

struct	is_const

struct	is_const< const T >

struct	is_const_ref

struct	is_const_ref< const T & >

struct	is_ref

struct	is_ref< const T & >

struct	is_ref< T & >

class	ivariable

struct	like_op

class	literal_node

struct	log10_op

struct	log1p_op

struct	log2_op

struct	log_op

struct	loop_runtime_checker

struct	lt_op

struct	lte_op

struct	memory_context_t

struct	mod_op

struct	mul_op

class	multi_switch_node

class	multimode_genfunction_node

class	multimode_strfunction_node

struct	nand_op

struct	ncdf_op

struct	ne_op

struct	neg_op

class	node_allocator

class	node_collection_destructor

struct	node_collector_interface

struct	node_depth_base

struct	nodetype_T0oT1

struct	nodetype_T0oT1< T, const T0 &, const T1 & >

struct	nodetype_T0oT1< T, const T0 &, const T1 >

struct	nodetype_T0oT1< T, const T0 &, T1 & >

struct	nodetype_T0oT1< T, const T0, const T1 & >

struct	nodetype_T0oT1< T, const T0, const T1 >

struct	nodetype_T0oT1< T, const T0, T1 & >

struct	nodetype_T0oT1< T, T0 &, const T1 & >

struct	nodetype_T0oT1< T, T0 &, const T1 >

struct	nodetype_T0oT1< T, T0 &, T1 & >

struct	nodetype_T0oT1oT2

struct	nodetype_T0oT1oT2< T, const T0 &, const T1 &, const T2 & >

struct	nodetype_T0oT1oT2< T, const T0 &, const T1 &, const T2 >

struct	nodetype_T0oT1oT2< T, const T0 &, const T1, const T2 & >

struct	nodetype_T0oT1oT2< T, const T0 &, const T1, const T2 >

struct	nodetype_T0oT1oT2< T, const T0, const T1 &, const T2 & >

struct	nodetype_T0oT1oT2< T, const T0, const T1 &, const T2 >

struct	nodetype_T0oT1oT2< T, const T0, const T1, const T2 & >

struct	nodetype_T0oT1oT2< T, const T0, const T1, const T2 >

struct	nodetype_T0oT1oT2< T, T0 &, T1 &, T2 & >

struct	nodetype_T0oT1oT2oT3

struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2 &, const T3 & >

struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2 &, const T3 >

struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2, const T3 & >

struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1 &, const T2, const T3 >

struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2 &, const T3 & >

struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2 &, const T3 >

struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2, const T3 & >

struct	nodetype_T0oT1oT2oT3< T, const T0 &, const T1, const T2, const T3 >

struct	nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2 &, const T3 & >

struct	nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2 &, const T3 >

struct	nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2, const T3 & >

struct	nodetype_T0oT1oT2oT3< T, const T0, const T1 &, const T2, const T3 >

struct	nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2 &, const T3 & >

struct	nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2 &, const T3 >

struct	nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2, const T3 & >

struct	nodetype_T0oT1oT2oT3< T, const T0, const T1, const T2, const T3 >

struct	nor_op

struct	notl_op

class	null_eq_node

class	null_igenfunc

class	null_node

struct	opr_base

struct	or_op

struct	param_to_str

struct	param_to_str< 0 >

struct	pos_op

struct	pow_op

class	quaternary_node

struct	r2d_op

struct	range_data_type

class	range_interface

struct	range_pack

class	rebasevector_celem_node

class	rebasevector_celem_rtc_node

class	rebasevector_elem_node

class	rebasevector_elem_rtc_node

class	repeat_until_loop_bc_node

class	repeat_until_loop_bc_rtc_node

class	repeat_until_loop_node

class	repeat_until_loop_rtc_node

class	return_envelope_node

class	return_exception

class	return_node

struct	round_op

class	scand_node

class	scor_node

struct	sec_op

struct	set_zero_value_impl

struct	set_zero_value_impl< double >

struct	set_zero_value_impl< float >

struct	set_zero_value_impl< long double >

struct	sf00_op

struct	sf01_op

struct	sf02_op

struct	sf03_op

struct	sf04_op

struct	sf05_op

struct	sf06_op

struct	sf07_op

struct	sf08_op

struct	sf09_op

struct	sf10_op

struct	sf11_op

struct	sf12_op

struct	sf13_op

struct	sf14_op

struct	sf15_op

struct	sf16_op

struct	sf17_op

struct	sf18_op

struct	sf19_op

struct	sf20_op

struct	sf21_op

struct	sf22_op

struct	sf23_op

struct	sf24_op

struct	sf25_op

struct	sf26_op

struct	sf27_op

struct	sf28_op

struct	sf29_op

struct	sf30_op

struct	sf31_op

struct	sf32_op

struct	sf33_op

struct	sf34_op

struct	sf35_op

struct	sf36_op

struct	sf37_op

struct	sf38_op

struct	sf39_op

class	sf3_node

class	sf3_var_node

class	sf3ext_type_node

struct	sf40_op

struct	sf41_op

struct	sf42_op

struct	sf43_op

struct	sf44_op

struct	sf45_op

struct	sf46_op

struct	sf47_op

struct	sf48_op

struct	sf49_op

class	sf4_node

class	sf4_var_node

struct	sf50_op

struct	sf51_op

struct	sf52_op

struct	sf53_op

struct	sf54_op

struct	sf55_op

struct	sf56_op

struct	sf57_op

struct	sf58_op

struct	sf59_op

struct	sf60_op

struct	sf61_op

struct	sf62_op

struct	sf63_op

struct	sf64_op

struct	sf65_op

struct	sf66_op

struct	sf67_op

struct	sf68_op

struct	sf69_op

struct	sf70_op

struct	sf71_op

struct	sf72_op

struct	sf73_op

struct	sf74_op

struct	sf75_op

struct	sf76_op

struct	sf77_op

struct	sf78_op

struct	sf79_op

struct	sf80_op

struct	sf81_op

struct	sf82_op

struct	sf83_op

struct	sf84_op

struct	sf85_op

struct	sf86_op

struct	sf87_op

struct	sf88_op

struct	sf89_op

struct	sf90_op

struct	sf91_op

struct	sf92_op

struct	sf93_op

struct	sf94_op

struct	sf95_op

struct	sf96_op

struct	sf97_op

struct	sf98_op

struct	sf99_op

struct	sf_base

struct	sfext00_op

struct	sfext01_op

struct	sfext02_op

struct	sfext03_op

struct	sfext04_op

struct	sfext05_op

struct	sfext06_op

struct	sfext07_op

struct	sfext08_op

struct	sfext09_op

struct	sfext10_op

struct	sfext11_op

struct	sfext12_op

struct	sfext13_op

struct	sfext14_op

struct	sfext15_op

struct	sfext16_op

struct	sfext17_op

struct	sfext18_op

struct	sfext19_op

struct	sfext20_op

struct	sfext21_op

struct	sfext22_op

struct	sfext23_op

struct	sfext24_op

struct	sfext25_op

struct	sfext26_op

struct	sfext27_op

struct	sfext28_op

struct	sfext29_op

struct	sfext30_op

struct	sfext31_op

struct	sfext32_op

struct	sfext33_op

struct	sfext34_op

struct	sfext35_op

struct	sfext36_op

struct	sfext37_op

struct	sfext38_op

struct	sfext39_op

struct	sfext40_op

struct	sfext41_op

struct	sfext42_op

struct	sfext43_op

struct	sfext44_op

struct	sfext45_op

struct	sfext46_op

struct	sfext47_op

struct	sfext48_op

struct	sfext49_op

struct	sfext50_op

struct	sfext51_op

struct	sfext52_op

struct	sfext53_op

struct	sfext54_op

struct	sfext55_op

struct	sfext56_op

struct	sfext57_op

struct	sfext58_op

struct	sfext59_op

struct	sfext60_op

struct	sfext61_op

struct	sgn_op

struct	sin_op

struct	sinc_op

struct	sinh_op

class	sos_base_node

class	sos_node

class	sosos_base_node

class	sosos_node

struct	sqrt_op

class	str_sogens_node

class	str_vararg_node

class	str_xoxr_node

class	str_xrox_node

class	str_xroxr_node

class	string_base_node

class	string_concat_node

class	string_function_node

class	string_literal_node

class	string_range_node

class	string_size_node

class	stringvar_node

class	stringvar_size_node

struct	sub_op

class	swap_generic_node

class	swap_genstrings_node

class	swap_node

class	swap_string_node

class	swap_vecvec_node

class	switch_n_node

class	switch_node

class	T0oT1

struct	T0oT1_define

class	T0oT1oT2

struct	T0oT1oT20T3process

class	T0oT1oT2_base_node

struct	T0oT1oT2_define

class	T0oT1oT2_sf3

class	T0oT1oT2_sf3ext

class	T0oT1oT2oT3

class	T0oT1oT2oT3_base_node

struct	T0oT1oT2oT3_define

class	T0oT1oT2oT3_sf4

class	T0oT1oT2oT3_sf4ext

struct	T0oT1oT2process

struct	tan_op

struct	tanh_op

class	trinary_node

struct	trunc_op

class	unary_branch_node

class	unary_node

class	unary_variable_node

class	unary_vector_node

class	uv_base_node

class	uvouv_node

struct	vararg_add_op

struct	vararg_avg_op

class	vararg_function_node

struct	vararg_mand_op

struct	vararg_max_op

struct	vararg_min_op

struct	vararg_mor_op

struct	vararg_mul_op

struct	vararg_multi_op

class	vararg_node

class	vararg_varnode

class	variable_node

struct	vec_add_op

struct	vec_avg_op

class	vec_binop_valvec_node

class	vec_binop_vecval_node

class	vec_binop_vecvec_node

class	vec_data_store

struct	vec_max_op

struct	vec_min_op

struct	vec_mul_op

class	vector_celem_node

class	vector_celem_rtc_node

class	vector_elem_node

class	vector_elem_rtc_node

class	vector_holder

class	vector_init_iota_constconst_node

class	vector_init_iota_constnconst_node

class	vector_init_iota_nconstconst_node

class	vector_init_iota_nconstnconst_node

class	vector_init_single_constvalue_node

class	vector_init_single_value_node

class	vector_init_zero_value_node

class	vector_initialisation_node

class	vector_interface

class	vector_node

class	vector_size_node

class	vectorize_node

class	vob_base_node

class	vob_node

class	voc_base_node

class	voc_node

class	vov_base_node

class	vov_node

class	while_loop_bc_node

class	while_loop_bc_rtc_node

class	while_loop_node

class	while_loop_rtc_node

struct	xnor_op

struct	xor_op

Typedefs
typedef char	char_t

typedef char_t *	char_ptr

typedef char_t const *	char_cptr

typedef unsigned char	uchar_t

typedef uchar_t *	uchar_ptr

typedef uchar_t const *	uchar_cptr

typedef unsigned long long int	_uint64_t

typedef long long int	_int64_t

Enumerations
enum	operator_type { e_default , e_null , e_add , e_sub , e_mul , e_div , e_mod , e_pow , e_atan2 , e_min , e_max , e_avg , e_sum , e_prod , e_lt , e_lte , e_eq , e_equal , e_ne , e_nequal , e_gte , e_gt , e_and , e_nand , e_or , e_nor , e_xor , e_xnor , e_mand , e_mor , e_scand , e_scor , e_shr , e_shl , e_abs , e_acos , e_acosh , e_asin , e_asinh , e_atan , e_atanh , e_ceil , e_cos , e_cosh , e_exp , e_expm1 , e_floor , e_log , e_log10 , e_log2 , e_log1p , e_logn , e_neg , e_pos , e_round , e_roundn , e_root , e_sqrt , e_sin , e_sinc , e_sinh , e_sec , e_csc , e_tan , e_tanh , e_cot , e_clamp , e_iclamp , e_inrange , e_sgn , e_r2d , e_d2r , e_d2g , e_g2d , e_hypot , e_notl , e_erf , e_erfc , e_ncdf , e_frac , e_trunc , e_assign , e_addass , e_subass , e_mulass , e_divass , e_modass , e_in , e_like , e_ilike , e_multi , e_smulti , e_swap , e_sf00 = 1000 , e_sf01 = 1001 , e_sf02 = 1002 , e_sf03 = 1003 , e_sf04 = 1004 , e_sf05 = 1005 , e_sf06 = 1006 , e_sf07 = 1007 , e_sf08 = 1008 , e_sf09 = 1009 , e_sf10 = 1010 , e_sf11 = 1011 , e_sf12 = 1012 , e_sf13 = 1013 , e_sf14 = 1014 , e_sf15 = 1015 , e_sf16 = 1016 , e_sf17 = 1017 , e_sf18 = 1018 , e_sf19 = 1019 , e_sf20 = 1020 , e_sf21 = 1021 , e_sf22 = 1022 , e_sf23 = 1023 , e_sf24 = 1024 , e_sf25 = 1025 , e_sf26 = 1026 , e_sf27 = 1027 , e_sf28 = 1028 , e_sf29 = 1029 , e_sf30 = 1030 , e_sf31 = 1031 , e_sf32 = 1032 , e_sf33 = 1033 , e_sf34 = 1034 , e_sf35 = 1035 , e_sf36 = 1036 , e_sf37 = 1037 , e_sf38 = 1038 , e_sf39 = 1039 , e_sf40 = 1040 , e_sf41 = 1041 , e_sf42 = 1042 , e_sf43 = 1043 , e_sf44 = 1044 , e_sf45 = 1045 , e_sf46 = 1046 , e_sf47 = 1047 , e_sf48 = 1048 , e_sf49 = 1049 , e_sf50 = 1050 , e_sf51 = 1051 , e_sf52 = 1052 , e_sf53 = 1053 , e_sf54 = 1054 , e_sf55 = 1055 , e_sf56 = 1056 , e_sf57 = 1057 , e_sf58 = 1058 , e_sf59 = 1059 , e_sf60 = 1060 , e_sf61 = 1061 , e_sf62 = 1062 , e_sf63 = 1063 , e_sf64 = 1064 , e_sf65 = 1065 , e_sf66 = 1066 , e_sf67 = 1067 , e_sf68 = 1068 , e_sf69 = 1069 , e_sf70 = 1070 , e_sf71 = 1071 , e_sf72 = 1072 , e_sf73 = 1073 , e_sf74 = 1074 , e_sf75 = 1075 , e_sf76 = 1076 , e_sf77 = 1077 , e_sf78 = 1078 , e_sf79 = 1079 , e_sf80 = 1080 , e_sf81 = 1081 , e_sf82 = 1082 , e_sf83 = 1083 , e_sf84 = 1084 , e_sf85 = 1085 , e_sf86 = 1086 , e_sf87 = 1087 , e_sf88 = 1088 , e_sf89 = 1089 , e_sf90 = 1090 , e_sf91 = 1091 , e_sf92 = 1092 , e_sf93 = 1093 , e_sf94 = 1094 , e_sf95 = 1095 , e_sf96 = 1096 , e_sf97 = 1097 , e_sf98 = 1098 , e_sf99 = 1099 , e_sffinal = 1100 , e_sf4ext00 = 2000 , e_sf4ext01 = 2001 , e_sf4ext02 = 2002 , e_sf4ext03 = 2003 , e_sf4ext04 = 2004 , e_sf4ext05 = 2005 , e_sf4ext06 = 2006 , e_sf4ext07 = 2007 , e_sf4ext08 = 2008 , e_sf4ext09 = 2009 , e_sf4ext10 = 2010 , e_sf4ext11 = 2011 , e_sf4ext12 = 2012 , e_sf4ext13 = 2013 , e_sf4ext14 = 2014 , e_sf4ext15 = 2015 , e_sf4ext16 = 2016 , e_sf4ext17 = 2017 , e_sf4ext18 = 2018 , e_sf4ext19 = 2019 , e_sf4ext20 = 2020 , e_sf4ext21 = 2021 , e_sf4ext22 = 2022 , e_sf4ext23 = 2023 , e_sf4ext24 = 2024 , e_sf4ext25 = 2025 , e_sf4ext26 = 2026 , e_sf4ext27 = 2027 , e_sf4ext28 = 2028 , e_sf4ext29 = 2029 , e_sf4ext30 = 2030 , e_sf4ext31 = 2031 , e_sf4ext32 = 2032 , e_sf4ext33 = 2033 , e_sf4ext34 = 2034 , e_sf4ext35 = 2035 , e_sf4ext36 = 2036 , e_sf4ext37 = 2037 , e_sf4ext38 = 2038 , e_sf4ext39 = 2039 , e_sf4ext40 = 2040 , e_sf4ext41 = 2041 , e_sf4ext42 = 2042 , e_sf4ext43 = 2043 , e_sf4ext44 = 2044 , e_sf4ext45 = 2045 , e_sf4ext46 = 2046 , e_sf4ext47 = 2047 , e_sf4ext48 = 2048 , e_sf4ext49 = 2049 , e_sf4ext50 = 2050 , e_sf4ext51 = 2051 , e_sf4ext52 = 2052 , e_sf4ext53 = 2053 , e_sf4ext54 = 2054 , e_sf4ext55 = 2055 , e_sf4ext56 = 2056 , e_sf4ext57 = 2057 , e_sf4ext58 = 2058 , e_sf4ext59 = 2059 , e_sf4ext60 = 2060 , e_sf4ext61 = 2061 }

Functions
bool	is_whitespace (const char_t c)

bool	is_operator_char (const char_t c)

bool	is_letter (const char_t c)

bool	is_digit (const char_t c)

bool	is_letter_or_digit (const char_t c)

bool	is_left_bracket (const char_t c)

bool	is_right_bracket (const char_t c)

bool	is_bracket (const char_t c)

bool	is_sign (const char_t c)

bool	is_invalid (const char_t c)

bool	is_valid_string_char (const char_t c)

void	case_normalise (std::string &s)

bool	imatch (const char_t c1, const char_t c2)

bool	imatch (const std::string &s1, const std::string &s2)

bool	is_valid_sf_symbol (const std::string &symbol)

const char_t &	front (const std::string &s)

const char_t &	back (const std::string &s)

std::string	to_str (int i)

std::string	to_str (std::size_t i)

bool	is_hex_digit (const uchar_t digit)

uchar_t	hex_to_bin (uchar_t h)

template<typename Iterator >
bool	parse_hex (Iterator &itr, Iterator end, char_t &result)

bool	cleanup_escapes (std::string &s)

bool	is_reserved_word (const std::string &symbol)

bool	is_reserved_symbol (const std::string &symbol)

bool	is_base_function (const std::string &function_name)

bool	is_control_struct (const std::string &cntrl_strct)

bool	is_logic_opr (const std::string &lgc_opr)

template<typename Iterator , typename Compare >
bool	match_impl (const Iterator pattern_begin, const Iterator pattern_end, const Iterator data_begin, const Iterator data_end, const typename std::iterator_traits< Iterator >::value_type &zero_or_more, const typename std::iterator_traits< Iterator >::value_type &exactly_one)

bool	wc_match (const std::string &wild_card, const std::string &str)

bool	wc_imatch (const std::string &wild_card, const std::string &str)

bool	sequence_match (const std::string &pattern, const std::string &str, std::size_t &diff_index, char_t &diff_value)

template<typename T >
void	set_zero_value (T *data, const std::size_t size)

template<typename T >
void	set_zero_value (std::vector< T > &v)

template<typename T >
T	compute_pow10 (T d, const int exponent)

template<typename Iterator , typename T >
bool	string_to_type_converter_impl_ref (Iterator &itr, const Iterator end, T &result)

template<typename Iterator , typename T >
static bool	parse_nan (Iterator &itr, const Iterator end, T &t)

template<typename Iterator , typename T >
static bool	parse_inf (Iterator &itr, const Iterator end, T &t, const bool negative)

template<typename T >
bool	valid_exponent (const int exponent, numeric::details::real_type_tag)

template<typename Iterator , typename T >
bool	string_to_real (Iterator &itr_external, const Iterator end, T &t, numeric::details::real_type_tag)

template<typename T >
bool	string_to_real (const std::string &s, T &t)

std::string	to_str (const operator_type opr)

void	dump_ptr (const std::string &, const void *)

void	dump_ptr (const std::string &, const void *, const std::size_t)

template<typename T >
void	dump_vector (const std::string &, const T *, const std::size_t)

template<typename T >
bool	is_generally_string_node (const expression_node< T > *node)

bool	is_true (const double v)

bool	is_true (const long double v)

bool	is_true (const float v)

template<typename T >
bool	is_true (const expression_node< T > *node)

template<typename T >
bool	is_true (const std::pair< expression_node< T > *, bool > &node)

template<typename T >
bool	is_false (const expression_node< T > *node)

template<typename T >
bool	is_false (const std::pair< expression_node< T > *, bool > &node)

template<typename T >
bool	is_literal_node (const expression_node< T > *node)

template<typename T >
bool	is_unary_node (const expression_node< T > *node)

template<typename T >
bool	is_neg_unary_node (const expression_node< T > *node)

template<typename T >
bool	is_binary_node (const expression_node< T > *node)

template<typename T >
bool	is_variable_node (const expression_node< T > *node)

template<typename T >
bool	is_ivariable_node (const expression_node< T > *node)

template<typename T >
bool	is_vector_elem_node (const expression_node< T > *node)

template<typename T >
bool	is_vector_celem_node (const expression_node< T > *node)

template<typename T >
bool	is_vector_elem_rtc_node (const expression_node< T > *node)

template<typename T >
bool	is_vector_celem_rtc_node (const expression_node< T > *node)

template<typename T >
bool	is_rebasevector_elem_node (const expression_node< T > *node)

template<typename T >
bool	is_rebasevector_elem_rtc_node (const expression_node< T > *node)

template<typename T >
bool	is_rebasevector_celem_rtc_node (const expression_node< T > *node)

template<typename T >
bool	is_rebasevector_celem_node (const expression_node< T > *node)

template<typename T >
bool	is_vector_node (const expression_node< T > *node)

template<typename T >
bool	is_ivector_node (const expression_node< T > *node)

template<typename T >
bool	is_constant_node (const expression_node< T > *node)

template<typename T >
bool	is_null_node (const expression_node< T > *node)

template<typename T >
bool	is_break_node (const expression_node< T > *node)

template<typename T >
bool	is_continue_node (const expression_node< T > *node)

template<typename T >
bool	is_swap_node (const expression_node< T > *node)

template<typename T >
bool	is_function (const expression_node< T > *node)

template<typename T >
bool	is_vararg_node (const expression_node< T > *node)

template<typename T >
bool	is_return_node (const expression_node< T > *node)

template<typename T >
bool	is_negate_node (const expression_node< T > *node)

template<typename T >
bool	is_assert_node (const expression_node< T > *node)

template<typename T >
bool	branch_deletable (const expression_node< T > *node)

template<std::size_t N, typename T >
bool	all_nodes_valid (expression_node< T > *const (&b)[N])

template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	all_nodes_valid (const Sequence< expression_node< T > *, Allocator > &b)

template<std::size_t N, typename T >
bool	all_nodes_variables (expression_node< T > *const (&b)[N])

template<typename T , typename Allocator , template< typename, typename > class Sequence>
bool	all_nodes_variables (const Sequence< expression_node< T > *, Allocator > &b)

template<typename NodeAllocator , typename T , std::size_t N>
void	free_all_nodes (NodeAllocator &node_allocator, expression_node< T > *(&b)[N])

template<typename NodeAllocator , typename T , typename Allocator , template< typename, typename > class Sequence>
void	free_all_nodes (NodeAllocator &node_allocator, Sequence< expression_node< T > *, Allocator > &b)

template<typename NodeAllocator , typename T >
void	free_node (NodeAllocator &, expression_node< T > *&node)

template<typename T >
void	destroy_node (expression_node< T > *&node)

template<typename T , std::size_t N>
void	construct_branch_pair (std::pair< expression_node< T > , bool >(&branch)[N], expression_node< T > b, const std::size_t &index)

template<typename T >
void	construct_branch_pair (std::pair< expression_node< T > , bool > &branch, expression_node< T > b)

template<std::size_t N, typename T >
void	init_branches (std::pair< expression_node< T > , bool >(&branch)[N], expression_node< T > b0, expression_node< T > b1=reinterpret_cast< expression_node< T > >(0), expression_node< T > b2=reinterpret_cast< expression_node< T > >(0), expression_node< T > b3=reinterpret_cast< expression_node< T > >(0), expression_node< T > b4=reinterpret_cast< expression_node< T > >(0), expression_node< T > b5=reinterpret_cast< expression_node< T > >(0), expression_node< T > b6=reinterpret_cast< expression_node< T > >(0), expression_node< T > b7=reinterpret_cast< expression_node< T > >(0), expression_node< T > b8=reinterpret_cast< expression_node< T > >(0), expression_node< T > b9=reinterpret_cast< expression_node< T > >(0))

template<typename T , std::size_t N>
T	axn (const T a, const T x)

template<typename T , std::size_t N>
T	axnb (const T a, const T x, const T b)

template<typename T >
memory_context_t< T >	make_memory_context (vector_holder< T > &vec_holder, vec_data_store< T > &vds)

template<typename T >
memory_context_t< T >	make_memory_context (vector_holder< T > &vec_holder0, vector_holder< T > &vec_holder1, vec_data_store< T > &vds)

template<typename T >
T	value (details::expression_node< T > *n)

template<typename T >
T	value (std::pair< details::expression_node< T > *, bool > n)

template<typename T >
T	value (const T *t)

template<typename T >
T	value (const T &t)

template<typename T >
bool	is_sf3ext_node (const expression_node< T > *n)

template<typename T >
bool	is_sf4ext_node (const expression_node< T > *n)

template<typename T >
bool	is_vov_node (const expression_node< T > *node)

template<typename T >
bool	is_cov_node (const expression_node< T > *node)

template<typename T >
bool	is_voc_node (const expression_node< T > *node)

template<typename T >
bool	is_cob_node (const expression_node< T > *node)

template<typename T >
bool	is_boc_node (const expression_node< T > *node)

template<typename T >
bool	is_t0ot1ot2_node (const expression_node< T > *node)

template<typename T >
bool	is_t0ot1ot2ot3_node (const expression_node< T > *node)

template<typename T >
bool	is_uv_node (const expression_node< T > *node)

template<typename T >
bool	is_string_node (const expression_node< T > *node)

template<typename T >
bool	is_string_range_node (const expression_node< T > *node)

template<typename T >
bool	is_const_string_node (const expression_node< T > *node)

template<typename T >
bool	is_const_string_range_node (const expression_node< T > *node)

template<typename T >
bool	is_string_assignment_node (const expression_node< T > *node)

template<typename T >
bool	is_string_concat_node (const expression_node< T > *node)

template<typename T >
bool	is_string_function_node (const expression_node< T > *node)

template<typename T >
bool	is_string_condition_node (const expression_node< T > *node)

template<typename T >
bool	is_string_ccondition_node (const expression_node< T > *node)

template<typename T >
bool	is_string_vararg_node (const expression_node< T > *node)

template<typename T >
bool	is_genricstring_range_node (const expression_node< T > *node)

void	load_operations_map (std::multimap< std::string, details::base_operation_t, details::ilesscompare > &m)

template<typename Parser >
void	disable_type_checking (Parser &p)

bool	is_true (const cmplx::complex_t &v)

bool	is_false (const cmplx::complex_t &v)

template<typename Iterator >
bool	string_to_real (Iterator &itr_external, const Iterator end, cmplx::complex_t &t, details::numeric::details::complex_type_tag)

bool	is_true (const mpfr::mpreal &v)

bool	is_false (const mpfr::mpreal &v)

template<typename Iterator >
bool	string_to_real (Iterator &itr_external, const Iterator end, mpfr::mpreal &t, numeric::details::mpfrreal_type_tag)

bool	is_true (const real::type v)

bool	is_false (const real::type v)

template<typename Iterator >
bool	string_to_real (Iterator &itr_external, const Iterator end, real::type &t, details::numeric::details::my_real_type_tag)

Variables
static const std::string	reserved_words []

static const std::size_t	reserved_words_size = sizeof(reserved_words) / sizeof(std::string)

static const std::string	reserved_symbols []

static const std::size_t	reserved_symbols_size = sizeof(reserved_symbols) / sizeof(std::string)

static const std::string	base_function_list []

static const std::size_t	base_function_list_size = sizeof(base_function_list) / sizeof(std::string)

static const std::string	logic_ops_list []

static const std::size_t	logic_ops_list_size = sizeof(logic_ops_list) / sizeof(std::string)

static const std::string	cntrl_struct_list []

static const std::size_t	cntrl_struct_list_size = sizeof(cntrl_struct_list) / sizeof(std::string)

static const std::string	arithmetic_ops_list []

static const std::size_t	arithmetic_ops_list_size = sizeof(arithmetic_ops_list) / sizeof(std::string)

static const std::string	assignment_ops_list []

static const std::size_t	assignment_ops_list_size = sizeof(assignment_ops_list) / sizeof(std::string)

static const std::string	inequality_ops_list []

static const std::size_t	inequality_ops_list_size = sizeof(inequality_ops_list) / sizeof(std::string)

static const double	pow10 []

static const std::size_t	pow10_size = sizeof(pow10) / sizeof(double)

Typedef Documentation

◆ _int64_t

typedef long long int exprtk::details::_int64_t

Definition at line 101 of file exprtk.hpp.

◆ _uint64_t

typedef unsigned long long int exprtk::details::_uint64_t

Definition at line 100 of file exprtk.hpp.

◆ char_cptr

typedef char_t const* exprtk::details::char_cptr

Definition at line 96 of file exprtk.hpp.

◆ char_ptr

typedef char_t* exprtk::details::char_ptr

Definition at line 95 of file exprtk.hpp.

◆ char_t

typedef char exprtk::details::char_t

Definition at line 94 of file exprtk.hpp.

◆ uchar_cptr

typedef uchar_t const* exprtk::details::uchar_cptr

Definition at line 99 of file exprtk.hpp.

◆ uchar_ptr

typedef uchar_t* exprtk::details::uchar_ptr

Definition at line 98 of file exprtk.hpp.

◆ uchar_t

typedef unsigned char exprtk::details::uchar_t

Definition at line 97 of file exprtk.hpp.

Enumeration Type Documentation

◆ operator_type

enum exprtk::details::operator_type

private

Enumerator
e_default
e_null
e_add
e_sub
e_mul
e_div
e_mod
e_pow
e_atan2
e_min
e_max
e_avg
e_sum
e_prod
e_lt
e_lte
e_eq
e_equal
e_ne
e_nequal
e_gte
e_gt
e_and
e_nand
e_or
e_nor
e_xor
e_xnor
e_mand
e_mor
e_scand
e_scor
e_shr
e_shl
e_abs
e_acos
e_acosh
e_asin
e_asinh
e_atan
e_atanh
e_ceil
e_cos
e_cosh
e_exp
e_expm1
e_floor
e_log
e_log10
e_log2
e_log1p
e_logn
e_neg
e_pos
e_round
e_roundn
e_root
e_sqrt
e_sin
e_sinc
e_sinh
e_sec
e_csc
e_tan
e_tanh
e_cot
e_clamp
e_iclamp
e_inrange
e_sgn
e_r2d
e_d2r
e_d2g
e_g2d
e_hypot
e_notl
e_erf
e_erfc
e_ncdf
e_frac
e_trunc
e_assign
e_addass
e_subass
e_mulass
e_divass
e_modass
e_in
e_like
e_ilike
e_multi
e_smulti
e_swap
e_sf00
e_sf01
e_sf02
e_sf03
e_sf04
e_sf05
e_sf06
e_sf07
e_sf08
e_sf09
e_sf10
e_sf11
e_sf12
e_sf13
e_sf14
e_sf15
e_sf16
e_sf17
e_sf18
e_sf19
e_sf20
e_sf21
e_sf22
e_sf23
e_sf24
e_sf25
e_sf26
e_sf27
e_sf28
e_sf29
e_sf30
e_sf31
e_sf32
e_sf33
e_sf34
e_sf35
e_sf36
e_sf37
e_sf38
e_sf39
e_sf40
e_sf41
e_sf42
e_sf43
e_sf44
e_sf45
e_sf46
e_sf47
e_sf48
e_sf49
e_sf50
e_sf51
e_sf52
e_sf53
e_sf54
e_sf55
e_sf56
e_sf57
e_sf58
e_sf59
e_sf60
e_sf61
e_sf62
e_sf63
e_sf64
e_sf65
e_sf66
e_sf67
e_sf68
e_sf69
e_sf70
e_sf71
e_sf72
e_sf73
e_sf74
e_sf75
e_sf76
e_sf77
e_sf78
e_sf79
e_sf80
e_sf81
e_sf82
e_sf83
e_sf84
e_sf85
e_sf86
e_sf87
e_sf88
e_sf89
e_sf90
e_sf91
e_sf92
e_sf93
e_sf94
e_sf95
e_sf96
e_sf97
e_sf98
e_sf99
e_sffinal
e_sf4ext00
e_sf4ext01
e_sf4ext02
e_sf4ext03
e_sf4ext04
e_sf4ext05
e_sf4ext06
e_sf4ext07
e_sf4ext08
e_sf4ext09
e_sf4ext10
e_sf4ext11
e_sf4ext12
e_sf4ext13
e_sf4ext14
e_sf4ext15
e_sf4ext16
e_sf4ext17
e_sf4ext18
e_sf4ext19
e_sf4ext20
e_sf4ext21
e_sf4ext22
e_sf4ext23
e_sf4ext24
e_sf4ext25
e_sf4ext26
e_sf4ext27
e_sf4ext28
e_sf4ext29
e_sf4ext30
e_sf4ext31
e_sf4ext32
e_sf4ext33
e_sf4ext34
e_sf4ext35
e_sf4ext36
e_sf4ext37
e_sf4ext38
e_sf4ext39
e_sf4ext40
e_sf4ext41
e_sf4ext42
e_sf4ext43
e_sf4ext44
e_sf4ext45
e_sf4ext46
e_sf4ext47
e_sf4ext48
e_sf4ext49
e_sf4ext50
e_sf4ext51
e_sf4ext52
e_sf4ext53
e_sf4ext54
e_sf4ext55
e_sf4ext56
e_sf4ext57
e_sf4ext58
e_sf4ext59
e_sf4ext60
e_sf4ext61

Definition at line 4996 of file exprtk.hpp.

      {
         e_default , e_null    , e_add     , e_sub     ,
         e_mul     , e_div     , e_mod     , e_pow     ,
         e_atan2   , e_min     , e_max     , e_avg     ,
         e_sum     , e_prod    , e_lt      , e_lte     ,
         e_eq      , e_equal   , e_ne      , e_nequal  ,
         e_gte     , e_gt      , e_and     , e_nand    ,
         e_or      , e_nor     , e_xor     , e_xnor    ,
         e_mand    , e_mor     , e_scand   , e_scor    ,
         e_shr     , e_shl     , e_abs     , e_acos    ,
         e_acosh   , e_asin    , e_asinh   , e_atan    ,
         e_atanh   , e_ceil    , e_cos     , e_cosh    ,
         e_exp     , e_expm1   , e_floor   , e_log     ,
         e_log10   , e_log2    , e_log1p   , e_logn    ,
         e_neg     , e_pos     , e_round   , e_roundn  ,
         e_root    , e_sqrt    , e_sin     , e_sinc    ,
         e_sinh    , e_sec     , e_csc     , e_tan     ,
         e_tanh    , e_cot     , e_clamp   , e_iclamp  ,
         e_inrange , e_sgn     , e_r2d     , e_d2r     ,
         e_d2g     , e_g2d     , e_hypot   , e_notl    ,
         e_erf     , e_erfc    , e_ncdf    , e_frac    ,
         e_trunc   , e_assign  , e_addass  , e_subass  ,
         e_mulass  , e_divass  , e_modass  , e_in      ,
         e_like    , e_ilike   , e_multi   , e_smulti  ,
         e_swap    ,
 
         // Do not add new functions/operators after this point.
         e_sf00 = 1000, e_sf01 = 1001, e_sf02 = 1002, e_sf03 = 1003,
         e_sf04 = 1004, e_sf05 = 1005, e_sf06 = 1006, e_sf07 = 1007,
         e_sf08 = 1008, e_sf09 = 1009, e_sf10 = 1010, e_sf11 = 1011,
         e_sf12 = 1012, e_sf13 = 1013, e_sf14 = 1014, e_sf15 = 1015,
         e_sf16 = 1016, e_sf17 = 1017, e_sf18 = 1018, e_sf19 = 1019,
         e_sf20 = 1020, e_sf21 = 1021, e_sf22 = 1022, e_sf23 = 1023,
         e_sf24 = 1024, e_sf25 = 1025, e_sf26 = 1026, e_sf27 = 1027,
         e_sf28 = 1028, e_sf29 = 1029, e_sf30 = 1030, e_sf31 = 1031,
         e_sf32 = 1032, e_sf33 = 1033, e_sf34 = 1034, e_sf35 = 1035,
         e_sf36 = 1036, e_sf37 = 1037, e_sf38 = 1038, e_sf39 = 1039,
         e_sf40 = 1040, e_sf41 = 1041, e_sf42 = 1042, e_sf43 = 1043,
         e_sf44 = 1044, e_sf45 = 1045, e_sf46 = 1046, e_sf47 = 1047,
         e_sf48 = 1048, e_sf49 = 1049, e_sf50 = 1050, e_sf51 = 1051,
         e_sf52 = 1052, e_sf53 = 1053, e_sf54 = 1054, e_sf55 = 1055,
         e_sf56 = 1056, e_sf57 = 1057, e_sf58 = 1058, e_sf59 = 1059,
         e_sf60 = 1060, e_sf61 = 1061, e_sf62 = 1062, e_sf63 = 1063,
         e_sf64 = 1064, e_sf65 = 1065, e_sf66 = 1066, e_sf67 = 1067,
         e_sf68 = 1068, e_sf69 = 1069, e_sf70 = 1070, e_sf71 = 1071,
         e_sf72 = 1072, e_sf73 = 1073, e_sf74 = 1074, e_sf75 = 1075,
         e_sf76 = 1076, e_sf77 = 1077, e_sf78 = 1078, e_sf79 = 1079,
         e_sf80 = 1080, e_sf81 = 1081, e_sf82 = 1082, e_sf83 = 1083,
         e_sf84 = 1084, e_sf85 = 1085, e_sf86 = 1086, e_sf87 = 1087,
         e_sf88 = 1088, e_sf89 = 1089, e_sf90 = 1090, e_sf91 = 1091,
         e_sf92 = 1092, e_sf93 = 1093, e_sf94 = 1094, e_sf95 = 1095,
         e_sf96 = 1096, e_sf97 = 1097, e_sf98 = 1098, e_sf99 = 1099,
         e_sffinal  = 1100,
         e_sf4ext00 = 2000, e_sf4ext01 = 2001, e_sf4ext02 = 2002, e_sf4ext03 = 2003,
         e_sf4ext04 = 2004, e_sf4ext05 = 2005, e_sf4ext06 = 2006, e_sf4ext07 = 2007,
         e_sf4ext08 = 2008, e_sf4ext09 = 2009, e_sf4ext10 = 2010, e_sf4ext11 = 2011,
         e_sf4ext12 = 2012, e_sf4ext13 = 2013, e_sf4ext14 = 2014, e_sf4ext15 = 2015,
         e_sf4ext16 = 2016, e_sf4ext17 = 2017, e_sf4ext18 = 2018, e_sf4ext19 = 2019,
         e_sf4ext20 = 2020, e_sf4ext21 = 2021, e_sf4ext22 = 2022, e_sf4ext23 = 2023,
         e_sf4ext24 = 2024, e_sf4ext25 = 2025, e_sf4ext26 = 2026, e_sf4ext27 = 2027,
         e_sf4ext28 = 2028, e_sf4ext29 = 2029, e_sf4ext30 = 2030, e_sf4ext31 = 2031,
         e_sf4ext32 = 2032, e_sf4ext33 = 2033, e_sf4ext34 = 2034, e_sf4ext35 = 2035,
         e_sf4ext36 = 2036, e_sf4ext37 = 2037, e_sf4ext38 = 2038, e_sf4ext39 = 2039,
         e_sf4ext40 = 2040, e_sf4ext41 = 2041, e_sf4ext42 = 2042, e_sf4ext43 = 2043,
         e_sf4ext44 = 2044, e_sf4ext45 = 2045, e_sf4ext46 = 2046, e_sf4ext47 = 2047,
         e_sf4ext48 = 2048, e_sf4ext49 = 2049, e_sf4ext50 = 2050, e_sf4ext51 = 2051,
         e_sf4ext52 = 2052, e_sf4ext53 = 2053, e_sf4ext54 = 2054, e_sf4ext55 = 2055,
         e_sf4ext56 = 2056, e_sf4ext57 = 2057, e_sf4ext58 = 2058, e_sf4ext59 = 2059,
         e_sf4ext60 = 2060, e_sf4ext61 = 2061
      };

Function Documentation

◆ all_nodes_valid() [1/2]

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

bool exprtk::details::all_nodes_valid ( const Sequence< expression_node< T > *, Allocator > & b )

inlineprivate

Definition at line 5873 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < b.size(); ++i)
         {
            if (0 == b[i]) return false;
         }
 
         return true;
      }

References match_impl().

Here is the call graph for this function:

◆ all_nodes_valid() [2/2]

template<std::size_t N, typename T >

bool exprtk::details::all_nodes_valid ( expression_node< T > *const (&) b[N] )

inlineprivate

Definition at line 5860 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < N; ++i)
         {
            if (0 == b[i]) return false;
         }
 
         return true;
      }

References match_impl().

Here is the call graph for this function:

◆ all_nodes_variables() [1/2]

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

bool exprtk::details::all_nodes_variables ( const Sequence< expression_node< T > *, Allocator > & b )

inlineprivate

Definition at line 5900 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < b.size(); ++i)
         {
            if (0 == b[i])
               return false;
            else if (!is_variable_node(b[i]))
               return false;
         }
 
         return true;
      }

References is_variable_node(), and match_impl().

Here is the call graph for this function:

◆ all_nodes_variables() [2/2]

template<std::size_t N, typename T >

bool exprtk::details::all_nodes_variables ( expression_node< T > *const (&) b[N] )

inlineprivate

Definition at line 5884 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < N; ++i)
         {
            if (0 == b[i])
               return false;
            else if (!is_variable_node(b[i]))
               return false;
         }
 
         return true;
      }

References is_variable_node(), and match_impl().

Here is the call graph for this function:

◆ axn()

template<typename T , std::size_t N>

T exprtk::details::axn	(	const T	a,
		const T	x
	)

inlineprivate

Definition at line 11769 of file exprtk.hpp.

      {
         // a*x^n
         return a * exprtk::details::numeric::fast_exp<T,N>::result(x);
      }

References exprtk::details::numeric::fast_exp< T, N >::result().

Here is the call graph for this function:

◆ axnb()

template<typename T , std::size_t N>

T exprtk::details::axnb	(	const T	a,
		const T	x,
		const T	b
	)

inlineprivate

Definition at line 11776 of file exprtk.hpp.

      {
         // a*x^n+b
         return a * exprtk::details::numeric::fast_exp<T,N>::result(x) + b;
      }

References exprtk::details::numeric::fast_exp< T, N >::result().

Here is the call graph for this function:

◆ back()

const char_t & exprtk::details::back ( const std::string & s )

inline

Definition at line 272 of file exprtk.hpp.

      {
         return s[s.size() - 1];
      }

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

Here is the caller graph for this function:

◆ branch_deletable()

template<typename T >

bool exprtk::details::branch_deletable ( const expression_node< T > * node )

inlineprivate

Definition at line 5852 of file exprtk.hpp.

      {
         return (0 != node)             &&
                !is_variable_node(node) &&
                !is_string_node  (node) ;
      }

References is_string_node(), is_variable_node(), and match_impl().

Referenced by exprtk::details::node_depth_base< Node >::collect(), exprtk::details::node_depth_base< Node >::collect(), construct_branch_pair(), construct_branch_pair(), exprtk::details::generic_function_node< T, GenericFunction >::init_branches(), exprtk::details::function_N_node< T, IFunction, N >::init_branches(), and exprtk::expression< T >::control_block::~control_block().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ case_normalise()

void exprtk::details::case_normalise ( std::string & s )

inline

Definition at line 182 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < s.size(); ++i)
         {
            s[i] = static_cast<std::string::value_type>(std::tolower(s[i]));
         }
      }

Referenced by exprtk::parser< T >::dependent_entity_collector::assignment_symbols(), and exprtk::parser< T >::dependent_entity_collector::symbols().

Here is the caller graph for this function:

◆ cleanup_escapes()

bool exprtk::details::cleanup_escapes ( std::string & s )

inline

Definition at line 345 of file exprtk.hpp.

      {
         typedef std::string::iterator str_itr_t;
 
         str_itr_t itr1 = s.begin();
         str_itr_t itr2 = s.begin();
         str_itr_t end  = s.end  ();
 
         std::size_t removal_count  = 0;
 
         while (end != itr1)
         {
            if ('\\' == (*itr1))
            {
               if (end == ++itr1)
               {
                  return false;
               }
               else if (parse_hex(itr1, end, *itr2))
               {
                  itr1 += 4;
                  itr2 += 1;
                  removal_count += 4;
               }
               else if ('a' == (*itr1)) { (*itr2++) = '\a'; ++itr1; ++removal_count; }
               else if ('b' == (*itr1)) { (*itr2++) = '\b'; ++itr1; ++removal_count; }
               else if ('f' == (*itr1)) { (*itr2++) = '\f'; ++itr1; ++removal_count; }
               else if ('n' == (*itr1)) { (*itr2++) = '\n'; ++itr1; ++removal_count; }
               else if ('r' == (*itr1)) { (*itr2++) = '\r'; ++itr1; ++removal_count; }
               else if ('t' == (*itr1)) { (*itr2++) = '\t'; ++itr1; ++removal_count; }
               else if ('v' == (*itr1)) { (*itr2++) = '\v'; ++itr1; ++removal_count; }
               else if ('0' == (*itr1)) { (*itr2++) = '\0'; ++itr1; ++removal_count; }
               else
               {
                  (*itr2++) = (*itr1++);
                  ++removal_count;
               }
 
               continue;
            }
            else
               (*itr2++) = (*itr1++);
         }
 
         if ((removal_count > s.size()) || (0 == removal_count))
            return false;
 
         s.resize(s.size() - removal_count);
 
         return true;
      }

References parse_hex().

Referenced by exprtk::lexer::generator::scan_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_pow10()

template<typename T >

T exprtk::details::compute_pow10	(	T	d,
		const int	exponent
	)

inline

Definition at line 1719 of file exprtk.hpp.

      {
         static const double fract10[] =
         {
            0.0,
            1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004, 1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008, 1.0E+009, 1.0E+010,
            1.0E+011, 1.0E+012, 1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016, 1.0E+017, 1.0E+018, 1.0E+019, 1.0E+020,
            1.0E+021, 1.0E+022, 1.0E+023, 1.0E+024, 1.0E+025, 1.0E+026, 1.0E+027, 1.0E+028, 1.0E+029, 1.0E+030,
            1.0E+031, 1.0E+032, 1.0E+033, 1.0E+034, 1.0E+035, 1.0E+036, 1.0E+037, 1.0E+038, 1.0E+039, 1.0E+040,
            1.0E+041, 1.0E+042, 1.0E+043, 1.0E+044, 1.0E+045, 1.0E+046, 1.0E+047, 1.0E+048, 1.0E+049, 1.0E+050,
            1.0E+051, 1.0E+052, 1.0E+053, 1.0E+054, 1.0E+055, 1.0E+056, 1.0E+057, 1.0E+058, 1.0E+059, 1.0E+060,
            1.0E+061, 1.0E+062, 1.0E+063, 1.0E+064, 1.0E+065, 1.0E+066, 1.0E+067, 1.0E+068, 1.0E+069, 1.0E+070,
            1.0E+071, 1.0E+072, 1.0E+073, 1.0E+074, 1.0E+075, 1.0E+076, 1.0E+077, 1.0E+078, 1.0E+079, 1.0E+080,
            1.0E+081, 1.0E+082, 1.0E+083, 1.0E+084, 1.0E+085, 1.0E+086, 1.0E+087, 1.0E+088, 1.0E+089, 1.0E+090,
            1.0E+091, 1.0E+092, 1.0E+093, 1.0E+094, 1.0E+095, 1.0E+096, 1.0E+097, 1.0E+098, 1.0E+099, 1.0E+100,
            1.0E+101, 1.0E+102, 1.0E+103, 1.0E+104, 1.0E+105, 1.0E+106, 1.0E+107, 1.0E+108, 1.0E+109, 1.0E+110,
            1.0E+111, 1.0E+112, 1.0E+113, 1.0E+114, 1.0E+115, 1.0E+116, 1.0E+117, 1.0E+118, 1.0E+119, 1.0E+120,
            1.0E+121, 1.0E+122, 1.0E+123, 1.0E+124, 1.0E+125, 1.0E+126, 1.0E+127, 1.0E+128, 1.0E+129, 1.0E+130,
            1.0E+131, 1.0E+132, 1.0E+133, 1.0E+134, 1.0E+135, 1.0E+136, 1.0E+137, 1.0E+138, 1.0E+139, 1.0E+140,
            1.0E+141, 1.0E+142, 1.0E+143, 1.0E+144, 1.0E+145, 1.0E+146, 1.0E+147, 1.0E+148, 1.0E+149, 1.0E+150,
            1.0E+151, 1.0E+152, 1.0E+153, 1.0E+154, 1.0E+155, 1.0E+156, 1.0E+157, 1.0E+158, 1.0E+159, 1.0E+160,
            1.0E+161, 1.0E+162, 1.0E+163, 1.0E+164, 1.0E+165, 1.0E+166, 1.0E+167, 1.0E+168, 1.0E+169, 1.0E+170,
            1.0E+171, 1.0E+172, 1.0E+173, 1.0E+174, 1.0E+175, 1.0E+176, 1.0E+177, 1.0E+178, 1.0E+179, 1.0E+180,
            1.0E+181, 1.0E+182, 1.0E+183, 1.0E+184, 1.0E+185, 1.0E+186, 1.0E+187, 1.0E+188, 1.0E+189, 1.0E+190,
            1.0E+191, 1.0E+192, 1.0E+193, 1.0E+194, 1.0E+195, 1.0E+196, 1.0E+197, 1.0E+198, 1.0E+199, 1.0E+200,
            1.0E+201, 1.0E+202, 1.0E+203, 1.0E+204, 1.0E+205, 1.0E+206, 1.0E+207, 1.0E+208, 1.0E+209, 1.0E+210,
            1.0E+211, 1.0E+212, 1.0E+213, 1.0E+214, 1.0E+215, 1.0E+216, 1.0E+217, 1.0E+218, 1.0E+219, 1.0E+220,
            1.0E+221, 1.0E+222, 1.0E+223, 1.0E+224, 1.0E+225, 1.0E+226, 1.0E+227, 1.0E+228, 1.0E+229, 1.0E+230,
            1.0E+231, 1.0E+232, 1.0E+233, 1.0E+234, 1.0E+235, 1.0E+236, 1.0E+237, 1.0E+238, 1.0E+239, 1.0E+240,
            1.0E+241, 1.0E+242, 1.0E+243, 1.0E+244, 1.0E+245, 1.0E+246, 1.0E+247, 1.0E+248, 1.0E+249, 1.0E+250,
            1.0E+251, 1.0E+252, 1.0E+253, 1.0E+254, 1.0E+255, 1.0E+256, 1.0E+257, 1.0E+258, 1.0E+259, 1.0E+260,
            1.0E+261, 1.0E+262, 1.0E+263, 1.0E+264, 1.0E+265, 1.0E+266, 1.0E+267, 1.0E+268, 1.0E+269, 1.0E+270,
            1.0E+271, 1.0E+272, 1.0E+273, 1.0E+274, 1.0E+275, 1.0E+276, 1.0E+277, 1.0E+278, 1.0E+279, 1.0E+280,
            1.0E+281, 1.0E+282, 1.0E+283, 1.0E+284, 1.0E+285, 1.0E+286, 1.0E+287, 1.0E+288, 1.0E+289, 1.0E+290,
            1.0E+291, 1.0E+292, 1.0E+293, 1.0E+294, 1.0E+295, 1.0E+296, 1.0E+297, 1.0E+298, 1.0E+299, 1.0E+300,
            1.0E+301, 1.0E+302, 1.0E+303, 1.0E+304, 1.0E+305, 1.0E+306, 1.0E+307, 1.0E+308
         };
 
         static const int fract10_size = static_cast<int>(sizeof(fract10) / sizeof(double));
 
         const int e = std::abs(exponent);
 
         if (exponent >= std::numeric_limits<T>::min_exponent10)
         {
            if (e < fract10_size)
            {
               if (exponent > 0)
                  return T(d * fract10[e]);
               else
                  return T(d / fract10[e]);
            }
            else
               return T(d * std::pow(10.0, 10.0 * exponent));
         }
         else
         {
                     d /= T(fract10[           -std::numeric_limits<T>::min_exponent10]);
            return T(d /    fract10[-exponent + std::numeric_limits<T>::min_exponent10]);
         }
      }

References match_impl().

Referenced by string_to_real().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ construct_branch_pair() [1/2]

template<typename T >

void exprtk::details::construct_branch_pair	(	std::pair< expression_node< T > *, bool > &	branch,
		expression_node< T > *	b
	)

inlineprivate

Definition at line 6622 of file exprtk.hpp.

      {
         if (b)
         {
            branch = std::make_pair(b,branch_deletable(b));
         }
      }

References branch_deletable().

Here is the call graph for this function:

◆ construct_branch_pair() [2/2]

template<typename T , std::size_t N>

void exprtk::details::construct_branch_pair	(	std::pair< expression_node< T > *, bool >(&)	branch[N],
		expression_node< T > *	b,
		const std::size_t &	index
	)

inlineprivate

Definition at line 6611 of file exprtk.hpp.

      {
         if (b && (index < N))
         {
            branch[index] = std::make_pair(b,branch_deletable(b));
         }
      }

References branch_deletable(), and match_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_node()

template<typename T >

void exprtk::details::destroy_node ( expression_node< T > *& node )

inlineprivate

Definition at line 6019 of file exprtk.hpp.

      {
         if (0 != node)
         {
            node_collection_destructor<expression_node<T> >
               ::delete_nodes(node);
         }
      }

References match_impl().

Referenced by exprtk::details::range_pack< T >::free().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disable_type_checking()

template<typename Parser >

void exprtk::details::disable_type_checking ( Parser & p )

inline

Definition at line 22168 of file exprtk.hpp.

      {
         p.state_.type_check_enabled = false;
      }

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

Here is the caller graph for this function:

◆ dump_ptr() [1/2]

void exprtk::details::dump_ptr	(	const std::string &	,
		const void *
	)

inlineprivate

Definition at line 5164 of file exprtk.hpp.

5164{}

Referenced by exprtk::details::vec_data_store< T >::control_block::create_data(), exprtk::expression< T >::release(), exprtk::details::vec_data_store< T >::control_block::~control_block(), and exprtk::symbol_table< T >::~symbol_table().

Here is the caller graph for this function:

◆ dump_ptr() [2/2]

void exprtk::details::dump_ptr	(	const std::string &	,
		const void *	,
		const std::size_t
	)

inlineprivate

Definition at line 5165 of file exprtk.hpp.

5165{}

◆ dump_vector()

template<typename T >

void exprtk::details::dump_vector	(	const std::string &	,
		const T *	,
		const std::size_t
	)

inlineprivate

Definition at line 5167 of file exprtk.hpp.

5167{}

◆ free_all_nodes() [1/2]

template<typename NodeAllocator , typename T , std::size_t N>

void exprtk::details::free_all_nodes	(	NodeAllocator &	node_allocator,
		expression_node< T > *(&)	b[N]
	)

inlineprivate

Definition at line 5984 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < N; ++i)
         {
            free_node(node_allocator,b[i]);
         }
      }

References free_node(), and match_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_all_nodes() [2/2]

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

void exprtk::details::free_all_nodes	(	NodeAllocator &	node_allocator,
		Sequence< expression_node< T > *, Allocator > &	b
	)

inlineprivate

Definition at line 5996 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < b.size(); ++i)
         {
            free_node(node_allocator,b[i]);
         }
 
         b.clear();
      }

References free_node(), and match_impl().

Here is the call graph for this function:

◆ free_node()

template<typename NodeAllocator , typename T >

void exprtk::details::free_node	(	NodeAllocator &	,
		expression_node< T > *&	node
	)

inlineprivate

Definition at line 6007 of file exprtk.hpp.

      {
         if ((0 == node) || is_variable_node(node) || is_string_node(node))
         {
            return;
         }
 
         node_collection_destructor<expression_node<T> >
            ::delete_nodes(node);
      }

References is_string_node(), is_variable_node(), and match_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ front()

const char_t & exprtk::details::front ( const std::string & s )

inline

Definition at line 267 of file exprtk.hpp.

      {
         return s[0];
      }

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

Here is the caller graph for this function:

◆ hex_to_bin()

uchar_t exprtk::details::hex_to_bin ( uchar_t h )

inline

Definition at line 313 of file exprtk.hpp.

      {
         if (('0' <= h) && (h <= '9'))
            return (h - '0');
         else
            return static_cast<uchar_t>(std::toupper(h) - 'A');
      }

Referenced by parse_hex().

Here is the caller graph for this function:

◆ imatch() [1/2]

bool exprtk::details::imatch	(	const char_t	c1,
		const char_t	c2
	)

inline

Definition at line 190 of file exprtk.hpp.

      {
         return std::tolower(c1) == std::tolower(c2);
      }

Here is the caller graph for this function:

◆ imatch() [2/2]

bool exprtk::details::imatch	(	const std::string &	s1,
		const std::string &	s2
	)

inline

Definition at line 195 of file exprtk.hpp.

      {
         if (s1.size() == s2.size())
         {
            for (std::size_t i = 0; i < s1.size(); ++i)
            {
               if (std::tolower(s1[i]) != std::tolower(s2[i]))
               {
                  return false;
               }
            }
 
            return true;
         }
 
         return false;
      }

◆ init_branches()

template<std::size_t N, typename T >

void exprtk::details::init_branches	(	std::pair< expression_node< T > *, bool >(&)	branch[N],
		expression_node< T > *	b0,
		expression_node< T > *	b1 = `reinterpret_cast<expression_node<T>*>(0)`,
		expression_node< T > *	b2 = `reinterpret_cast<expression_node<T>*>(0)`,
		expression_node< T > *	b3 = `reinterpret_cast<expression_node<T>*>(0)`,
		expression_node< T > *	b4 = `reinterpret_cast<expression_node<T>*>(0)`,
		expression_node< T > *	b5 = `reinterpret_cast<expression_node<T>*>(0)`,
		expression_node< T > *	b6 = `reinterpret_cast<expression_node<T>*>(0)`,
		expression_node< T > *	b7 = `reinterpret_cast<expression_node<T>*>(0)`,
		expression_node< T > *	b8 = `reinterpret_cast<expression_node<T>*>(0)`,
		expression_node< T > *	b9 = `reinterpret_cast<expression_node<T>*>(0)`
	)

inlineprivate

Definition at line 6631 of file exprtk.hpp.

      {
         construct_branch_pair(branch, b0, 0);
         construct_branch_pair(branch, b1, 1);
         construct_branch_pair(branch, b2, 2);
         construct_branch_pair(branch, b3, 3);
         construct_branch_pair(branch, b4, 4);
         construct_branch_pair(branch, b5, 5);
         construct_branch_pair(branch, b6, 6);
         construct_branch_pair(branch, b7, 7);
         construct_branch_pair(branch, b8, 8);
         construct_branch_pair(branch, b9, 9);
      }

References construct_branch_pair(), and match_impl().

Here is the call graph for this function:

◆ is_assert_node()

template<typename T >

bool exprtk::details::is_assert_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5846 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_assert == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::expression_helper< T >::is_assert(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_base_function()

bool exprtk::details::is_base_function ( const std::string & function_name )

inline

Definition at line 542 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < base_function_list_size; ++i)
         {
            if (imatch(function_name, base_function_list[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References base_function_list, base_function_list_size, and imatch().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_binary_node()

template<typename T >

bool exprtk::details::is_binary_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5673 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_binary == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::expression_helper< T >::is_binary(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_boc_node()

template<typename T >

bool exprtk::details::is_boc_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18895 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const boc_base_node<T>*>(node));
      }

References match_impl().

Referenced by exprtk::parser< T >::expression_generator< Type >::coboc_optimisable(), exprtk::parser< T >::expression_generator< Type >::synthesize_boc_expression::process(), and exprtk::parser< T >::expression_generator< Type >::synthesize_coboc_expression::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_bracket()

bool exprtk::details::is_bracket ( const char_t c )

inline

Definition at line 152 of file exprtk.hpp.

      {
         return is_left_bracket(c) || is_right_bracket(c);
      }

References is_left_bracket(), and is_right_bracket().

Referenced by exprtk::lexer::helper::bracket_checker::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_break_node()

template<typename T >

bool exprtk::details::is_break_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5797 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_break == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::is_invalid_break_continue_op(), and exprtk::parser< T >::expression_generator< Type >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_cob_node()

template<typename T >

bool exprtk::details::is_cob_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18889 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const cob_base_node<T>*>(node));
      }

References match_impl().

Referenced by exprtk::parser< T >::expression_generator< Type >::cocob_optimisable(), exprtk::parser< T >::expression_generator< Type >::synthesize_cob_expression::process(), and exprtk::parser< T >::expression_generator< Type >::synthesize_cocob_expression::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_const_string_node()

template<typename T >

bool exprtk::details::is_const_string_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18931 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_stringconst == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::parser< T >::parse_assert_statement(), exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_const_string_range_node()

template<typename T >

bool exprtk::details::is_const_string_range_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18937 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_cstringvarrng == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::details::generic_function_node< T, GenericFunction >::init_branches(), and exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_constant_node()

template<typename T >

bool exprtk::details::is_constant_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5781 of file exprtk.hpp.

      {
         return node &&
         (
           details::expression_node<T>::e_constant    == node->type() ||
           details::expression_node<T>::e_stringconst == node->type()
         );
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_continue_node()

template<typename T >

bool exprtk::details::is_continue_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5803 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_continue == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::is_invalid_break_continue_op(), and exprtk::parser< T >::expression_generator< Type >::operator()().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_control_struct()

bool exprtk::details::is_control_struct ( const std::string & cntrl_strct )

inline

Definition at line 555 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < cntrl_struct_list_size; ++i)
         {
            if (imatch(cntrl_strct, cntrl_struct_list[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References cntrl_struct_list, cntrl_struct_list_size, and imatch().

Here is the call graph for this function:

◆ is_cov_node()

template<typename T >

bool exprtk::details::is_cov_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18877 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const cov_base_node<T>*>(node));
      }

References match_impl().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_digit()

bool exprtk::details::is_digit ( const char_t c )

inline

Definition at line 132 of file exprtk.hpp.

      {
         return ('0' <= c) && (c <= '9');
      }

Referenced by is_invalid(), is_letter_or_digit(), is_valid_sf_symbol(), exprtk::lexer::generator::next_is_digit(), exprtk::parser< T >::parse_special_function(), exprtk::lexer::generator::scan_number(), exprtk::lexer::generator::scan_special_function(), and exprtk::lexer::generator::scan_token().

Here is the caller graph for this function:

◆ is_false() [1/5]

bool exprtk::details::is_false ( const cmplx::complex_t & v )

inline

Definition at line 375 of file exprtk_complex_adaptor.hpp.

375{ return cmplx::is_false(v); }

cmplx::is_false

bool is_false(const complex_t v)

Definition complex_type.hpp:214

References cmplx::is_false().

Here is the call graph for this function:

◆ is_false() [2/5]

template<typename T >

bool exprtk::details::is_false ( const expression_node< T > * node )

inlineprivate

Definition at line 5643 of file exprtk.hpp.

      {
         return std::equal_to<T>()(T(0),node->value());
      }

References match_impl().

Referenced by exprtk::details::repeat_until_loop_node< T >::value(), exprtk::details::repeat_until_loop_rtc_node< T >::value(), exprtk::details::repeat_until_loop_bc_node< T >::value(), and exprtk::details::repeat_until_loop_bc_rtc_node< T >::value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_false() [3/5]

bool exprtk::details::is_false ( const mpfr::mpreal & v )

inline

Definition at line 375 of file exprtk_mpfr_adaptor.hpp.

375{ return details::numeric::details::is_false_impl(v); }

References exprtk::details::numeric::details::is_false_impl().

Here is the call graph for this function:

◆ is_false() [4/5]

bool exprtk::details::is_false ( const real::type v )

inline

Definition at line 350 of file exprtk_real_adaptor.hpp.

350{ return real::is_false(v); }

real::is_false

bool is_false(const type v)

Definition real_type.hpp:229

References real::is_false().

Here is the call graph for this function:

◆ is_false() [5/5]

template<typename T >

bool exprtk::details::is_false ( const std::pair< expression_node< T > *, bool > & node )

inlineprivate

Definition at line 5649 of file exprtk.hpp.

      {
         return std::equal_to<T>()(T(0),node.first->value());
      }

References match_impl().

Here is the call graph for this function:

◆ is_function()

template<typename T >

bool exprtk::details::is_function ( const expression_node< T > * node )

inlineprivate

Definition at line 5815 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_function == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::expression_helper< T >::is_function(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_generally_string_node()

template<typename T >

bool exprtk::details::is_generally_string_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18985 of file exprtk.hpp.

      {
         if (node)
         {
            switch (node->type())
            {
               case expression_node<T>::e_stringvar     :
               case expression_node<T>::e_stringconst   :
               case expression_node<T>::e_stringvarrng  :
               case expression_node<T>::e_cstringvarrng :
               case expression_node<T>::e_strgenrange   :
               case expression_node<T>::e_strass        :
               case expression_node<T>::e_strconcat     :
               case expression_node<T>::e_strfunction   :
               case expression_node<T>::e_strcondition  :
               case expression_node<T>::e_strccondition :
               case expression_node<T>::e_stringvararg  : return true;
               default                                  : return false;
            }
         }
 
         return false;
      }

References match_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_genricstring_range_node()

template<typename T >

bool exprtk::details::is_genricstring_range_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18979 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strgenrange == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_hex_digit()

bool exprtk::details::is_hex_digit ( const uchar_t digit )

inline

Definition at line 306 of file exprtk.hpp.

      {
         return (('0' <= digit) && (digit <= '9')) ||
                (('A' <= digit) && (digit <= 'F')) ||
                (('a' <= digit) && (digit <= 'f')) ;
      }

Referenced by parse_hex(), and exprtk::lexer::generator::scan_string().

Here is the caller graph for this function:

◆ is_invalid()

bool exprtk::details::is_invalid ( const char_t c )

inline

Definition at line 162 of file exprtk.hpp.

      {
         return !is_whitespace   (c) &&
                !is_operator_char(c) &&
                !is_letter       (c) &&
                !is_digit        (c) &&
                ('.'  != c)          &&
                ('_'  != c)          &&
                ('$'  != c)          &&
                ('~'  != c)          &&
                ('\'' != c);
      }

References is_digit(), is_letter(), is_operator_char(), and is_whitespace().

Here is the call graph for this function:

◆ is_ivariable_node()

template<typename T >

bool exprtk::details::is_ivariable_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5685 of file exprtk.hpp.

      {
         return node &&
                (
                  details::expression_node<T>::e_variable      == node->type() ||
                  details::expression_node<T>::e_vecelem       == node->type() ||
                  details::expression_node<T>::e_veccelem      == node->type() ||
                  details::expression_node<T>::e_vecelemrtc    == node->type() ||
                  details::expression_node<T>::e_veccelemrtc   == node->type() ||
                  details::expression_node<T>::e_rbvecelem     == node->type() ||
                  details::expression_node<T>::e_rbveccelem    == node->type() ||
                  details::expression_node<T>::e_rbvecelemrtc  == node->type() ||
                  details::expression_node<T>::e_rbveccelemrtc == node->type()
                );
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_swap_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_ivector_node()

template<typename T >

bool exprtk::details::is_ivector_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5756 of file exprtk.hpp.

      {
         if (node)
         {
            switch (node->type())
            {
               case details::expression_node<T>::e_vector      :
               case details::expression_node<T>::e_vecvalass   :
               case details::expression_node<T>::e_vecvecass   :
               case details::expression_node<T>::e_vecopvalass :
               case details::expression_node<T>::e_vecopvecass :
               case details::expression_node<T>::e_vecvecswap  :
               case details::expression_node<T>::e_vecvecarith :
               case details::expression_node<T>::e_vecvalarith :
               case details::expression_node<T>::e_valvecarith :
               case details::expression_node<T>::e_vecunaryop  :
               case details::expression_node<T>::e_vecondition : return true;
               default                                         : return false;
            }
         }
         else
            return false;
      }

References match_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_left_bracket()

bool exprtk::details::is_left_bracket ( const char_t c )

inline

Definition at line 142 of file exprtk.hpp.

      {
         return ('(' == c) || ('[' == c) || ('{' == c);
      }

Referenced by exprtk::lexer::helper::sequence_validator::invalid_bracket_check(), and is_bracket().

Here is the caller graph for this function:

◆ is_letter()

bool exprtk::details::is_letter ( const char_t c )

inline

Definition at line 126 of file exprtk.hpp.

      {
         return (('a' <= c) && (c <= 'z')) ||
                (('A' <= c) && (c <= 'Z')) ;
      }

Referenced by is_invalid(), is_letter_or_digit(), exprtk::lexer::generator::scan_token(), exprtk::symbol_table< T >::valid_function(), and exprtk::symbol_table< T >::valid_symbol().

Here is the caller graph for this function:

◆ is_letter_or_digit()

bool exprtk::details::is_letter_or_digit ( const char_t c )

inline

Definition at line 137 of file exprtk.hpp.

      {
         return is_letter(c) || is_digit(c);
      }

References is_digit(), and is_letter().

Referenced by exprtk::lexer::generator::scan_symbol(), exprtk::symbol_table< T >::valid_function(), and exprtk::symbol_table< T >::valid_symbol().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_literal_node()

template<typename T >

bool exprtk::details::is_literal_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5655 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_constant == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::expression_helper< T >::is_literal(), exprtk::expression_helper< T >::match_type_sequence(), exprtk::parser< T >::parse_define_constvar_statement(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_logic_opr()

bool exprtk::details::is_logic_opr ( const std::string & lgc_opr )

inline

Definition at line 568 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < logic_ops_list_size; ++i)
         {
            if (imatch(lgc_opr, logic_ops_list[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References imatch(), logic_ops_list, and logic_ops_list_size.

Here is the call graph for this function:

◆ is_neg_unary_node()

template<typename T >

bool exprtk::details::is_neg_unary_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5667 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_neg == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_negate_node()

template<typename T >

bool exprtk::details::is_negate_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5835 of file exprtk.hpp.

      {
         if (node && is_unary_node(node))
         {
            return (details::e_neg == static_cast<const unary_node<T>*>(node)->operation());
         }
         else
            return false;
      }

References e_neg, is_unary_node(), and match_impl().

Here is the call graph for this function:

◆ is_null_node()

template<typename T >

bool exprtk::details::is_null_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5791 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_null == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::parser< T >::expression_generator< Type >::for_loop(), exprtk::expression_helper< T >::is_null(), exprtk::parser< T >::expression_generator< Type >::is_null_present(), exprtk::expression_helper< T >::match_type_sequence(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< T >::expression_generator< Type >::repeat_until_loop(), exprtk::parser< T >::expression_generator< Type >::synthesize_null_expression(), and exprtk::parser< T >::expression_generator< Type >::while_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_operator_char()

bool exprtk::details::is_operator_char ( const char_t c )

inline

Definition at line 111 of file exprtk.hpp.

      {
         return ('+' == c) || ('-' == c) ||
                ('*' == c) || ('/' == c) ||
                ('^' == c) || ('<' == c) ||
                ('>' == c) || ('=' == c) ||
                (',' == c) || ('!' == c) ||
                ('(' == c) || (')' == c) ||
                ('[' == c) || (']' == c) ||
                ('{' == c) || ('}' == c) ||
                ('%' == c) || (':' == c) ||
                ('?' == c) || ('&' == c) ||
                ('|' == c) || (';' == c) ;
      }

Referenced by is_invalid(), and exprtk::lexer::generator::scan_token().

Here is the caller graph for this function:

◆ is_rebasevector_celem_node()

template<typename T >

bool exprtk::details::is_rebasevector_celem_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5744 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_rbveccelem == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_rebasevec_celem_node< T >::assignment_rebasevec_celem_node(), exprtk::details::assignment_rebasevec_celem_op_node< T, Operation >::assignment_rebasevec_celem_op_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_rebasevector_celem_rtc_node()

template<typename T >

bool exprtk::details::is_rebasevector_celem_rtc_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5738 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_rbveccelemrtc == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_rebasevec_celem_op_rtc_node< T, Operation >::assignment_rebasevec_celem_op_rtc_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_rebasevector_elem_node()

template<typename T >

bool exprtk::details::is_rebasevector_elem_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5726 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_rbvecelem == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_rebasevec_elem_node< T >::assignment_rebasevec_elem_node(), exprtk::details::assignment_rebasevec_elem_op_node< T, Operation >::assignment_rebasevec_elem_op_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_rebasevector_elem_rtc_node()

template<typename T >

bool exprtk::details::is_rebasevector_elem_rtc_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5732 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_rbvecelemrtc == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_rebasevec_elem_op_rtc_node< T, Operation >::assignment_rebasevec_elem_op_rtc_node(), exprtk::details::assignment_rebasevec_elem_rtc_node< T >::assignment_rebasevec_elem_rtc_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_reserved_symbol()

bool exprtk::details::is_reserved_symbol ( const std::string & symbol )

inline

Definition at line 529 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < reserved_symbols_size; ++i)
         {
            if (imatch(symbol, reserved_symbols[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References imatch(), reserved_symbols, and reserved_symbols_size.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_reserved_word()

bool exprtk::details::is_reserved_word ( const std::string & symbol )

inline

Definition at line 516 of file exprtk.hpp.

      {
         for (std::size_t i = 0; i < reserved_words_size; ++i)
         {
            if (imatch(symbol, reserved_words[i]))
            {
               return true;
            }
         }
 
         return false;
      }

References imatch(), reserved_words, and reserved_words_size.

Referenced by exprtk::parser< T >::remove_replace_symbol(), and exprtk::parser< T >::replace_symbol().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_return_node()

template<typename T >

bool exprtk::details::is_return_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5827 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_return == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_right_bracket()

bool exprtk::details::is_right_bracket ( const char_t c )

inline

Definition at line 147 of file exprtk.hpp.

      {
         return (')' == c) || (']' == c) || ('}' == c);
      }

Referenced by exprtk::lexer::helper::sequence_validator::invalid_bracket_check(), is_bracket(), and exprtk::lexer::helper::bracket_checker::operator()().

Here is the caller graph for this function:

◆ is_sf3ext_node()

template<typename T >

bool exprtk::details::is_sf3ext_node ( const expression_node< T > * n )

inlineprivate

Definition at line 17656 of file exprtk.hpp.

      {
         switch (n->type())
         {
            case expression_node<T>::e_vovov : return true;
            case expression_node<T>::e_vovoc : return true;
            case expression_node<T>::e_vocov : return true;
            case expression_node<T>::e_covov : return true;
            case expression_node<T>::e_covoc : return true;
            default                          : return false;
         }
      }

References match_impl().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_sf4ext_expression::compile_left(), exprtk::parser< T >::expression_generator< Type >::synthesize_sf4ext_expression::compile_right(), exprtk::expression_helper< T >::is_sf3ext(), exprtk::expression_helper< T >::match_type_sequence(), exprtk::parser< T >::expression_generator< Type >::synthesize_vob_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_bov_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_cob_expression::process(), and exprtk::parser< T >::expression_generator< Type >::synthesize_boc_expression::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_sf4ext_node()

template<typename T >

bool exprtk::details::is_sf4ext_node ( const expression_node< T > * n )

inlineprivate

Definition at line 17834 of file exprtk.hpp.

      {
         switch (n->type())
         {
            case expression_node<T>::e_vovovov : return true;
            case expression_node<T>::e_vovovoc : return true;
            case expression_node<T>::e_vovocov : return true;
            case expression_node<T>::e_vocovov : return true;
            case expression_node<T>::e_covovov : return true;
            case expression_node<T>::e_covocov : return true;
            case expression_node<T>::e_vocovoc : return true;
            case expression_node<T>::e_covovoc : return true;
            case expression_node<T>::e_vococov : return true;
            default                            : return false;
         }
      }

References match_impl().

Referenced by exprtk::expression_helper< T >::is_sf4ext(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_sign()

bool exprtk::details::is_sign ( const char_t c )

inline

Definition at line 157 of file exprtk.hpp.

      {
         return ('+' == c) || ('-' == c);
      }

Referenced by exprtk::lexer::generator::scan_number().

Here is the caller graph for this function:

◆ is_string_assignment_node()

template<typename T >

bool exprtk::details::is_string_assignment_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18943 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strass == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_string_ccondition_node()

template<typename T >

bool exprtk::details::is_string_ccondition_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18967 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strccondition == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_string_concat_node()

template<typename T >

bool exprtk::details::is_string_concat_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18949 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strconcat == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_string_condition_node()

template<typename T >

bool exprtk::details::is_string_condition_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18961 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strcondition == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_string_function_node()

template<typename T >

bool exprtk::details::is_string_function_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18955 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_strfunction == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_string_node()

template<typename T >

bool exprtk::details::is_string_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18919 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_stringvar == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_string_node< T, AssignmentProcess >::assignment_string_node(), branch_deletable(), exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::details::range_pack< T >::free(), free_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::details::swap_string_node< T >::swap_string_node(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_string_range_node()

template<typename T >

bool exprtk::details::is_string_range_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18925 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_stringvarrng == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_string_range_node< T, AssignmentProcess >::assignment_string_range_node(), exprtk::parser< T >::expression_generator< Type >::branch_to_id(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_string_vararg_node()

template<typename T >

bool exprtk::details::is_string_vararg_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18973 of file exprtk.hpp.

      {
         return node && (expression_node<T>::e_stringvararg == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_swap_node()

template<typename T >

bool exprtk::details::is_swap_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5809 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_swap == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Here is the call graph for this function:

◆ is_t0ot1ot2_node()

template<typename T >

bool exprtk::details::is_t0ot1ot2_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18901 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const T0oT1oT2_base_node<T>*>(node));
      }

References match_impl().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_t0ot1ot2ot3_node()

template<typename T >

bool exprtk::details::is_t0ot1ot2ot3_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18907 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const T0oT1oT2oT3_base_node<T>*>(node));
      }

References match_impl().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_true() [1/8]

bool exprtk::details::is_true ( const cmplx::complex_t & v )

inline

Definition at line 374 of file exprtk_complex_adaptor.hpp.

374{ return cmplx::is_true(v); }

cmplx::is_true

bool is_true(const complex_t v)

Definition complex_type.hpp:213

References cmplx::is_true().

Here is the call graph for this function:

◆ is_true() [2/8]

bool exprtk::details::is_true ( const double v )

inlineprivate

Definition at line 5615 of file exprtk.hpp.

      {
         return std::not_equal_to<double>()(0.0,v);
      }

Here is the caller graph for this function:

◆ is_true() [3/8]

template<typename T >

bool exprtk::details::is_true ( const expression_node< T > * node )

inlineprivate

Definition at line 5631 of file exprtk.hpp.

      {
         return std::not_equal_to<T>()(T(0),node->value());
      }

References match_impl().

Here is the call graph for this function:

◆ is_true() [4/8]

bool exprtk::details::is_true ( const float v )

inlineprivate

Definition at line 5625 of file exprtk.hpp.

      {
         return std::not_equal_to<float>()(0.0f,v);
      }

◆ is_true() [5/8]

bool exprtk::details::is_true ( const long double v )

inlineprivate

Definition at line 5620 of file exprtk.hpp.

      {
         return std::not_equal_to<long double>()(0.0L,v);
      }

◆ is_true() [6/8]

bool exprtk::details::is_true ( const mpfr::mpreal & v )

inline

Definition at line 374 of file exprtk_mpfr_adaptor.hpp.

374{ return details::numeric::details::is_true_impl (v); }

References exprtk::details::numeric::details::is_true_impl().

Here is the call graph for this function:

◆ is_true() [7/8]

bool exprtk::details::is_true ( const real::type v )

inline

Definition at line 349 of file exprtk_real_adaptor.hpp.

349{ return real::is_true(v); }

real::is_true

bool is_true(const type v)

Definition real_type.hpp:228

References real::is_true().

Here is the call graph for this function:

◆ is_true() [8/8]

template<typename T >

bool exprtk::details::is_true ( const std::pair< expression_node< T > *, bool > & node )

inlineprivate

Definition at line 5637 of file exprtk.hpp.

      {
         return std::not_equal_to<T>()(T(0),node.first->value());
      }

References match_impl().

Here is the call graph for this function:

◆ is_unary_node()

template<typename T >

bool exprtk::details::is_unary_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5661 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_unary == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by is_negate_node(), exprtk::expression_helper< T >::is_unary(), and exprtk::expression_helper< T >::match_type_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_uv_node()

template<typename T >

bool exprtk::details::is_uv_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18913 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const uv_base_node<T>*>(node));
      }

References match_impl().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_vob_expression::process(), exprtk::parser< T >::expression_generator< Type >::synthesize_bov_expression::process(), and exprtk::parser< T >::expression_generator< Type >::uvouv_optimisable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_valid_sf_symbol()

bool exprtk::details::is_valid_sf_symbol ( const std::string & symbol )

inline

Definition at line 257 of file exprtk.hpp.

      {
         // Special function: $f12 or $F34
         return (4 == symbol.size())  &&
                ('$' == symbol[0])    &&
                imatch('f',symbol[1]) &&
                is_digit(symbol[2])   &&
                is_digit(symbol[3]);
      }

References imatch(), and is_digit().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_valid_string_char()

bool exprtk::details::is_valid_string_char ( const char_t c )

inline

Definition at line 175 of file exprtk.hpp.

      {
         return std::isprint(static_cast<uchar_t>(c)) ||
                is_whitespace(c);
      }

References is_whitespace().

Referenced by exprtk::lexer::generator::scan_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_vararg_node()

template<typename T >

bool exprtk::details::is_vararg_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5821 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_vararg == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::expression_helper< T >::is_vararg().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_variable_node()

template<typename T >

bool exprtk::details::is_variable_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5679 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_variable == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_vector_celem_node()

template<typename T >

bool exprtk::details::is_vector_celem_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5708 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_veccelem == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_vector_celem_rtc_node()

template<typename T >

bool exprtk::details::is_vector_celem_rtc_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5720 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_veccelemrtc == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_vec_celem_op_rtc_node< T, Operation >::assignment_vec_celem_op_rtc_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_vector_elem_node()

template<typename T >

bool exprtk::details::is_vector_elem_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5702 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_vecelem == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_vec_elem_node< T >::assignment_vec_elem_node(), exprtk::details::assignment_vec_elem_op_node< T, Operation >::assignment_vec_elem_op_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_vector_elem_rtc_node()

template<typename T >

bool exprtk::details::is_vector_elem_rtc_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5714 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_vecelemrtc == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_vec_elem_op_rtc_node< T, Operation >::assignment_vec_elem_op_rtc_node(), exprtk::details::assignment_vec_elem_rtc_node< T >::assignment_vec_elem_rtc_node(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_vector_node()

template<typename T >

bool exprtk::details::is_vector_node ( const expression_node< T > * node )

inlineprivate

Definition at line 5750 of file exprtk.hpp.

      {
         return node && (details::expression_node<T>::e_vector == node->type());
      }

References match_impl(), and exprtk::details::expression_node< T >::type().

Referenced by exprtk::details::assignment_vec_node< T >::assignment_vec_node(), exprtk::details::assignment_vec_op_node< T, Operation >::assignment_vec_op_node(), exprtk::details::assignment_vecvec_node< T >::assignment_vecvec_node(), exprtk::details::assignment_vecvec_op_node< T, Operation >::assignment_vecvec_op_node(), exprtk::parser< T >::expression_generator< Type >::is_constpow_operation(), exprtk::parser< T >::expression_generator< Type >::is_invalid_assignment_op(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_assignment_operation_expression(), exprtk::details::unary_vector_node< T, Operation >::unary_vector_node(), exprtk::details::vec_binop_valvec_node< T, Operation >::vec_binop_valvec_node(), exprtk::details::vec_binop_vecval_node< T, Operation >::vec_binop_vecval_node(), exprtk::details::vec_binop_vecvec_node< T, Operation >::vec_binop_vecvec_node(), and exprtk::parser< T >::expression_generator< Type >::vector_element().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_voc_node()

template<typename T >

bool exprtk::details::is_voc_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18883 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const voc_base_node<T>*>(node));
      }

References match_impl().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_vov_node()

template<typename T >

bool exprtk::details::is_vov_node ( const expression_node< T > * node )

inlineprivate

Definition at line 18871 of file exprtk.hpp.

      {
         return (0 != dynamic_cast<const vov_base_node<T>*>(node));
      }

References match_impl().

Referenced by exprtk::parser< T >::expression_generator< Type >::branch_to_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_whitespace()

bool exprtk::details::is_whitespace ( const char_t c )

inline

Definition at line 103 of file exprtk.hpp.

      {
         return (' '  == c) || ('\n' == c) ||
                ('\r' == c) || ('\t' == c) ||
                ('\b' == c) || ('\v' == c) ||
                ('\f' == c) ;
      }

Referenced by exprtk::parser< T >::construct_subexpr(), is_invalid(), is_valid_string_char(), exprtk::lexer::generator::scan_token(), and exprtk::lexer::generator::skip_whitespace().

Here is the caller graph for this function:

◆ load_operations_map()

void exprtk::details::load_operations_map ( std::multimap< std::string, details::base_operation_t, details::ilesscompare > & m )

inlineprivate

Definition at line 19395 of file exprtk.hpp.

      {
         #define register_op(Symbol, Type, Args)                                             \
         m.insert(std::make_pair(std::string(Symbol),details::base_operation_t(Type,Args))); \
 
         register_op("abs"       , e_abs     , 1)
         register_op("acos"      , e_acos    , 1)
         register_op("acosh"     , e_acosh   , 1)
         register_op("asin"      , e_asin    , 1)
         register_op("asinh"     , e_asinh   , 1)
         register_op("atan"      , e_atan    , 1)
         register_op("atanh"     , e_atanh   , 1)
         register_op("ceil"      , e_ceil    , 1)
         register_op("cos"       , e_cos     , 1)
         register_op("cosh"      , e_cosh    , 1)
         register_op("exp"       , e_exp     , 1)
         register_op("expm1"     , e_expm1   , 1)
         register_op("floor"     , e_floor   , 1)
         register_op("log"       , e_log     , 1)
         register_op("log10"     , e_log10   , 1)
         register_op("log2"      , e_log2    , 1)
         register_op("log1p"     , e_log1p   , 1)
         register_op("round"     , e_round   , 1)
         register_op("sin"       , e_sin     , 1)
         register_op("sinc"      , e_sinc    , 1)
         register_op("sinh"      , e_sinh    , 1)
         register_op("sec"       , e_sec     , 1)
         register_op("csc"       , e_csc     , 1)
         register_op("sqrt"      , e_sqrt    , 1)
         register_op("tan"       , e_tan     , 1)
         register_op("tanh"      , e_tanh    , 1)
         register_op("cot"       , e_cot     , 1)
         register_op("rad2deg"   , e_r2d     , 1)
         register_op("deg2rad"   , e_d2r     , 1)
         register_op("deg2grad"  , e_d2g     , 1)
         register_op("grad2deg"  , e_g2d     , 1)
         register_op("sgn"       , e_sgn     , 1)
         register_op("not"       , e_notl    , 1)
         register_op("erf"       , e_erf     , 1)
         register_op("erfc"      , e_erfc    , 1)
         register_op("ncdf"      , e_ncdf    , 1)
         register_op("frac"      , e_frac    , 1)
         register_op("trunc"     , e_trunc   , 1)
         register_op("atan2"     , e_atan2   , 2)
         register_op("mod"       , e_mod     , 2)
         register_op("logn"      , e_logn    , 2)
         register_op("pow"       , e_pow     , 2)
         register_op("root"      , e_root    , 2)
         register_op("roundn"    , e_roundn  , 2)
         register_op("equal"     , e_equal   , 2)
         register_op("not_equal" , e_nequal  , 2)
         register_op("hypot"     , e_hypot   , 2)
         register_op("shr"       , e_shr     , 2)
         register_op("shl"       , e_shl     , 2)
         register_op("clamp"     , e_clamp   , 3)
         register_op("iclamp"    , e_iclamp  , 3)
         register_op("inrange"   , e_inrange , 3)
         #undef register_op
      }

References e_abs, e_acos, e_acosh, e_asin, e_asinh, e_atan, e_atan2, e_atanh, e_ceil, e_clamp, e_cos, e_cosh, e_cot, e_csc, e_d2g, e_d2r, e_equal, e_erf, e_erfc, e_exp, e_expm1, e_floor, e_frac, e_g2d, e_hypot, e_iclamp, e_inrange, e_log, e_log10, e_log1p, e_log2, e_logn, e_mod, e_ncdf, e_nequal, e_notl, e_pow, e_r2d, e_root, e_round, e_roundn, e_sec, e_sgn, e_shl, e_shr, e_sin, e_sinc, e_sinh, e_sqrt, e_tan, e_tanh, e_trunc, and register_op.

◆ make_memory_context() [1/2]

template<typename T >

memory_context_t< T > exprtk::details::make_memory_context	(	vector_holder< T > &	vec_holder,
		vec_data_store< T > &	vds
	)

inlineprivate

Definition at line 13470 of file exprtk.hpp.

      {
         memory_context_t<T> result_ctxt;
         result_ctxt.temp_  = (vec_holder.rebaseable()) ?
                              new vector_holder<T>(vec_holder,vds) :
                              new vector_holder<T>(vds) ;
         result_ctxt.temp_vec_node_ = new vector_node  <T>(vds,result_ctxt.temp_);
         return result_ctxt;
      }

References match_impl(), exprtk::details::vector_holder< Type >::rebaseable(), and exprtk::details::memory_context_t< T >::temp_.

Referenced by exprtk::details::conditional_vector_node< T >::conditional_vector_node(), exprtk::details::unary_vector_node< T, Operation >::unary_vector_node(), exprtk::details::vec_binop_valvec_node< T, Operation >::vec_binop_valvec_node(), exprtk::details::vec_binop_vecval_node< T, Operation >::vec_binop_vecval_node(), and exprtk::details::vec_binop_vecvec_node< T, Operation >::vec_binop_vecvec_node().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_memory_context() [2/2]

template<typename T >

memory_context_t< T > exprtk::details::make_memory_context	(	vector_holder< T > &	vec_holder0,
		vector_holder< T > &	vec_holder1,
		vec_data_store< T > &	vds
	)

inlineprivate

Definition at line 13482 of file exprtk.hpp.

      {
         memory_context_t<T> result_ctxt;
 
         if (!vec_holder0.rebaseable() && !vec_holder1.rebaseable())
            result_ctxt.temp_ = new vector_holder<T>(vds);
         else if (vec_holder0.rebaseable() && !vec_holder1.rebaseable())
            result_ctxt.temp_ = new vector_holder<T>(vec_holder0,vds);
         else if (!vec_holder0.rebaseable() && vec_holder1.rebaseable())
            result_ctxt.temp_ = new vector_holder<T>(vec_holder1,vds);
         else
         {
            result_ctxt.temp_ = (vec_holder0.base_size() >= vec_holder1.base_size()) ?
                                new vector_holder<T>(vec_holder0, vds) :
                                new vector_holder<T>(vec_holder1, vds) ;
         }
 
         result_ctxt.temp_vec_node_ = new vector_node <T>(vds,result_ctxt.temp_);
         return result_ctxt;
      }

References match_impl(), and exprtk::details::memory_context_t< T >::temp_.

Here is the call graph for this function:

◆ match_impl()

template<typename Iterator , typename Compare >

bool exprtk::details::match_impl	(	const Iterator	pattern_begin,
		const Iterator	pattern_end,
		const Iterator	data_begin,
		const Iterator	data_end,
		const typename std::iterator_traits< Iterator >::value_type &	zero_or_more,
		const typename std::iterator_traits< Iterator >::value_type &	exactly_one
	)

inline

Definition at line 598 of file exprtk.hpp.

      {
         typedef typename std::iterator_traits<Iterator>::value_type type;
 
         const Iterator null_itr(0);
 
         Iterator p_itr  = pattern_begin;
         Iterator d_itr  = data_begin;
         Iterator np_itr = null_itr;
         Iterator nd_itr = null_itr;
 
         for ( ; ; )
         {
            if (p_itr != pattern_end)
            {
               const type c = *(p_itr);
 
               if ((data_end != d_itr) && (Compare::cmp(c,*(d_itr)) || (exactly_one == c)))
               {
                  ++d_itr;
                  ++p_itr;
                  continue;
               }
               else if (zero_or_more == c)
               {
                  while ((pattern_end != p_itr) && (zero_or_more == *(p_itr)))
                  {
                     ++p_itr;
                  }
 
                  const type d = *(p_itr);
 
                  while ((data_end != d_itr) && !(Compare::cmp(d,*(d_itr)) || (exactly_one == d)))
                  {
                     ++d_itr;
                  }
 
                  // set backtrack iterators
                  np_itr = p_itr - 1;
                  nd_itr = d_itr + 1;
 
                  continue;
               }
            }
            else if (data_end == d_itr)
               break;
 
            if ((data_end == d_itr) || (null_itr == nd_itr))
                return false;
 
            p_itr = np_itr;
            d_itr = nd_itr;
         }
 
         return true;
      }

Here is the caller graph for this function:

◆ parse_hex()

template<typename Iterator >

bool exprtk::details::parse_hex	(	Iterator &	itr,
		Iterator	end,
		char_t &	result
	)

inline

Definition at line 322 of file exprtk.hpp.

      {
         if (
              (end ==  (itr    ))               ||
              (end ==  (itr + 1))               ||
              (end ==  (itr + 2))               ||
              (end ==  (itr + 3))               ||
              ('0' != *(itr    ))               ||
              ('X' != std::toupper(*(itr + 1))) ||
              (!is_hex_digit(*(itr + 2)))       ||
              (!is_hex_digit(*(itr + 3)))
            )
         {
            return false;
         }
 
         result = hex_to_bin(static_cast<uchar_t>(*(itr + 2))) << 4 |
                  hex_to_bin(static_cast<uchar_t>(*(itr + 3))) ;
 
         return true;
      }

References hex_to_bin(), and is_hex_digit().

Referenced by cleanup_escapes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_inf()

template<typename Iterator , typename T >

static bool exprtk::details::parse_inf	(	Iterator &	itr,
		const Iterator	end,
		T &	t,
		const bool	negative
	)

inlinestatic

Definition at line 1891 of file exprtk.hpp.

      {
         static const char_t inf_uc[] = "INFINITY";
         static const char_t inf_lc[] = "infinity";
         static const std::size_t inf_length = 8;
 
         const std::size_t length = static_cast<std::size_t>(std::distance(itr,end));
 
         if ((3 != length) && (inf_length != length))
            return false;
 
         char_cptr inf_itr = ('i' == (*itr)) ? inf_lc : inf_uc;
 
         while (end != itr)
         {
            if (*inf_itr == static_cast<char_t>(*itr))
            {
               ++itr;
               ++inf_itr;
               continue;
            }
            else
               return false;
         }
 
         if (negative)
            t = -std::numeric_limits<T>::infinity();
         else
            t =  std::numeric_limits<T>::infinity();
 
         return true;
      }

References match_impl().

Referenced by string_to_real().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_nan()

template<typename Iterator , typename T >

static bool exprtk::details::parse_nan	(	Iterator &	itr,
		const Iterator	end,
		T &	t
	)

inlinestatic

Definition at line 1858 of file exprtk.hpp.

      {
         typedef typename std::iterator_traits<Iterator>::value_type type;
 
         static const std::size_t nan_length = 3;
 
         if (std::distance(itr,end) != static_cast<int>(nan_length))
            return false;
 
         if (static_cast<type>('n') == (*itr))
         {
            if (
                 (static_cast<type>('a') != *(itr + 1)) ||
                 (static_cast<type>('n') != *(itr + 2))
               )
            {
               return false;
            }
         }
         else if (
                   (static_cast<type>('A') != *(itr + 1)) ||
                   (static_cast<type>('N') != *(itr + 2))
                 )
         {
            return false;
         }
 
         t = std::numeric_limits<T>::quiet_NaN();
 
         return true;
      }

References match_impl().

Referenced by string_to_real().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sequence_match()

bool exprtk::details::sequence_match	(	const std::string &	pattern,
		const std::string &	str,
		std::size_t &	diff_index,
		char_t &	diff_value
	)

inline

Definition at line 686 of file exprtk.hpp.

      {
         if (str.empty())
         {
            return ("Z" == pattern);
         }
         else if ('*' == pattern[0])
            return false;
 
         typedef std::string::const_iterator itr_t;
 
         itr_t p_itr = pattern.begin();
         itr_t s_itr = str    .begin();
 
         const itr_t p_end = pattern.end();
         const itr_t s_end = str    .end();
 
         while ((s_end != s_itr) && (p_end != p_itr))
         {
            if ('*' == (*p_itr))
            {
               const char_t target = static_cast<char_t>(std::toupper(*(p_itr - 1)));
 
               if ('*' == target)
               {
                  diff_index = static_cast<std::size_t>(std::distance(str.begin(),s_itr));
                  diff_value = static_cast<char_t>(std::toupper(*p_itr));
 
                  return false;
               }
               else
                  ++p_itr;
 
               while (s_itr != s_end)
               {
                  if (target != std::toupper(*s_itr))
                     break;
                  else
                     ++s_itr;
               }
 
               continue;
            }
            else if (
                      ('?' != *p_itr) &&
                      std::toupper(*p_itr) != std::toupper(*s_itr)
                    )
            {
               diff_index = static_cast<std::size_t>(std::distance(str.begin(),s_itr));
               diff_value = static_cast<char_t>(std::toupper(*p_itr));
 
               return false;
            }
 
            ++p_itr;
            ++s_itr;
         }
 
         return (
                  (s_end == s_itr) &&
                  (
                    (p_end ==  p_itr) ||
                    ('*'   == *p_itr)
                  )
                );
      }

References match_impl().

Referenced by exprtk::parser< T >::type_checker::verify().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_zero_value() [1/2]

template<typename T >

void exprtk::details::set_zero_value ( std::vector< T > & v )

inline

Definition at line 792 of file exprtk.hpp.

      {
         set_zero_value(v.data(),v.size());
      }

References set_zero_value().

Here is the call graph for this function:

◆ set_zero_value() [2/2]

template<typename T >

void exprtk::details::set_zero_value	(	T *	data,
		const std::size_t	size
	)

inline

Definition at line 786 of file exprtk.hpp.

      {
         set_zero_value_impl<T>::process(data,size);
      }

References exprtk::details::set_zero_value_impl< T >::process().

Referenced by exprtk::parser< T >::parse_define_vector_statement(), set_zero_value(), exprtk::details::vector_initialisation_node< T >::value(), and exprtk::details::vector_init_zero_value_node< T >::value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ string_to_real() [1/5]

template<typename T >

bool exprtk::details::string_to_real	(	const std::string &	s,
		T &	t
	)

inline

Definition at line 2090 of file exprtk.hpp.

      {
         const typename numeric::details::number_type<T>::type num_type;
 
         char_cptr begin = s.data();
         char_cptr end   = s.data() + s.size();
 
         return string_to_real(begin, end, t, num_type);
      }

References string_to_real().

Here is the call graph for this function:

◆ string_to_real() [2/5]

template<typename Iterator >

bool exprtk::details::string_to_real	(	Iterator &	itr_external,
		const Iterator	end,
		cmplx::complex_t &	t,
		details::numeric::details::complex_type_tag
	)

inline

Definition at line 363 of file exprtk_complex_adaptor.hpp.

      {
         typename numeric::details::number_type<double>::type num_type;
         double real_component;
         const bool result = string_to_real<Iterator,double>(itr_external,end,real_component,num_type);
         t.c_.real(real_component);
         return result;
      }

References cmplx::complex_t::c_, and match_impl().

Here is the call graph for this function:

◆ string_to_real() [3/5]

template<typename Iterator >

bool exprtk::details::string_to_real	(	Iterator &	itr_external,
		const Iterator	end,
		mpfr::mpreal &	t,
		numeric::details::mpfrreal_type_tag
	)

inline

Definition at line 368 of file exprtk_mpfr_adaptor.hpp.

      {
         t = mpfr::mpreal(std::string(itr_external,end));
         return true;
      }

References match_impl().

Here is the call graph for this function:

◆ string_to_real() [4/5]

template<typename Iterator >

bool exprtk::details::string_to_real	(	Iterator &	itr_external,
		const Iterator	end,
		real::type &	t,
		details::numeric::details::my_real_type_tag
	)

inline

Definition at line 343 of file exprtk_real_adaptor.hpp.

      {
         typename numeric::details::number_type<double>::type num_type;
         return string_to_real<Iterator,double>(itr_external,end,t.d_,num_type);
      }

References real::type::d_, and match_impl().

Here is the call graph for this function:

◆ string_to_real() [5/5]

template<typename Iterator , typename T >

bool exprtk::details::string_to_real	(	Iterator &	itr_external,
		const Iterator	end,
		T &	t,
		numeric::details::real_type_tag
	)

inline

Definition at line 1932 of file exprtk.hpp.

      {
         if (end == itr_external) return false;
 
         Iterator itr = itr_external;
 
         T d = T(0);
 
         const bool negative = ('-' == (*itr));
 
         if (negative || '+' == (*itr))
         {
            if (end == ++itr)
               return false;
         }
 
         bool instate = false;
 
         static const char_t zero = static_cast<uchar_t>('0');
 
         #define parse_digit_1(d)          \
         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else                              \
            { break; }                     \
         if (end == ++itr) break;          \
 
         #define parse_digit_2(d)          \
         if ((digit = (*itr - zero)) < 10) \
            { d = d * T(10) + digit; }     \
         else                              \
            { break; }                     \
            ++itr;                         \
 
         if ('.' != (*itr))
         {
            const Iterator curr = itr;
 
            while ((end != itr) && (zero == (*itr))) ++itr;
 
            while (end != itr)
            {
               unsigned int digit;
               parse_digit_1(d)
               parse_digit_1(d)
               parse_digit_2(d)
            }
 
            if (curr != itr) instate = true;
         }
 
         int exponent = 0;
 
         if (end != itr)
         {
            if ('.' == (*itr))
            {
               const Iterator curr = ++itr;
               T tmp_d = T(0);
 
               while (end != itr)
               {
                  unsigned int digit;
                  parse_digit_1(tmp_d)
                  parse_digit_1(tmp_d)
                  parse_digit_2(tmp_d)
               }
 
               if (curr != itr)
               {
                  instate = true;
 
                  const int frac_exponent = static_cast<int>(-std::distance(curr, itr));
 
                  if (!valid_exponent<T>(frac_exponent, numeric::details::real_type_tag()))
                     return false;
 
                  d += compute_pow10(tmp_d, frac_exponent);
               }
 
               #undef parse_digit_1
               #undef parse_digit_2
            }
 
            if (end != itr)
            {
               typename std::iterator_traits<Iterator>::value_type c = (*itr);
 
               if (('e' == c) || ('E' == c))
               {
                  int exp = 0;
 
                  if (!details::string_to_type_converter_impl_ref(++itr, end, exp))
                  {
                     if (end == itr)
                        return false;
                     else
                        c = (*itr);
                  }
 
                  exponent += exp;
               }
 
               if (end != itr)
               {
                  if (('f' == c) || ('F' == c) || ('l' == c) || ('L' == c))
                     ++itr;
                  else if ('#' == c)
                  {
                     if (end == ++itr)
                        return false;
                     else if (('I' <= (*itr)) && ((*itr) <= 'n'))
                     {
                        if (('i' == (*itr)) || ('I' == (*itr)))
                        {
                           return parse_inf(itr, end, t, negative);
                        }
                        else if (('n' == (*itr)) || ('N' == (*itr)))
                        {
                           return parse_nan(itr, end, t);
                        }
                        else
                           return false;
                     }
                     else
                        return false;
                  }
                  else if (('I' <= (*itr)) && ((*itr) <= 'n'))
                  {
                     if (('i' == (*itr)) || ('I' == (*itr)))
                     {
                        return parse_inf(itr, end, t, negative);
                     }
                     else if (('n' == (*itr)) || ('N' == (*itr)))
                     {
                        return parse_nan(itr, end, t);
                     }
                     else
                        return false;
                  }
                  else
                     return false;
               }
            }
         }
 
         if ((end != itr) || (!instate))
            return false;
         else if (!valid_exponent<T>(exponent, numeric::details::real_type_tag()))
            return false;
         else if (exponent)
            d = compute_pow10(d,exponent);
 
         t = static_cast<T>((negative) ? -d : d);
         return true;
      }

References compute_pow10(), match_impl(), parse_digit_1, parse_digit_2, parse_inf(), parse_nan(), and string_to_type_converter_impl_ref().

Referenced by exprtk::lexer::helper::numeric_checker< T >::operator()(), exprtk::parser< T >::parse_branch(), and string_to_real().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ string_to_type_converter_impl_ref()

template<typename Iterator , typename T >

bool exprtk::details::string_to_type_converter_impl_ref	(	Iterator &	itr,
		const Iterator	end,
		T &	result
	)

inline

Definition at line 1781 of file exprtk.hpp.

      {
         if (itr == end)
            return false;
 
         const bool negative = ('-' == (*itr));
 
         if (negative || ('+' == (*itr)))
         {
            if (end == ++itr)
               return false;
         }
 
         static const uchar_t zero = static_cast<uchar_t>('0');
 
         while ((end != itr) && (zero == (*itr))) ++itr;
 
         bool return_result = true;
         unsigned int digit = 0;
         const std::size_t length = static_cast<std::size_t>(std::distance(itr,end));
 
         if (length <= 4)
         {
            switch (length)
            {
               #ifdef exprtk_use_lut
 
               #define exprtk_process_digit                          \
               if ((digit = details::digit_table[(int)*itr++]) < 10) \
                  result = result * 10 + (digit);                    \
               else                                                  \
               {                                                     \
                  return_result = false;                             \
                  break;                                             \
               }                                                     \
               exprtk_fallthrough                                    \
 
               #else
 
               #define exprtk_process_digit        \
               if ((digit = (*itr++ - zero)) < 10) \
                  result = result * T(10) + digit; \
               else                                \
               {                                   \
                  return_result = false;           \
                  break;                           \
               }                                   \
               exprtk_fallthrough                  \
 
               #endif
 
               case 4 : exprtk_process_digit
               case 3 : exprtk_process_digit
               case 2 : exprtk_process_digit
               case 1 : if ((digit = (*itr - zero))>= 10)
                        {
                           digit = 0;
                           return_result = false;
                        }
 
               #undef exprtk_process_digit
            }
         }
         else
            return_result = false;
 
         if (length && return_result)
         {
            result = result * 10 + static_cast<T>(digit);
            ++itr;
         }
 
         result = negative ? -result : result;
         return return_result;
      }

References exprtk_process_digit, and match_impl().

Referenced by string_to_real().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_str() [1/3]

std::string exprtk::details::to_str ( const operator_type opr )

inlineprivate

Definition at line 5068 of file exprtk.hpp.

      {
         switch (opr)
         {
            case e_add    : return  "+"  ;
            case e_sub    : return  "-"  ;
            case e_mul    : return  "*"  ;
            case e_div    : return  "/"  ;
            case e_mod    : return  "%"  ;
            case e_pow    : return  "^"  ;
            case e_assign : return ":="  ;
            case e_addass : return "+="  ;
            case e_subass : return "-="  ;
            case e_mulass : return "*="  ;
            case e_divass : return "/="  ;
            case e_modass : return "%="  ;
            case e_lt     : return  "<"  ;
            case e_lte    : return "<="  ;
            case e_eq     : return "=="  ;
            case e_equal  : return  "="  ;
            case e_ne     : return "!="  ;
            case e_nequal : return "<>"  ;
            case e_gte    : return ">="  ;
            case e_gt     : return  ">"  ;
            case e_and    : return "and" ;
            case e_or     : return "or"  ;
            case e_xor    : return "xor" ;
            case e_nand   : return "nand";
            case e_nor    : return "nor" ;
            case e_xnor   : return "xnor";
            default       : return "N/A" ;
         }
      }

References e_add, e_addass, e_and, e_assign, e_div, e_divass, e_eq, e_equal, e_gt, e_gte, e_lt, e_lte, e_mod, e_modass, e_mul, e_mulass, e_nand, e_ne, e_nequal, e_nor, e_or, e_pow, e_sub, e_subass, e_xnor, e_xor, and match_impl().

Here is the call graph for this function:

◆ to_str() [2/3]

std::string exprtk::details::to_str ( int i )

inline

Definition at line 277 of file exprtk.hpp.

      {
         if (0 == i)
            return std::string("0");
 
         std::string result;
 
         const int sign = (i < 0) ? -1 : 1;
 
         for ( ; i; i /= 10)
         {
            result += '0' + static_cast<char_t>(sign * (i % 10));
         }
 
         if (sign < 0)
         {
            result += '-';
         }
 
         std::reverse(result.begin(), result.end());
 
         return result;
      }

Here is the caller graph for this function:

◆ to_str() [3/3]

std::string exprtk::details::to_str ( std::size_t i )

inline

Definition at line 301 of file exprtk.hpp.

      {
         return to_str(static_cast<int>(i));
      }

References to_str().

Here is the call graph for this function:

◆ valid_exponent()

template<typename T >

bool exprtk::details::valid_exponent	(	const int	exponent,
		numeric::details::real_type_tag
	)

inline

Definition at line 1925 of file exprtk.hpp.

      {
         using namespace details::numeric;
         return (numeric_info<T>::min_exp <= exponent) && (exponent <= numeric_info<T>::max_exp);
      }

References match_impl().

Here is the call graph for this function:

◆ value() [1/4]

template<typename T >

T exprtk::details::value ( const T & t )

inlineprivate

Definition at line 15767 of file exprtk.hpp.

      {
         return t;
      }

◆ value() [2/4]

template<typename T >

T exprtk::details::value ( const T * t )

inlineprivate

Definition at line 15761 of file exprtk.hpp.

      {
         return (*t);
      }

◆ value() [3/4]

template<typename T >

T exprtk::details::value ( details::expression_node< T > * n )

inlineprivate

Definition at line 15749 of file exprtk.hpp.

      {
         return n->value();
      }

References match_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ value() [4/4]

template<typename T >

T exprtk::details::value ( std::pair< details::expression_node< T > *, bool > n )

inlineprivate

Definition at line 15755 of file exprtk.hpp.

      {
         return n.first->value();
      }

References match_impl().

Here is the call graph for this function:

◆ wc_imatch()

bool exprtk::details::wc_imatch	(	const std::string &	wild_card,
		const std::string &	str
	)

inline

Definition at line 673 of file exprtk.hpp.

      {
         return match_impl<char_cptr,cis_match>
                (
                   wild_card.data(),
                   wild_card.data() + wild_card.size(),
                   str.data(),
                   str.data() + str.size(),
                   '*', '?'
                );
      }

References match_impl().

Referenced by exprtk::details::ilike_op< T >::process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wc_match()

bool exprtk::details::wc_match	(	const std::string &	wild_card,
		const std::string &	str
	)

inline

Definition at line 660 of file exprtk.hpp.

      {
         return match_impl<char_cptr,cs_match>
                (
                   wild_card.data(),
                   wild_card.data() + wild_card.size(),
                   str.data(),
                   str.data() + str.size(),
                   '*', '?'
                );
      }

References match_impl().

Referenced by exprtk::details::like_op< T >::process().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ arithmetic_ops_list

const std::string exprtk::details::arithmetic_ops_list[]

static

Initial value:

=
      {
         "+", "-", "*", "/", "%", "^"
      }

Definition at line 492 of file exprtk.hpp.

      {
         "+", "-", "*", "/", "%", "^"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_arithmetic_ops(), exprtk::parser< T >::settings_store::disable_arithmetic_operation(), and exprtk::parser< T >::settings_store::enable_arithmetic_operation().

◆ arithmetic_ops_list_size

const std::size_t exprtk::details::arithmetic_ops_list_size = sizeof(arithmetic_ops_list) / sizeof(std::string)

static

Definition at line 497 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_arithmetic_ops(), exprtk::parser< T >::settings_store::disable_arithmetic_operation(), and exprtk::parser< T >::settings_store::enable_arithmetic_operation().

◆ assignment_ops_list

const std::string exprtk::details::assignment_ops_list[]

static

Initial value:

=
      {
         ":=", "+=", "-=",
         "*=", "/=", "%="
      }

Definition at line 499 of file exprtk.hpp.

      {
         ":=", "+=", "-=",
         "*=", "/=", "%="
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_assignment_ops(), exprtk::parser< T >::settings_store::disable_assignment_operation(), and exprtk::parser< T >::settings_store::enable_assignment_operation().

◆ assignment_ops_list_size

const std::size_t exprtk::details::assignment_ops_list_size = sizeof(assignment_ops_list) / sizeof(std::string)

static

Definition at line 505 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_assignment_ops(), exprtk::parser< T >::settings_store::disable_assignment_operation(), and exprtk::parser< T >::settings_store::enable_assignment_operation().

◆ base_function_list

const std::string exprtk::details::base_function_list[]

static

Initial value:

=
      {
         "abs", "acos",  "acosh", "asin",  "asinh", "atan",  "atanh",
         "atan2",  "avg",  "ceil",  "clamp",  "cos",  "cosh",  "cot",
         "csc",  "equal",  "erf",  "erfc",  "exp",  "expm1", "floor",
         "frac", "hypot", "iclamp",  "like", "log", "log10",  "log2",
         "logn", "log1p", "mand", "max", "min", "mod", "mor",  "mul",
         "ncdf",  "pow",  "root",  "round",  "roundn",  "sec", "sgn",
         "sin", "sinc", "sinh", "sqrt", "sum", "swap", "tan", "tanh",
         "trunc",  "not_equal",  "inrange",  "deg2grad",   "deg2rad",
         "rad2deg", "grad2deg"
      }

Definition at line 463 of file exprtk.hpp.

      {
         "abs", "acos",  "acosh", "asin",  "asinh", "atan",  "atanh",
         "atan2",  "avg",  "ceil",  "clamp",  "cos",  "cosh",  "cot",
         "csc",  "equal",  "erf",  "erfc",  "exp",  "expm1", "floor",
         "frac", "hypot", "iclamp",  "like", "log", "log10",  "log2",
         "logn", "log1p", "mand", "max", "min", "mod", "mor",  "mul",
         "ncdf",  "pow",  "root",  "round",  "roundn",  "sec", "sgn",
         "sin", "sinc", "sinh", "sqrt", "sum", "swap", "tan", "tanh",
         "trunc",  "not_equal",  "inrange",  "deg2grad",   "deg2rad",
         "rad2deg", "grad2deg"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_base_functions(), exprtk::parser< T >::settings_store::disable_base_function(), exprtk::parser< T >::settings_store::enable_base_function(), and is_base_function().

◆ base_function_list_size

const std::size_t exprtk::details::base_function_list_size = sizeof(base_function_list) / sizeof(std::string)

static

Definition at line 476 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_base_functions(), exprtk::parser< T >::settings_store::disable_base_function(), exprtk::parser< T >::settings_store::enable_base_function(), and is_base_function().

◆ cntrl_struct_list

const std::string exprtk::details::cntrl_struct_list[]

static

Initial value:

=
      {
         "if", "switch", "for", "while", "repeat", "return"
      }

Definition at line 485 of file exprtk.hpp.

      {
         "if", "switch", "for", "while", "repeat", "return"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_control_structures(), exprtk::parser< T >::settings_store::disable_control_structure(), exprtk::parser< T >::settings_store::enable_control_structure(), and is_control_struct().

◆ cntrl_struct_list_size

const std::size_t exprtk::details::cntrl_struct_list_size = sizeof(cntrl_struct_list) / sizeof(std::string)

static

Definition at line 490 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_control_structures(), exprtk::parser< T >::settings_store::disable_control_structure(), exprtk::parser< T >::settings_store::enable_control_structure(), and is_control_struct().

◆ inequality_ops_list

const std::string exprtk::details::inequality_ops_list[]

static

Initial value:

=
      {
         "<",  "<=", "==",
         "=",  "!=", "<>",
         ">=",  ">"
      }

Definition at line 507 of file exprtk.hpp.

      {
         "<",  "<=", "==",
         "=",  "!=", "<>",
         ">=",  ">"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_inequality_ops(), exprtk::parser< T >::settings_store::disable_inequality_operation(), and exprtk::parser< T >::settings_store::enable_inequality_operation().

◆ inequality_ops_list_size

const std::size_t exprtk::details::inequality_ops_list_size = sizeof(inequality_ops_list) / sizeof(std::string)

static

Definition at line 514 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_inequality_ops(), exprtk::parser< T >::settings_store::disable_inequality_operation(), and exprtk::parser< T >::settings_store::enable_inequality_operation().

◆ logic_ops_list

const std::string exprtk::details::logic_ops_list[]

static

Initial value:

=
      {
         "and", "nand", "nor", "not", "or",  "xnor", "xor", "&", "|"
      }

Definition at line 478 of file exprtk.hpp.

      {
         "and", "nand", "nor", "not", "or",  "xnor", "xor", "&", "|"
      };

Referenced by exprtk::parser< T >::settings_store::disable_all_logic_ops(), exprtk::parser< T >::settings_store::disable_logic_operation(), exprtk::parser< T >::settings_store::enable_logic_operation(), and is_logic_opr().

◆ logic_ops_list_size

const std::size_t exprtk::details::logic_ops_list_size = sizeof(logic_ops_list) / sizeof(std::string)

static

Definition at line 483 of file exprtk.hpp.

Referenced by exprtk::parser< T >::settings_store::disable_all_logic_ops(), exprtk::parser< T >::settings_store::disable_logic_operation(), exprtk::parser< T >::settings_store::enable_logic_operation(), and is_logic_opr().

◆ pow10

const double exprtk::details::pow10[]

static

Initial value:

=
      {
         1.0,
         1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004,
         1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008,
         1.0E+009, 1.0E+010, 1.0E+011, 1.0E+012,
         1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016
      }

Definition at line 797 of file exprtk.hpp.

      {
         1.0,
         1.0E+001, 1.0E+002, 1.0E+003, 1.0E+004,
         1.0E+005, 1.0E+006, 1.0E+007, 1.0E+008,
         1.0E+009, 1.0E+010, 1.0E+011, 1.0E+012,
         1.0E+013, 1.0E+014, 1.0E+015, 1.0E+016
      };

Referenced by exprtk::details::numeric::details::roundn_impl(), exprtk::details::numeric::details::roundn_impl(), and exprtk::details::numeric::details::roundn_impl().

◆ pow10_size

const std::size_t exprtk::details::pow10_size = sizeof(pow10) / sizeof(double)

static

Definition at line 806 of file exprtk.hpp.

Referenced by exprtk::details::numeric::details::roundn_impl(), exprtk::details::numeric::details::roundn_impl(), and exprtk::details::numeric::details::roundn_impl().

◆ reserved_symbols

const std::string exprtk::details::reserved_symbols[]

static

Initial value:

=
      {
         "abs", "acos",  "acosh", "and",  "asin", "asinh",  "assert",
         "atan", "atanh",  "atan2", "avg",  "break", "case",  "ceil",
         "clamp", "continue", "const",  "cos", "cosh", "cot",  "csc",
         "default",  "deg2grad", "deg2rad",  "equal", "erf",  "erfc",
         "exp", "expm1", "false", "floor", "for", "frac", "grad2deg",
         "hypot", "iclamp", "if",  "else", "ilike", "in",  "inrange",
         "like",  "log",  "log10", "log2",  "logn",  "log1p", "mand",
         "max", "min",  "mod", "mor",  "mul", "ncdf",  "nand", "nor",
         "not",   "not_equal",   "null",   "or",   "pow",  "rad2deg",
         "repeat", "return", "root", "round", "roundn", "sec", "sgn",
         "shl", "shr", "sin", "sinc", "sinh", "sqrt", "sum",  "swap",
         "switch", "tan",  "tanh", "true",  "trunc", "until",  "var",
         "while", "xnor", "xor", "&", "|"
      }

Definition at line 444 of file exprtk.hpp.

      {
         "abs", "acos",  "acosh", "and",  "asin", "asinh",  "assert",
         "atan", "atanh",  "atan2", "avg",  "break", "case",  "ceil",
         "clamp", "continue", "const",  "cos", "cosh", "cot",  "csc",
         "default",  "deg2grad", "deg2rad",  "equal", "erf",  "erfc",
         "exp", "expm1", "false", "floor", "for", "frac", "grad2deg",
         "hypot", "iclamp", "if",  "else", "ilike", "in",  "inrange",
         "like",  "log",  "log10", "log2",  "logn",  "log1p", "mand",
         "max", "min",  "mod", "mor",  "mul", "ncdf",  "nand", "nor",
         "not",   "not_equal",   "null",   "or",   "pow",  "rad2deg",
         "repeat", "return", "root", "round", "roundn", "sec", "sgn",
         "shl", "shr", "sin", "sinc", "sinh", "sqrt", "sum",  "swap",
         "switch", "tan",  "tanh", "true",  "trunc", "until",  "var",
         "while", "xnor", "xor", "&", "|"
      };

Referenced by exprtk::symbol_table< T >::type_store< Type, RawType >::add_impl(), is_reserved_symbol(), and exprtk::symbol_table< T >::control_block::st_data::st_data().

◆ reserved_symbols_size

const std::size_t exprtk::details::reserved_symbols_size = sizeof(reserved_symbols) / sizeof(std::string)

static

Definition at line 461 of file exprtk.hpp.

Referenced by exprtk::symbol_table< T >::type_store< Type, RawType >::add_impl(), is_reserved_symbol(), and exprtk::symbol_table< T >::control_block::st_data::st_data().

◆ reserved_words

const std::string exprtk::details::reserved_words[]

static

Initial value:

=
      {
         "assert",  "break", "case", "continue", "const",  "default",
         "false", "for", "if", "else", "ilike", "in", "like",  "and",
         "nand",  "nor",  "not",  "null",  "or",  "repeat", "return",
         "shl",  "shr",  "swap",  "switch",  "true",  "until", "var",
         "while", "xnor", "xor", "&", "|"
      }

Definition at line 433 of file exprtk.hpp.

      {
         "assert",  "break", "case", "continue", "const",  "default",
         "false", "for", "if", "else", "ilike", "in", "like",  "and",
         "nand",  "nor",  "not",  "null",  "or",  "repeat", "return",
         "shl",  "shr",  "swap",  "switch",  "true",  "until", "var",
         "while", "xnor", "xor", "&", "|"
      };

Referenced by exprtk::parser< T >::init_precompilation(), is_reserved_word(), and exprtk::symbol_table< T >::control_block::st_data::st_data().

◆ reserved_words_size

const std::size_t exprtk::details::reserved_words_size = sizeof(reserved_words) / sizeof(std::string)

static

Definition at line 442 of file exprtk.hpp.

Referenced by exprtk::parser< T >::init_precompilation(), is_reserved_word(), and exprtk::symbol_table< T >::control_block::st_data::st_data().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ _int64_t

◆ _uint64_t

◆ char_cptr

◆ char_ptr

◆ char_t

◆ uchar_cptr

◆ uchar_ptr

◆ uchar_t

Enumeration Type Documentation

◆ operator_type

Function Documentation

◆ all_nodes_valid() [1/2]

◆ all_nodes_valid() [2/2]

◆ all_nodes_variables() [1/2]

◆ all_nodes_variables() [2/2]

◆ axn()

◆ axnb()

◆ back()

◆ branch_deletable()

◆ case_normalise()

◆ cleanup_escapes()

◆ compute_pow10()

◆ construct_branch_pair() [1/2]

◆ construct_branch_pair() [2/2]

◆ destroy_node()

◆ disable_type_checking()

◆ dump_ptr() [1/2]

◆ dump_ptr() [2/2]

◆ dump_vector()

◆ free_all_nodes() [1/2]

◆ free_all_nodes() [2/2]

◆ free_node()

◆ front()

◆ hex_to_bin()

◆ imatch() [1/2]

◆ imatch() [2/2]

◆ init_branches()

◆ is_assert_node()

◆ is_base_function()

◆ is_binary_node()

◆ is_boc_node()

◆ is_bracket()

◆ is_break_node()

◆ is_cob_node()

◆ is_const_string_node()

◆ is_const_string_range_node()

◆ is_constant_node()

◆ is_continue_node()

◆ is_control_struct()

◆ is_cov_node()

◆ is_digit()

◆ is_false() [1/5]

◆ is_false() [2/5]

◆ is_false() [3/5]

◆ is_false() [4/5]

◆ is_false() [5/5]

◆ is_function()

◆ is_generally_string_node()

◆ is_genricstring_range_node()

◆ is_hex_digit()

◆ is_invalid()

◆ is_ivariable_node()

◆ is_ivector_node()

◆ is_left_bracket()

◆ is_letter()

◆ is_letter_or_digit()

◆ is_literal_node()

◆ is_logic_opr()

◆ is_neg_unary_node()

◆ is_negate_node()

◆ is_null_node()

◆ is_operator_char()

◆ is_rebasevector_celem_node()