amxp_expression_main.c File Reference

#include <sys/resource.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <regex.h>
#include <amxc/amxc.h>
#include <amxc/amxc_macros.h>
#include "amxp_expr_priv.h"
#include "amxp_expr.tab.h"

Go to the source code of this file.

Data Structures
struct	_amxp_expr_vfunc
struct	_amxp_expr_bfunc
struct	_amxp_regexp

Macros
#define	_GNU_SOURCE
#define	REGEXP_STORE_SIZE   40

Typedefs
typedef struct _amxp_expr_vfunc	amxp_expr_vfunc_t
typedef struct _amxp_expr_bfunc	amxp_expr_bfunc_t
typedef struct _amxp_regexp	amxp_regexp_t

Functions
static void	amxp_regexp_clean (amxc_llist_it_t *it)
static amxp_regexp_t *	amxp_regexp_get (const char *regexp_str)
static CONSTRUCTOR void	amxp_regexp_store_init (void)
static DESTRUCTOR void	amxp_regexp_store_cleanup (void)
static void	amxp_expr_vfunc_hit_free (UNUSED const char *key, amxc_htable_it_t *it)
static void	amxp_expr_bfunc_hit_free (UNUSED const char *key, amxc_htable_it_t *it)
static ssize_t	amxp_expr_string_reader (amxp_expr_t *expr, void *buf, size_t max_size)
static bool	amxp_expr_match_regexp (amxp_expr_t *expr, amxc_var_t *lvalue, amxc_var_t *rvalue)
static bool	amxp_expr_string_check (const char *lstr, size_t llength, const char *rstr, size_t rlength, amxp_expr_comp_t comperator)
static bool	amxp_expr_string_head_tail_check (amxc_var_t *lvalue, amxc_var_t *rvalue, amxp_expr_comp_t comperator)
static bool	amxp_expr_in_list (amxc_var_t *lvalue, amxc_var_t *rvalue)
static bool	amxp_expr_in_string (amxc_var_t *lvalue, amxc_var_t *rvalue)
static bool	amxp_expr_equals_ignorecase (amxc_var_t *lvalue, amxc_var_t *rvalue)
static bool	amxp_expr_is_simple_type (amxc_var_t *value)
static bool	amxp_expr_are_simple_types (amxc_var_t *lvalue, amxc_var_t *rvalue)
static bool	amxp_expr_in (amxp_expr_t *expr, amxc_var_t *lvalue, amxc_var_t *rvalue)
static bool	amxp_expr_comperator (int result, amxp_expr_comp_t type)
static amxp_expr_status_t	_value_first_of (UNUSED amxp_expr_t *expr, amxc_var_t *args, amxc_var_t *ret)
static bool	_bool_is_empty (UNUSED amxp_expr_t *expr, amxc_var_t *args)
static bool	_bool_contains (amxp_expr_t *expr, amxc_var_t *args)
static bool	amxp_expr_is_safe_value (const char *string)
static amxp_expr_status_t	amxp_expr_parse (amxp_expr_t *expr)
void	amxp_expr_msg (amxp_expr_t *expr, const char *format,...)
int	amxp_expr_printf (const char *format,...)
bool	amxp_expr_compare (amxp_expr_t *expr, amxc_var_t *lvalue, amxc_var_t *rvalue, amxp_expr_comp_t comperator)
amxp_expr_status_t	amxp_expr_call_value_func (amxp_expr_t *expr, const char *func, amxc_var_t *args, amxc_var_t *ret)
bool	amxp_expr_call_bool_func (amxp_expr_t *expr, const char *func, amxc_var_t *args)
amxp_expr_status_t	amxp_expr_get_field (amxp_expr_t *expr, amxc_var_t *value, const char *path)
amxp_expr_status_t	amxp_expr_new (amxp_expr_t **expr, const char *expression)
	Allocates and initializes an expression. More...
void	amxp_expr_delete (amxp_expr_t **expr)
	Deletes a previously allocated expression structure. More...
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...
amxp_expr_status_t	amxp_expr_buildf_new (amxp_expr_t **expr, const char *expr_fmt,...)
amxp_expr_status_t	amxp_expr_init (amxp_expr_t *expr, const char *expression)
	Initializes an expression structure. More...
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_buildf (amxp_expr_t *expr, const char *expr_fmt,...)
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...
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...
	CONSTRUCTOR_LVL (101)
	DESTRUCTOR_LVL (101)

Variables
static amxc_htable_t	value_funcs
static amxc_htable_t	bool_funcs
static amxc_htable_t	regexp_store
static amxc_llist_t	regexp_store_list

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 56 of file amxp_expression_main.c.

REGEXP_STORE_SIZE

#define REGEXP_STORE_SIZE   40

Definition at line 73 of file amxp_expression_main.c.

Typedef Documentation

amxp_expr_bfunc_t

typedef struct _amxp_expr_bfunc amxp_expr_bfunc_t

amxp_expr_vfunc_t

typedef struct _amxp_expr_vfunc amxp_expr_vfunc_t

amxp_regexp_t

typedef struct _amxp_regexp amxp_regexp_t

Function Documentation

_bool_contains()

static bool _bool_contains ( amxp_expr_t *  expr, amxc_var_t *  args  )

static

Definition at line 412 of file amxp_expression_main.c.

                                             {
    bool retval = false;
    amxc_var_t* data = (amxc_var_t*) expr->priv;
    const char* path = NULL;
    amxc_var_t field_value;
    amxp_expr_status_t status = amxp_expr_status_ok;
 
    amxc_var_init(&field_value);
    when_null(data, exit);
    when_null(expr->get_field, exit);
 
    amxc_var_for_each(field_var, args) {
        if(amxc_var_type_of(field_var) != AMXC_VAR_ID_CSTRING) {
            // ignore invalid field paths - field paths must be strings
            continue;
        }
        path = amxc_var_constcast(cstring_t, field_var);
        status = expr->get_field(expr, &field_value, path, expr->priv);
        retval = (status == amxp_expr_status_ok);
        if(retval) {
            // found one, we can stop
            break;
        }
    }
 
exit:
    amxc_var_clean(&field_value);
    return retval;
}

_bool_is_empty()

static bool _bool_is_empty ( UNUSED amxp_expr_t *  expr, amxc_var_t *  args  )

static

Definition at line 389 of file amxp_expression_main.c.

                                             {
    bool retval = false;
    amxc_llist_it_t* it = amxc_llist_get_first(&args->data.vl);
    amxc_var_t* data = amxc_var_from_llist_it(it);
 
    if(amxc_var_is_null(data)) {
        retval = true;
    }
 
    if((amxc_var_type_of(data) == AMXC_VAR_ID_LIST) &&
       amxc_llist_is_empty(&data->data.vl)) {
        retval = true;
    }
 
    if((amxc_var_type_of(data) == AMXC_VAR_ID_HTABLE) &&
       amxc_htable_is_empty(&data->data.vm)) {
        retval = true;
    }
 
    return retval;
}

_value_first_of()

static amxp_expr_status_t _value_first_of ( UNUSED amxp_expr_t *  expr, amxc_var_t *  args, amxc_var_t *  ret  )

static

Definition at line 367 of file amxp_expression_main.c.

                                                           {
    amxp_expr_status_t status = amxp_expr_status_invalid_value;
    amxc_var_t* data = NULL;
    amxc_llist_for_each(it, (&args->data.vl)) {
        data = amxc_var_from_llist_it(it);
        if(!amxc_var_is_null(data)) {
            break;
        }
        data = NULL;
    }
 
    when_null(data, exit);
    amxc_var_copy(ret, data);
 
    status = amxp_expr_status_ok;
 
exit:
    return status;
}

amxp_expr_are_simple_types()

static bool amxp_expr_are_simple_types ( amxc_var_t *  lvalue, amxc_var_t *  rvalue  )

static

Definition at line 297 of file amxp_expression_main.c.

                                                           {
    return (amxp_expr_is_simple_type(lvalue) &&
            amxp_expr_is_simple_type(rvalue));
}

amxp_expr_bfunc_hit_free()

static void amxp_expr_bfunc_hit_free ( UNUSED const char *  key, amxc_htable_it_t *  it  )

static

Definition at line 129 of file amxp_expression_main.c.

                                                           {
    amxp_expr_bfunc_t* bfn = amxc_htable_it_get_data(it, amxp_expr_bfunc_t, hit);
    free(bfn);
}

amxp_expr_buildf()

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

Definition at line 755 of file amxp_expression_main.c.

                                         {
    va_list args;
    amxp_expr_status_t retval = amxp_expr_status_unknown_error;
    va_start(args, expr_fmt);
    retval = amxp_expr_vbuildf(expr, expr_fmt, args);
    va_end(args);
    return retval;
}

amxp_expr_buildf_new()

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

Definition at line 685 of file amxp_expression_main.c.

                                             {
    va_list args;
    amxp_expr_status_t retval = amxp_expr_status_unknown_error;
    va_start(args, expr_fmt);
    retval = amxp_expr_vbuildf_new(expr, expr_fmt, args);
    va_end(args);
    return retval;
}

amxp_expr_call_bool_func()

bool amxp_expr_call_bool_func	(	amxp_expr_t *	expr,
		const char *	func,
		amxc_var_t *	args
	)

Definition at line 586 of file amxp_expression_main.c.

                                                {
    int retval = false;
    amxc_htable_it_t* it = amxc_htable_get(&bool_funcs, func);
    amxp_expr_bfunc_t* fn = amxc_htable_it_get_data(it, amxp_expr_bfunc_t, hit);
 
    expr->status = amxp_expr_status_function_not_found;
    when_null(it, exit);
    expr->status = amxp_expr_status_ok;
    if(expr->verify) {
        retval = true;
    } else {
        retval = fn->fn(expr, args);
    }
 
exit:
    return retval;
}

amxp_expr_call_value_func()

amxp_expr_status_t amxp_expr_call_value_func	(	amxp_expr_t *	expr,
		const char *	func,
		amxc_var_t *	args,
		amxc_var_t *	ret
	)

Definition at line 567 of file amxp_expression_main.c.

                                                              {
    amxc_htable_it_t* it = amxc_htable_get(&value_funcs, func);
    amxp_expr_vfunc_t* fn = amxc_htable_it_get_data(it, amxp_expr_vfunc_t, hit);
 
    expr->status = amxp_expr_status_function_not_found;
    when_null(it, exit);
    if(expr->verify) {
        expr->status = amxp_expr_status_ok;
    } else {
        expr->status = fn->fn(expr, args, ret);
    }
 
exit:
    return expr->status;
}

amxp_expr_compare()

bool amxp_expr_compare	(	amxp_expr_t *	expr,
		amxc_var_t *	lvalue,
		amxc_var_t *	rvalue,
		amxp_expr_comp_t	comperator
	)

Definition at line 519 of file amxp_expression_main.c.

                                                    {
    int result = 0;
    bool retval = false;
 
    if((comperator != amxp_expr_comp_in) &&
       (comperator != amxp_expr_comp_starts_with) &&
       (comperator != amxp_expr_comp_ends_with) &&
       (comperator != amxp_expr_comp_contains)) {
        if(!amxp_expr_are_simple_types(lvalue, rvalue)) {
            expr->status = amxp_expr_status_invalid_value;
            goto exit;
        }
    }
 
    switch(comperator) {
    case amxp_expr_comp_matches:
        retval = amxp_expr_match_regexp(expr, lvalue, rvalue);
        break;
    case amxp_expr_comp_starts_with:
    case amxp_expr_comp_ends_with:
        retval = amxp_expr_string_head_tail_check(lvalue, rvalue, comperator);
        break;
    case amxp_expr_comp_in:
        retval = amxp_expr_in(expr, lvalue, rvalue);
        break;
    case amxp_expr_comp_contains:
        retval = amxp_expr_in(expr, rvalue, lvalue);
        break;
    case amxp_expr_comp_equals_ignorecase:
        retval = amxp_expr_equals_ignorecase(rvalue, lvalue);
        break;
    default:
        amxc_var_compare(lvalue, rvalue, &result);
        retval = amxp_expr_comperator(result, comperator);
        break;
    }
 
    if(expr->verify) {
        retval = true;
    }
 
exit:
    return retval;
}

amxp_expr_comperator()

static bool amxp_expr_comperator ( int  result, amxp_expr_comp_t  type  )

static

Definition at line 340 of file amxp_expression_main.c.

                                                                    {
    bool retval = false;
    switch(type) {
    case amxp_expr_comp_equal:
        retval = (result == 0);
        break;
    case amxp_expr_comp_not_equal:
        retval = (result != 0);
        break;
    case amxp_expr_comp_lesser:
        retval = (result < 0);
        break;
    case amxp_expr_comp_bigger:
        retval = (result > 0);
        break;
    case amxp_expr_comp_lesser_equal:
        retval = (result <= 0);
        break;
    case amxp_expr_comp_bigger_equal:
        retval = (result >= 0);
        break;
    default:
        break;
    }
    return retval;
}

amxp_expr_equals_ignorecase()

static bool amxp_expr_equals_ignorecase ( amxc_var_t *  lvalue, amxc_var_t *  rvalue  )

static

Definition at line 275 of file amxp_expression_main.c.

                                                            {
    bool retval = false;
    char* lvalue_str = NULL;
    char* rvalue_str = NULL;
 
    lvalue_str = amxc_var_dyncast(cstring_t, lvalue);
    rvalue_str = amxc_var_dyncast(cstring_t, rvalue);
 
    retval = 0 == strcasecmp(lvalue_str, rvalue_str);
 
    free(lvalue_str);
    free(rvalue_str);
 
    return retval;
}

amxp_expr_get_field()

amxp_expr_status_t amxp_expr_get_field	(	amxp_expr_t *	expr,
		amxc_var_t *	value,
		const char *	path
	)

Definition at line 606 of file amxp_expression_main.c.

                                                         {
    amxp_expr_status_t retval = amxp_expr_status_unknown_error;
    amxp_expr_get_field_t fn = expr->get_field;
 
    amxc_var_clean(value);
    if(expr->verify) {
        amxc_var_set(bool, value, true);
        retval = amxp_expr_status_ok;
        goto exit;
    }
 
    if(fn != NULL) {
        retval = fn(expr, value, path, expr->priv);
    }
 
    if(amxc_var_is_null(value)) {
        retval = amxp_expr_status_field_not_found;
        amxp_expr_msg(expr, "Field not found - %s -", path);
    }
    expr->status = retval;
 
exit:
    return retval;
}

amxp_expr_in()

static bool amxp_expr_in ( amxp_expr_t *  expr, amxc_var_t *  lvalue, amxc_var_t *  rvalue  )

static

Definition at line 303 of file amxp_expression_main.c.

                                             {
    int rtype = amxc_var_type_of(rvalue);
    bool retval = false;
 
    if(!amxp_expr_is_simple_type(lvalue)) {
        expr->status = amxp_expr_status_invalid_value;
        goto exit;
    }
 
    switch(rtype) {
    case AMXC_VAR_ID_LIST:
        retval = amxp_expr_in_list(lvalue, rvalue);
        break;
    case AMXC_VAR_ID_CSTRING:
        retval = amxp_expr_in_string(lvalue, rvalue);
        break;
    case AMXC_VAR_ID_SSV_STRING:
    case AMXC_VAR_ID_CSV_STRING:
        amxc_var_cast(rvalue, AMXC_VAR_ID_LIST);
        retval = amxp_expr_in_list(lvalue, rvalue);
        break;
    case AMXC_VAR_ID_BOOL:
        if(!expr->verify) {
            expr->status = amxp_expr_status_invalid_value;
        }
        break;
    default:
        expr->status = amxp_expr_status_invalid_value;
        break;
    }
 
exit:
    return retval;
}

amxp_expr_in_list()

static bool amxp_expr_in_list ( amxc_var_t *  lvalue, amxc_var_t *  rvalue  )

static

Definition at line 236 of file amxp_expression_main.c.

                                                  {
    const amxc_llist_t* list = amxc_var_constcast(amxc_llist_t, rvalue);
    int result = 0;
    bool retval = false;
 
    amxc_llist_for_each(it, list) {
        amxc_var_t* item = amxc_var_from_llist_it(it);
        int amxc_rv = amxc_var_compare(lvalue, item, &result);
        if((amxc_rv == 0) && (result == 0)) {
            retval = true;
            break;
        }
    }
 
    return retval;
}

amxp_expr_in_string()

static bool amxp_expr_in_string ( amxc_var_t *  lvalue, amxc_var_t *  rvalue  )

static

Definition at line 254 of file amxp_expression_main.c.

                                                    {
    const char* string = amxc_var_constcast(cstring_t, rvalue);
    int rlength = strlen(string);
    char* lstr = amxc_var_dyncast(cstring_t, lvalue);
    int llength = strlen(lstr);
    bool retval = false;
 
    if(llength <= rlength) {
        for(int i = 0; i <= rlength - llength; i++) {
            if(strncmp(lstr, string + i, llength) == 0) {
                retval = true;
                break;
            }
        }
    }
 
    free(lstr);
    return retval;
}

amxp_expr_is_safe_value()

static bool amxp_expr_is_safe_value ( const char *  string )

static

Definition at line 443 of file amxp_expression_main.c.

                                                        {
    if(string == NULL) {
        return false;
    }
    for(const char* c = string; *c != '\0'; c++) {
        bool is_whitelisted =
            *c == ' '
            || *c == '!'
            || (*c >= '#' && *c <= '&')
            || (*c >= '(' && *c <= '[')
            || (*c >= ']' && *c <= '_')
            || (*c >= 'a' && *c <= '~');
        if(!is_whitelisted) {
            return false;
        }
    }
    return true;
}

amxp_expr_is_simple_type()

static bool amxp_expr_is_simple_type ( amxc_var_t *  value )

static

Definition at line 292 of file amxp_expression_main.c.

                                                        {
    int type = amxc_var_type_of(value);
    return !(type == AMXC_VAR_ID_HTABLE || type == AMXC_VAR_ID_LIST);
}

amxp_expr_match_regexp()

static bool amxp_expr_match_regexp ( amxp_expr_t *  expr, amxc_var_t *  lvalue, amxc_var_t *  rvalue  )

static

Definition at line 145 of file amxp_expression_main.c.

                                                       {
    bool retval = false;
    amxp_regexp_t* regexp = NULL;
    char* regexp_str = NULL;
    char* value_str = NULL;
 
    regexp_str = amxc_var_dyncast(cstring_t, rvalue);
    value_str = amxc_var_dyncast(cstring_t, lvalue);
 
    regexp = amxp_regexp_get(regexp_str);
    if(regexp == NULL) {
        regexp = (amxp_regexp_t*) calloc(1, sizeof(amxp_regexp_t));
        when_null_status(regexp, exit, expr->status = amxp_expr_status_invalid_regexp);
        if(regcomp(&regexp->regexp, regexp_str, REG_EXTENDED) != 0) {
            expr->status = amxp_expr_status_invalid_regexp;
            free(regexp);
            goto exit;
        }
        amxc_htable_insert(&regexp_store, regexp_str, &regexp->hit);
        amxc_llist_append(&regexp_store_list, &regexp->lit);
 
        if(amxc_htable_size(&regexp_store) > REGEXP_STORE_SIZE) {
            amxc_llist_it_t* it = amxc_llist_take_first(&regexp_store_list);
            amxp_regexp_clean(it);
        }
    }
 
    if(regexec(&regexp->regexp, value_str, 0, NULL, 0) == 0) {
        retval = true;
    }
 
exit:
    free(regexp_str);
    free(value_str);
 
    return retval;
}

amxp_expr_msg()

void amxp_expr_msg	(	amxp_expr_t *	expr,
		const char *	format,
			...
	)

Definition at line 504 of file amxp_expression_main.c.

                                                               {
    va_list args;
    va_start(args, format);
    amxc_string_vsetf(&expr->msg, format, args);
    va_end(args);
}

amxp_expr_parse()

static amxp_expr_status_t amxp_expr_parse ( amxp_expr_t *  expr )

static

Definition at line 462 of file amxp_expression_main.c.

                                                             {
    int yyparse_rv = 0;
    int length = 0;
    when_null(expr, exit);
    when_null(expr->expression, exit);
 
    expr->status = amxp_expr_status_ok;
    length = strlen(expr->expression);
    if(length == 0) {
        goto exit;
    }
    amxc_rbuffer_write(&expr->rbuffer,
                       expr->expression,
                       length);
    if(expr->expression[length - 1] != ';') {
        amxc_rbuffer_write(&expr->rbuffer, ";", 2);
    }
 
    expr->reader = amxp_expr_string_reader;
    expr->status = amxp_expr_status_ok;
 
    amxp_expr_create_lex(expr);
    yyparse_rv = yyparse(expr->scanner);
    amxp_expr_destroy_lex(expr);
 
    if(yyparse_rv != 0) {
        amxp_expr_node_t* node = NULL;
        expr->status = amxp_expr_status_syntax_error;
        node = amxp_expr_node_pop(&expr->nodes);
        while(node != NULL) {
            amxp_expr_node_delete(&node);
            node = amxp_expr_node_pop(&expr->nodes);
        }
    }
 
    amxc_rbuffer_clean(&expr->rbuffer);
 
exit:
    return expr->status;
}

amxp_expr_printf()

int amxp_expr_printf	(	const char *	format,
			...
	)

Definition at line 511 of file amxp_expression_main.c.

                                              {
    va_list args;
    va_start(args, format);
    vfprintf(stderr, format, args);
    va_end(args);
    return 0;
}

amxp_expr_string_check()

static bool amxp_expr_string_check ( const char *  lstr, size_t  llength, const char *  rstr, size_t  rlength, amxp_expr_comp_t  comperator  )

static

Definition at line 185 of file amxp_expression_main.c.

                                                                {
    size_t offset = 0;
    bool retval = false;
 
    when_true(rlength > llength, exit);
 
    if(comperator == amxp_expr_comp_starts_with) {
        offset = 0;
    } else {
        offset = llength - rlength;
    }
    retval = strncmp(lstr + offset, rstr, rlength) == 0;
 
exit:
    return retval;
}

amxp_expr_string_head_tail_check()

static bool amxp_expr_string_head_tail_check ( amxc_var_t *  lvalue, amxc_var_t *  rvalue, amxp_expr_comp_t  comperator  )

static

Definition at line 206 of file amxp_expression_main.c.

                                                                          {
    bool retval = false;
    char* lstr = amxc_var_dyncast(cstring_t, lvalue);
    char* rstr = NULL;
    size_t llength = strlen(lstr);
 
    if(amxc_var_type_of(rvalue) == AMXC_VAR_ID_LIST) {
        amxc_var_for_each(var, rvalue) {
            size_t rlength = 0;
            rstr = amxc_var_dyncast(cstring_t, var);
            rlength = strlen(rstr);
            retval = amxp_expr_string_check(lstr, llength, rstr, rlength, comperator);
            free(rstr);
            if(retval) {
                break;
            }
        }
    } else {
        size_t rlength = 0;
        rstr = amxc_var_dyncast(cstring_t, rvalue);
        rlength = strlen(rstr);
        retval = amxp_expr_string_check(lstr, llength, rstr, rlength, comperator);
        free(rstr);
    }
    free(lstr);
    return retval;
}

amxp_expr_string_reader()

static ssize_t amxp_expr_string_reader ( amxp_expr_t *  expr, void *  buf, size_t  max_size  )

static

Definition at line 135 of file amxp_expression_main.c.

                                                        {
    ssize_t result = 0;
    result = amxc_rbuffer_read(&expr->rbuffer, (char*) buf, max_size);
    errno = 0;
 
    return result;
}

amxp_expr_vfunc_hit_free()

static void amxp_expr_vfunc_hit_free ( UNUSED const char *  key, amxc_htable_it_t *  it  )

static

Definition at line 123 of file amxp_expression_main.c.

                                                           {
    amxp_expr_vfunc_t* vfn = amxc_htable_it_get_data(it, amxp_expr_vfunc_t, hit);
    free(vfn);
}

amxp_regexp_clean()

static void amxp_regexp_clean ( amxc_llist_it_t *  it )

static

Definition at line 95 of file amxp_expression_main.c.

                                                   {
    amxp_regexp_t* amxp_regexp = (amxp_regexp_t*) amxc_container_of(it, amxp_regexp_t, lit);
    amxc_htable_it_clean(&amxp_regexp->hit, NULL);
    regfree(&amxp_regexp->regexp);
    free(amxp_regexp);
}

amxp_regexp_get()

static amxp_regexp_t* amxp_regexp_get ( const char *  regexp_str )

static

Definition at line 102 of file amxp_expression_main.c.

                                                              {
    amxp_regexp_t* regexp = NULL;
    amxc_htable_it_t* it = amxc_htable_get(&regexp_store, regexp_str);
    if(it != NULL) {
        regexp = amxc_container_of(it, amxp_regexp_t, hit);
        amxc_llist_append(&regexp_store_list, &regexp->lit);
    }
 
    return regexp;
}

amxp_regexp_store_cleanup()

static DESTRUCTOR void amxp_regexp_store_cleanup ( void  )

static

Definition at line 118 of file amxp_expression_main.c.

                                                       {
    amxc_llist_clean(&regexp_store_list, amxp_regexp_clean);
    amxc_htable_clean(&regexp_store, NULL);
}

amxp_regexp_store_init()

static CONSTRUCTOR void amxp_regexp_store_init ( void  )

static

Definition at line 113 of file amxp_expression_main.c.

                                                     {
    amxc_llist_init(&regexp_store_list);
    amxc_htable_init(&regexp_store, REGEXP_STORE_SIZE);
}

CONSTRUCTOR_LVL()

CONSTRUCTOR_LVL

(

101

)

Definition at line 861 of file amxp_expression_main.c.

                                                                {
    amxp_expr_add_value_fn("first_existing", _value_first_of);
    amxp_expr_add_bool_fn("is_empty", _bool_is_empty);
    amxp_expr_add_bool_fn("contains", _bool_contains);
}

DESTRUCTOR_LVL()

DESTRUCTOR_LVL

(

101

)

Definition at line 867 of file amxp_expression_main.c.

                                                                  {
    amxc_htable_clean(&value_funcs, amxp_expr_vfunc_hit_free);
    amxc_htable_clean(&bool_funcs, amxp_expr_bfunc_hit_free);
}

Variable Documentation

bool_funcs

amxc_htable_t bool_funcs

static

Definition at line 91 of file amxp_expression_main.c.

regexp_store

amxc_htable_t regexp_store

static

Definition at line 92 of file amxp_expression_main.c.

regexp_store_list

amxc_llist_t regexp_store_list

static

Definition at line 93 of file amxp_expression_main.c.

value_funcs

amxc_htable_t value_funcs

static

Definition at line 90 of file amxp_expression_main.c.