Expressions

Logical expression parser and evaluator. More...

Typedefs
typedef enum _expr_status	amxp_expr_status_t
	Expression status/error codes. More...
typedef ssize_t(*	amxp_expr_reader_t) (amxp_expr_t *expr, void *buf, size_t max_size)
	Expression reader function. More...
typedef amxp_expr_status_t(*	amxp_expr_get_field_t) (amxp_expr_t *expr, amxc_var_t *value, const char *path, void *priv)
	Field fetcher function signature. More...
typedef amxp_expr_status_t(*	amxp_expr_value_func_t) (amxp_expr_t *expr, amxc_var_t *args, amxc_var_t *ret)
	Callback function that can "calculate" a value. More...
typedef bool(*	amxp_expr_bool_func_t) (amxp_expr_t *expr, amxc_var_t *args)
	Callback function that evaluates to true or false. More...

Enumerations
enum	_expr_status {   amxp_expr_status_ok , amxp_expr_status_unknown_error , amxp_expr_status_syntax_error , amxp_expr_status_field_not_found ,   amxp_expr_status_invalid_regexp , amxp_expr_status_invalid_value , amxp_expr_status_function_not_found }
	Expression status/error codes. More...

Functions
amxp_expr_status_t	amxp_expr_new (amxp_expr_t **expr, const char *expression)
	Allocates and initializes an expression. More...
amxp_expr_status_t	amxp_expr_buildf_new (amxp_expr_t **expr, const char *expr_fmt,...) __attribute__((format(printf
	Allocates and initializes an expression with format-string and safety checks. More...
amxp_expr_status_t amxp_expr_status_t	amxp_expr_vbuildf_new (amxp_expr_t **expr, const char *expr_fmt, va_list args)
	va_list version of amxp_expr_buildf_new More...
void	amxp_expr_delete (amxp_expr_t **expr)
	Deletes a previously allocated expression structure. More...
amxp_expr_status_t	amxp_expr_buildf (amxp_expr_t *expr, const char *expr_fmt,...) __attribute__((format(printf
	Initializes an expression structure. More...
amxp_expr_status_t amxp_expr_status_t	amxp_expr_vbuildf (amxp_expr_t *expr, const char *expr_fmt, va_list args)
	va_list version of amxp_expr_buildf More...
amxp_expr_status_t	amxp_expr_init (amxp_expr_t *expr, const char *expression)
	Initializes an expression structure. More...
void	amxp_expr_clean (amxp_expr_t *expr)
	Clean-up the expression structure. More...
void	amxp_expr_dump_tree (amxp_expr_t *expr)
	Dumps the binary tree in dot formatted text file to stdout. More...
bool	amxp_expr_evaluate (amxp_expr_t *expr, amxp_expr_get_field_t fn, void *priv, amxp_expr_status_t *status)
	Evaluates an expression. More...
bool	amxp_expr_eval (amxp_expr_t *expr, amxp_expr_status_t *status)
	Evaluates an expression. More...
bool	amxp_expr_eval_var (amxp_expr_t *expr, const amxc_var_t *const data, amxp_expr_status_t *status)
	Evaluates an expression against a composite variant. More...
int	amxp_expr_find_var_paths (const amxc_var_t *const var, amxc_llist_t *paths, const char *path)
	Search matching variant paths in a composite variant. More...
int	amxp_expr_find_var_values (const amxc_var_t *const var, amxc_htable_t *values, const char *path)
	Search matching variant paths in a composite variant. More...
amxc_var_t *	amxp_expr_find_var (const amxc_var_t *const var, const char *path)
	Search a matching variant and returns a pointer to that variant. More...
amxp_expr_status_t	amxp_expr_get_field_var (amxp_expr_t *expr, amxc_var_t *value, const char *path, void *priv)
	Variant field fetcher implementation. More...
bool	amxp_expr_eval_set (amxp_expr_t *expr, const amxc_set_t *const data, amxp_expr_status_t *status)
	Evaluates an expression against a set. More...
amxp_expr_status_t	amxp_expr_get_field_set (amxp_expr_t *expr, amxc_var_t *value, const char *path, void *priv)
	Flag field fetcher implementation for sets. More...
int	amxp_expr_add_value_fn (const char *fn_name, amxp_expr_value_func_t fn)
	Adds a value calculation function. More...
int	amxp_expr_add_bool_fn (const char *fn_name, amxp_expr_bool_func_t fn)
	Adds a boolean evaluation function. More...
const char *	amxp_expr_get_string (amxp_expr_t *expr)
	Returns the string representation of the given expression. More...

Detailed Description

Logical expression parser and evaluator.

An logical expression evaluates to true or to false.

An expression can consist out of multiple expression parts, concatenated with a logical "OR" or logical "AND"

Syntax of an expression part

VALUE COMPARE OPERATOR VALUE

Each expression part has compare operator, a left value and a right value.

An VALUE can be:

• a field - name of a field, field names may be put between "{" and "}".
• a constant value - string, number, array, boolean, ...
• a function - must be a function that returns a value

Boolean values are case insensitive. There will be a match for true, True or even TrUe. The same comment applies to false.

The supported COMPARE OPERATORS are:

• "==" - is equal to
• "!=" - is not equal to
• "<" - is lesser then
• ">" - is bigger then
• "<=" - is lesser then or equal to
• ">=" - is bigger then or equal to
• "matches" - matches a regular expression, right value must be a regular expression
• "starts with" - string starts with a string, right value must be a string (text) or a list of strings. When the right value is a list of strings and the left value starts with any of the strings in the list it is considered a match.
• "ends with" - string ends with a string, right value must be a string (text) or a list of strings. When the right value is a list of strings and the left value ends with any of the strings in the list it is considered a match.
• "in" - value is in an array of values, right value must be an array When right value is a comma separated string or a space separated string the strings are used as an array of values. When the right value is a string, the check will verify if the value occurst at least once in the string.
• "~=" - checks if an array of values contains a value, left value must be an array. When left value is a comma separated string or a space sperated string the strings are used as an array of values. If the left value is a string, the check will verify if the value occurs at least once in the string.
• "^=" - string comparison ignoring uppercase/lowercase. Both the left value and the right value are converted to string before doing the comparison.

Supported logical operators:

• "not", "!" - not
• "and", "&&" - and
• "or", "||" - or

Example

first_name in ['Tess', 'Olivia', 'Abraham'] && age < 25

Typedef Documentation

amxp_expr_bool_func_t

typedef bool(* amxp_expr_bool_func_t) (amxp_expr_t *expr, amxc_var_t *args)

Callback function that evaluates to true or false.

Not all values can be expressed as a field or a constant, sometimes more complex operations are used. It is possible to define custom boolean method that evaluates the provided arguments and returns true or false.

Boolean functions can be used in any location in an expression when a logical expression is needed.

Parameters

expr	pointer to the expression structure
args	variant containing the arguments of the function

Returns

Returns true or false

Definition at line 240 of file amxp_expression.h.

amxp_expr_get_field_t

typedef amxp_expr_status_t(* amxp_expr_get_field_t) (amxp_expr_t *expr, amxc_var_t *value, const char *path, void *priv)

Field fetcher function signature.

An logical expression with only constant values is not very usefull.

A field fetcher function can be implemented and is used during the expression evaluation to get values for the fields used in the expression.

Depending on the situation or the specific problem a custom field fetcher is needed. When using libamxc variants as data, the field fetcher amxp_expr_get_field_var can be used.

Parameters

expr	pointer to the expression structure
value	the variant in which the value must be stored
path	the field
priv	the private user data

Returns

An expression status, should be amxp_expr_status_ok when the value for the field was fetched correctly.

Definition at line 193 of file amxp_expression.h.

amxp_expr_reader_t

typedef ssize_t(* amxp_expr_reader_t) (amxp_expr_t *expr, void *buf, size_t max_size)

Expression reader function.

A ringbuffer is used to store the expression and read from it during parsing of the expression.

Currently it is not possible to implement a custom reader function and set that function pointer.

Definition at line 166 of file amxp_expression.h.

amxp_expr_status_t

typedef enum _expr_status amxp_expr_status_t

Expression status/error codes.

amxp_expr_value_func_t

typedef amxp_expr_status_t(* amxp_expr_value_func_t) (amxp_expr_t *expr, amxc_var_t *args, amxc_var_t *ret)

Callback function that can "calculate" a value.

Not all values can be expressed as a field or a constant, sometimes more complex operations are used. It is possible to define custom value calculation methods and register them using amxp_expr_add_value_fn.

Value functions can be used in any location in an expression where a value is needed.

Parameters

expr	pointer to the expression structure
args	variant containing the arguments of the function
ret	The calculated value

Returns

An expression status, should be amxp_expr_status_ok when the value is calculated successfull.

Definition at line 218 of file amxp_expression.h.

Enumeration Type Documentation

_expr_status

enum _expr_status

Expression status/error codes.

Enumerator
amxp_expr_status_ok	No error, all ok
amxp_expr_status_unknown_error	Unknown error
amxp_expr_status_syntax_error	Expression has incorrect syntax
amxp_expr_status_field_not_found	Value field is not found
amxp_expr_status_invalid_regexp	Invalid regular expression provided (matches)
amxp_expr_status_invalid_value	Invalid value provided
amxp_expr_status_function_not_found	Function not found

Definition at line 144 of file amxp_expression.h.

                          {
    amxp_expr_status_ok,                 
    amxp_expr_status_unknown_error,      
    amxp_expr_status_syntax_error,       
    amxp_expr_status_field_not_found,    
    amxp_expr_status_invalid_regexp,     
    amxp_expr_status_invalid_value,      
    amxp_expr_status_function_not_found, 
} amxp_expr_status_t;

Function Documentation

amxp_expr_add_bool_fn()

int amxp_expr_add_bool_fn	(	const char *	fn_name,
		amxp_expr_bool_func_t	fn
	)

Adds a boolean evaluation function.

Adds a callback function with a given name to the possible boolean evaluation functions.

Parameters

fn_name	name of the function with which it can be used in the expressions
fn	the function pointer and must match amxp_expr_bool_func_t signature

Returns

0 when the function is added, any other value otherwise

Definition at line 838 of file amxp_expression_main.c.

                                                    {
    int retval = -1;
    amxp_expr_bfunc_t* bfn = NULL;
 
    if(amxc_htable_capacity(&bool_funcs) == 0) {
        amxc_htable_init(&bool_funcs, 5);
    }
 
    when_true(amxc_htable_contains(&bool_funcs, fn_name), exit);
    bfn = (amxp_expr_bfunc_t*) calloc(1, sizeof(amxp_expr_bfunc_t));
    when_null(bfn, exit);
    bfn->fn = fn;
    retval = amxc_htable_insert(&bool_funcs, fn_name, &bfn->hit);
 
exit:
    return retval;
}

amxp_expr_add_value_fn()

int amxp_expr_add_value_fn	(	const char *	fn_name,
		amxp_expr_value_func_t	fn
	)

Adds a value calculation function.

Adds a callback function with a given name to the possible value calculation functions.

Parameters

fn_name	name of the function with which it can be used in the expressions
fn	the function pointer and must match amxp_expr_value_func_t signature

Returns

0 when the function is added, any other value otherwise

Definition at line 820 of file amxp_expression_main.c.

                                                      {
    int retval = -1;
    amxp_expr_vfunc_t* vfn = NULL;
 
    if(amxc_htable_capacity(&value_funcs) == 0) {
        amxc_htable_init(&value_funcs, 5);
    }
    when_true(amxc_htable_contains(&value_funcs, fn_name), exit);
    vfn = (amxp_expr_vfunc_t*) calloc(1, sizeof(amxp_expr_vfunc_t));
    when_null(vfn, exit);
    vfn->fn = fn;
    retval = amxc_htable_insert(&value_funcs, fn_name, &vfn->hit);
 
exit:
    return retval;
}

amxp_expr_buildf()

amxp_expr_status_t amxp_expr_buildf	(	amxp_expr_t *	expr,
		const char *	expr_fmt,
			...
	)

Initializes an expression structure.

The same as amxp_expr_buildf_new but without new heap-allocation.

Note

Make sure that amxp_expr_clean (and not amxp_expr_delete) is called when the expression is not needed anymore. It is possible that the expression parser allocates memory at initialization time, which must be freed when the expression is not needed anymore.

Parameters

expr	a pointer to the location where the pointer to the new expression can be stored
expr_fmt	a string containing a logical expression with placeholders.

Returns

amxp_expr_status_ok if memory is allocated and the given expression is valid (syntax). When an error occurred the function will return any of the amxp_expr_status_t values

amxp_expr_buildf_new()

amxp_expr_status_t amxp_expr_buildf_new	(	amxp_expr_t **	expr,
		const char *	expr_fmt,
			...
	)

Allocates and initializes an expression with format-string and safety checks.

Allocates memory on the heap to store the expression data structure.

The provided expression format string and the replacement values are used to build the expression string. In the expression format string the nth placeholders is replaced with the nth replacement value in the variadic arguments (...).

The supported placeholders ('s', 'i', ...) are the ones supported by amxc_string_appendf_escape.

Example of a expression format string:

"password == '%s' and user == '%s'"

When the variadic arguments are:

["mypassword","admin"]

The expression string that is build will be:

"password == 'mypassword' and user == 'admin'"

Each value in the values variant is verified to avoid the expression, or the context of the expression, being interpreted in an unintended way.

Example of invalid values:

["mypassword' or true or '' = '", "admin"]

This would resolve into the following expression string:

"password == 'mypassword' or true or '' = '' and user == 'admin'"

Which is not the intention, so the first value is considered invalid and the expression build will fail.

The builded expression string is parsed and stored for later use. When the expression is invalid an error is returned and no memory is allocated.

Once an expression structure is available, it can be reused many times.

Note

The allocated memory must be freed when not used anymore, use amxp_expr_delete to free the memory

Parameters

expr	a pointer to the location where the pointer to the new expression can be stored
expr_fmt	a string containing a logical expression with placeholders.

Returns

amxp_expr_status_ok if memory is allocated and the given expression is valid (syntax). When an error occurred the function will return any of the amxp_expr_status_t values

amxp_expr_clean()

void amxp_expr_clean

(

amxp_expr_t *

expr

)

Clean-up the expression structure.

Cleans up all internally allocated memory. After calling this function the expression data structure must be re-initialized before use.

Parameters

expr	a pointer to the expression structure

Definition at line 766 of file amxp_expression_main.c.

                                        {
    amxp_expr_node_t* node = NULL;
    when_null(expr, exit);
 
    free(expr->expression);
    expr->expression = NULL;
 
    node = amxp_expr_get_node(expr);
    amxp_expr_node_delete(&node);
    amxc_lstack_clean(&expr->nodes, NULL);
    amxc_rbuffer_clean(&expr->rbuffer);
    amxc_string_clean(&expr->msg);
 
exit:
    return;
}

amxp_expr_delete()

void amxp_expr_delete

(

amxp_expr_t **

expr

)

Deletes a previously allocated expression structure.

Frees memory previously allocated.

Parameters

expr	a pointer to the location where the pointer to the allocated expression

Definition at line 652 of file amxp_expression_main.c.

                                          {
    when_null(expr, exit);
    when_null(*expr, exit);
 
    amxp_expr_clean(*expr);
    free(*expr);
    *expr = NULL;
 
exit:
    return;
}

amxp_expr_dump_tree()

void amxp_expr_dump_tree

(

amxp_expr_t *

expr

)

Dumps the binary tree in dot formatted text file to stdout.

Using the output as input to the dot tool a graph can be created the represents the builded binary tree by the expression parser.

Parameters

expr	a pointer to the expression structure

Definition at line 783 of file amxp_expression_main.c.

                                            {
    amxp_expr_node_dump(expr, amxp_expr_get_node(expr), 0, 0);
}

amxp_expr_eval()

bool amxp_expr_eval	(	amxp_expr_t *	expr,
		amxp_expr_status_t *	status
	)

Evaluates an expression.

Calls amxp_expr_evaluate without a field fetcher callback function.

Can only be used with expressions that don't contain any fields

Parameters

expr	a pointer to the expression structure
status	will contain the status code,

Returns

• true when the expression evaluates to true (status will be amxp_expr_status_ok)
• false when the expression evaluates to false (status can be an error code)

Definition at line 816 of file amxp_expression_main.c.

                                                                   {
    return amxp_expr_evaluate(expr, NULL, NULL, status);
}

amxp_expr_eval_set()

bool amxp_expr_eval_set	(	amxp_expr_t *	expr,
		const amxc_set_t *const	data,
		amxp_expr_status_t *	status
	)

Evaluates an expression against a set.

Calls amxp_expr_evaluate with a field fetcher callback function (see amxp_expr_get_field_set) The values of the fields in the expression are flags that are or are not in the given set.

Parameters

expr	a pointer to the expression structure
data	a set
status	will contain the status code,

Returns

• true when the expression evaluates to true
• false when the expression evaluates to false

Definition at line 59 of file amxp_expression_set.c.

                                                    {
    bool rv = false;
    when_null(data, exit);
 
    rv = amxp_expr_evaluate(expr, amxp_expr_get_field_set, (void*) data, status);
 
exit:
    return rv;
}

amxp_expr_eval_var()

bool amxp_expr_eval_var	(	amxp_expr_t *	expr,
		const amxc_var_t *const	data,
		amxp_expr_status_t *	status
	)

Evaluates an expression against a composite variant.

Calls amxp_expr_evaluate with a field fetcher callback function (see amxp_expr_get_field_var) The values of the fields in the expression are fetched from the given variant.

Parameters

expr	a pointer to the expression structure
data	a variant
status	will contain the status code,

Returns

• true when the expression evaluates to true (status will be amxp_expr_status_ok)
• false when the expression evaluates to false (status can be an error code)

Definition at line 315 of file amxp_expression_var.c.

                                                    {
    bool rv = false;
    when_null(data, exit);
    when_true(amxc_var_type_of(data) != AMXC_VAR_ID_HTABLE, exit);
 
    rv = amxp_expr_evaluate(expr, amxp_expr_get_field_var, (void*) data, status);
 
exit:
    return rv;
}

amxp_expr_evaluate()

bool amxp_expr_evaluate	(	amxp_expr_t *	expr,
		amxp_expr_get_field_t	fn,
		void *	priv,
		amxp_expr_status_t *	status
	)

Evaluates an expression.

If the expression provided (see amxp_expr_init or amxp_expr_new) contains fields, the field fetcher callback is called for each field encountered in the expression. The field fetcher callback function must return the value represented by the field.

How the field fetcher works depends on the implementation.

If no field fetcher callback is set and the expression contains fields, the expression will evaluate to false and the status code is set to amxp_expr_status_field_not_found.

Note

When an error occurs while evaluating the expression the return value will be false, check the status parameter to get the error code.

Parameters

expr	a pointer to the expression structure
fn	a field fetcher callback function.
priv	private data pointer, is passed as is to the field fetcher callback function
status	will contain the status code,

Returns

• true when the expression evaluates to true (status will be amxp_expr_status_ok)
• false when the expression evaluates to false (status can be an error code)

Definition at line 787 of file amxp_expression_main.c.

                                                    {
    bool rv = true;
    amxp_expr_node_t* node = NULL;
 
    when_null_status(expr, exit, rv = false);
 
    expr->get_field = fn;
    expr->priv = priv;
 
    node = amxp_expr_get_node(expr);
    if(node == NULL) {
        if(expr->status != amxp_expr_status_ok) {
            rv = false;
        }
    } else {
        rv = amxp_expr_node_eval(expr, node);
    }
 
    if((status != NULL) && (expr != NULL)) {
        *status = expr->status;
    }
 
exit:
    return rv;
}

amxp_expr_find_var()

amxc_var_t* amxp_expr_find_var	(	const amxc_var_t *const	var,
		const char *	path
	)

Search a matching variant and returns a pointer to that variant.

Using expressions or a wildcard '*' at the position of a list variant or a table variant the mathcing variants are filtered out. The expressions must be put between square brackets.

When multiple variants are matching the path, a NULL pointer is returned.

When multiple variants paths can match you can use amxp_expr_find_var_values or amxp_expr_find_var_paths instead.

Parameters

var	the composite variant
path	the variant path, it may contain wildcards or expressions

Returns

NULL when zero or more then one variants are matching, or a pointer to a variant is there is exactly one matching.

Definition at line 412 of file amxp_expression_var.c.

                                                 {
    const amxc_var_t* retval = NULL;
    int rv = 0;
    var_collector_t* first = NULL;
    amxc_llist_t parts;
    amxc_llist_t vars;
 
    amxc_llist_init(&parts);
    amxc_llist_init(&vars);
 
    when_null(var, exit);
    when_str_empty(path, exit);
 
    rv = var_build_parts(&parts, path);
    when_failed(rv, exit);
 
    var_collector_new("", var, &vars);
    var_collect(&vars, &parts);
 
    if(amxc_llist_is_empty(&vars)) {
        goto exit;
    }
 
    first = amxc_container_of(amxc_llist_get_first(&vars), var_collector_t, it);
    if((first == NULL) || (amxc_llist_it_get_next(&first->it) != NULL)) {
        goto exit;
    }
 
    retval = first->var;
 
exit:
    amxc_llist_clean(&parts, amxc_string_list_it_free);
    amxc_llist_clean(&vars, var_collector_it_free);
    return (amxc_var_t*) retval;
}

amxp_expr_find_var_paths()

int amxp_expr_find_var_paths	(	const amxc_var_t *const	var,
		amxc_llist_t *	paths,
		const char *	path
	)

Search matching variant paths in a composite variant.

Using expressions or a wildcard '*' at the position of a list variant or a table variant the mathcing variants are filtered out. The expressions must be put between square brackets.

All matching variant paths are added to the linked list. The value of each matching variant can be fetched using the GET macros provided in libamxc

Example:

Data set in json notation

{
   "00:01:02:03:44:f0": [
   ],
   "94:83:c4:06:da:66": [
       {
           "Extender": true,
           "MACAddress": "00:01:02:03:44:f0"
       },
       {
           "Extender": false,
           "MACAddress" : "00:00:55:3b:05",
       }
   ]
}

Search path: "94:83:c4:06:da:66.[MACAddress == '00:01:02:03:44:f0'].Extender" Result: ["'94:83:c4:06:da:66'.0.'Extender'"]

Search path: "94:83:c4:06:da:66.*.Extender" Result: ["'94:83:c4:06:da:66'.0.'Extender'", "'94:83:c4:06:da:66'.1.'Extender'"]

Parameters

var	the composite variant
paths	a linked list that will be filled with all paths to the variants that match
path	the variant path, it may contain wildcards or expressions

Returns

0 when successfull, any other value indicates an error.

Definition at line 348 of file amxp_expression_var.c.

                                               {
    int retval = 0;
    amxc_llist_t parts;
    amxc_llist_t vars;
 
    amxc_llist_init(&parts);
    amxc_llist_init(&vars);
 
    when_null(var, exit);
    when_null(paths, exit);
    when_str_empty(path, exit);
 
    retval = var_build_parts(&parts, path);
    when_failed(retval, exit);
    var_collector_new("", var, &vars);
    var_collect(&vars, &parts);
 
    amxc_llist_for_each(it, &vars) {
        var_collector_t* c = amxc_container_of(it, var_collector_t, it);
        amxc_llist_append(paths, &c->path->it);
        c->path = NULL;
    }
 
exit:
    amxc_llist_clean(&parts, amxc_string_list_it_free);
    amxc_llist_clean(&vars, var_collector_it_free);
    return retval;
}

amxp_expr_find_var_values()

int amxp_expr_find_var_values	(	const amxc_var_t *const	var,
		amxc_htable_t *	values,
		const char *	path
	)

Search matching variant paths in a composite variant.

Using expressions or a wildcard '*' at the position of a list variant or a table variant the mathcing variants are filtered out. The expressions must be put between square brackets.

All matching variant paths are added to the hash table. The keys in the table are the matching variant paths, the values are copies of the mathcing variants.

Example:

Data set in json notation

{
   "00:01:02:03:44:f0": [
   ],
   "94:83:c4:06:da:66": [
       {
           "Extender": true,
           "MACAddress": "00:01:02:03:44:f0"
       },
       {
           "Extender": false,
           "MACAddress" : "00:00:55:3b:05",
       }
   ]
}

Search path: "94:83:c4:06:da:66.[MACAddress == '00:01:02:03:44:f0'].Extender" Result: {"'94:83:c4:06:da:66'.0.'Extender'" = true}

Search path: "94:83:c4:06:da:66.*.Extender" Result: {"'94:83:c4:06:da:66'.0.'Extender'" = true, "'94:83:c4:06:da:66'.1.'Extender'" = false }

Parameters

var	the composite variant
values	a htable that will be filled with all paths and values of the variants that match the given path
path	the variant path, it may contain wildcards or expressions

Returns

0 when successfull, any other value indicates an error.

Definition at line 379 of file amxp_expression_var.c.

                                                {
    int retval = 0;
    amxc_llist_t parts;
    amxc_llist_t vars;
 
    amxc_llist_init(&parts);
    amxc_llist_init(&vars);
 
    when_null(var, exit);
    when_null(values, exit);
    when_str_empty(path, exit);
 
    retval = var_build_parts(&parts, path);
    when_failed(retval, exit);
    var_collector_new("", var, &vars);
    var_collect(&vars, &parts);
 
    amxc_llist_for_each(it, &vars) {
        var_collector_t* c = amxc_container_of(it, var_collector_t, it);
        amxc_var_t* value = NULL;
        amxc_var_new(&value);
        amxc_var_copy(value, c->var);
        amxc_htable_insert(values, amxc_string_get(c->path, 0), &value->hit);
    }
 
exit:
    amxc_llist_clean(&parts, amxc_string_list_it_free);
    amxc_llist_clean(&vars, var_collector_it_free);
    return retval;
}

amxp_expr_get_field_set()

amxp_expr_status_t amxp_expr_get_field_set	(	amxp_expr_t *	expr,
		amxc_var_t *	value,
		const char *	path,
		void *	priv
	)

Flag field fetcher implementation for sets.

Used by amxp_expr_eval_set. This function should not be called directly.

Parameters

expr	a pointer to the expression structure
value	the value of the field, filled by this function
path	the flag name
priv	the private data as provided to amxp_expr_evaluate

Returns

The status code

amxp_expr_get_field_var()

amxp_expr_status_t amxp_expr_get_field_var	(	amxp_expr_t *	expr,
		amxc_var_t *	value,
		const char *	path,
		void *	priv
	)

Variant field fetcher implementation.

Used by amxp_expr_eval_var. This function should not be called directly.

Parameters

expr	a pointer to the expression structure
value	the value of the field, filled by this function
path	the field name
priv	the private data as provided to amxp_expr_evaluate

Returns

The status code

amxp_expr_get_string()

const char* amxp_expr_get_string

(

amxp_expr_t *

expr

)

Returns the string representation of the given expression.

Parameters

expr	a pointer to the expression structure

Returns

The string representation of the expression, or NULL if there is none.

Definition at line 857 of file amxp_expression_main.c.

                                                    {
    return expr ? expr->expression : NULL;
}

amxp_expr_init()

amxp_expr_status_t amxp_expr_init	(	amxp_expr_t *	expr,
		const char *	expression
	)

Initializes an expression structure.

The provided expression is parsed and stored for later use. When the expression is invalid an error is returned.

Once an expression structure is initialized, it can be reused many times.

Note

Make sure that amxp_expr_clean is called when the expression is not needed anymore. It is possible that the expression parser allocates memory at initialization time, which must be freed when the expression is not needed anymore.

Parameters

expr	a pointer to the expression structure
expression	a string containing a logical expression.

Returns

amxp_expr_status_ok if the given expression is valid (syntax). When an error occurred the function will return any of the amxp_expr_status_t values

Definition at line 696 of file amxp_expression_main.c.

                                                          {
    amxp_expr_status_t retval = amxp_expr_status_unknown_error;
    when_null(expr, exit);
 
    expr->expression = NULL;
    expr->status = amxp_expr_status_ok;
    expr->verify = false;
    expr->get_field = NULL;
    amxc_rbuffer_init(&expr->rbuffer, 0);
    amxc_string_init(&expr->msg, 0);
    amxc_lstack_init(&expr->nodes);
 
    when_null(expression, exit);
    expr->expression = strdup(expression);
    when_null(expr->expression, exit);
 
    retval = amxp_expr_parse(expr);
    if(retval == 0) {
        expr->verify = true;
        amxp_expr_node_eval(expr, amxp_expr_get_node(expr));
        expr->verify = false;
        retval = expr->status;
    }
 
exit:
    if((retval != amxp_expr_status_ok) && (expr != NULL)) {
        amxp_expr_node_t* node = amxp_expr_get_node(expr);
        free(expr->expression);
        expr->expression = NULL;
        amxc_lqueue_clean(&expr->nodes, NULL);
        amxp_expr_node_delete(&node);
    }
    return retval;
}

amxp_expr_new()

amxp_expr_status_t amxp_expr_new	(	amxp_expr_t **	expr,
		const char *	expression
	)

Allocates and initializes an expression.

Allocates memory on the heap to store the expression data structure. The provided expression is parsed and stored for later use. When the expression is invalid an error is returned and no memory is allocated.

Once an expression structure is available, it can be reused many times.

Note

The allocated memory must be freed when not used anymore, use amxp_expr_delete to free the memory

Parameters

expr	a pointer to the location where the pointer to the new expression can be stored
expression	a string containing a logical expression.

Returns

amxp_expr_status_ok if memory is allocated and the given expression is valid (syntax). When an error occurred the function will return any of the amxp_expr_status_t values

Definition at line 633 of file amxp_expression_main.c.

                                                                             {
    amxp_expr_status_t retval = amxp_expr_status_unknown_error;
    when_null(expr, exit);
    when_null(expression, exit);
 
    *expr = (amxp_expr_t*) calloc(1, sizeof(amxp_expr_t));
    when_null((*expr), exit);
 
    retval = amxp_expr_init(*expr, expression);
 
exit:
    if((retval != 0) && (expr != NULL) && (*expr != NULL)) {
        amxp_expr_clean(*expr);
        free(*expr);
        *expr = NULL;
    }
    return retval;
}

amxp_expr_vbuildf()

amxp_expr_status_t amxp_expr_status_t amxp_expr_vbuildf	(	amxp_expr_t *	expr,
		const char *	expr_fmt,
		va_list	args
	)

va_list version of amxp_expr_buildf

Parameters

expr	a pointer to the location where the pointer to the new expression can be stored
expr_fmt	a string containing a logical expression with placeholders.
args	va list of arguments.

Returns

amxp_expr_status_ok if memory is allocated and the given expression is valid (syntax). When an error occurred the function will return any of the amxp_expr_status_t values

Definition at line 732 of file amxp_expression_main.c.

                                                   {
    amxp_expr_status_t retval = amxp_expr_status_unknown_error;
    int status = -1;
    amxc_string_t expression;
 
    amxc_string_init(&expression, 0);
 
    when_null(expr, exit);
    when_null(expr_fmt, exit);
 
    memset(expr, 0, sizeof(amxp_expr_t));
 
    status = amxc_string_vappendf_checked(&expression, amxp_expr_is_safe_value, expr_fmt, args);
    when_failed_status(status, exit, expr->status = amxp_expr_status_syntax_error);
    retval = amxp_expr_init(expr, amxc_string_get(&expression, 0));
 
exit:
    amxc_string_clean(&expression);
    return retval;
}

amxp_expr_vbuildf_new()

amxp_expr_status_t amxp_expr_status_t amxp_expr_vbuildf_new	(	amxp_expr_t **	expr,
		const char *	expr_fmt,
		va_list	args
	)

va_list version of amxp_expr_buildf_new

Parameters

expr	a pointer to the location where the pointer to the new expression can be stored
expr_fmt	a string containing a logical expression with placeholders.
args	va list of arguments.

Returns

amxp_expr_status_ok if memory is allocated and the given expression is valid (syntax). When an error occurred the function will return any of the amxp_expr_status_t values

Definition at line 664 of file amxp_expression_main.c.

                                                       {
    amxp_expr_status_t retval = amxp_expr_status_unknown_error;
    when_null(expr, exit);
    when_null(expr_fmt, exit);
 
    *expr = (amxp_expr_t*) calloc(1, sizeof(amxp_expr_t));
    when_null((*expr), exit);
 
    retval = amxp_expr_vbuildf(*expr, expr_fmt, args);
 
exit:
    if((retval != 0) && (expr != NULL) && (*expr != NULL)) {
        amxp_expr_clean(*expr);
        free(*expr);
        *expr = NULL;
    }
    return retval;
}