#include <ecoli_log.h>
#include <ecoli_test.h>
#include <ecoli_strvec.h>
+#include <ecoli_string.h>
#include <ecoli_node.h>
#include <ecoli_config.h>
#include <ecoli_dict.h>
static struct ec_dict *ec_node_cond_functions; /* functions dictionary */
struct ec_node_cond {
- struct ec_node gen;
char *cond_str; /* the condition string. */
- struct ec_parse *parsed_cond; /* the parsed condition. */
+ struct ec_pnode *parsed_cond; /* the parsed condition. */
struct ec_node *child; /* the child node. */
};
};
/*
- compare(eq|ne|gt|lt|ge|le, x, y)
- find(nodeset, id)
- count(nodeset)
-
- find by attrs? get_attr ?
-*/
+ * XXX missing:
+ * - find by attrs? get_attr ?
+ * - get/set variable
+ */
struct cond_result {
enum cond_result_type type;
};
typedef struct cond_result *(cond_func_t)(
- const struct ec_parse *state,
+ const struct ec_pnode *pstate,
struct cond_result **in, size_t in_len);
-void cond_result_free(struct cond_result *res)
+static void
+cond_result_free(struct cond_result *res)
{
if (res == NULL)
return;
ec_free(res);
}
-void cond_result_table_free(struct cond_result **table, size_t len)
+static void
+cond_result_table_free(struct cond_result **table, size_t len)
{
size_t i;
goto fail;
if (ec_node_or_add(expr,
- ec_node_any("id_value", "a_identifier")) < 0)
+ ec_node_any("id_value_str", "a_identifier")) < 0)
+ goto fail;
+
+ if (ec_node_or_add(expr,
+ ec_node_any("id_value_int", "a_int")) < 0)
goto fail;
/* prepend a lexer to the expression node */
ret = ec_node_re_lex_add(lex, "[_a-zA-Z][._a-zA-Z0-9]*", 1,
"a_identifier");
+ if (ret < 0)
+ goto fail;
+ ret = ec_node_re_lex_add(lex, "[0-9]+", 1, "a_int");
if (ret < 0)
goto fail;
ret = ec_node_re_lex_add(lex, "\\(", 1, "a_open");
return NULL;
}
-static struct ec_parse *
+static struct ec_pnode *
ec_node_cond_build(const char *cond_str)
{
- struct ec_parse *p = NULL;
+ struct ec_pnode *p = NULL;
/* parse the condition expression */
- p = ec_node_parse(ec_node_cond_parser, cond_str);
+ p = ec_parse(ec_node_cond_parser, cond_str);
if (p == NULL)
goto fail;
- if (!ec_parse_matches(p)) {
- errno = EINVAL;
- goto fail;
- }
- if (!ec_parse_has_child(p)) {
+ if (!ec_pnode_matches(p)) {
errno = EINVAL;
goto fail;
}
return p;
fail:
- ec_parse_free(p);
+ ec_pnode_free(p);
return NULL;
}
static struct cond_result *
-eval_root(const struct ec_parse *state, struct cond_result **in, size_t in_len)
+eval_root(const struct ec_pnode *pstate, struct cond_result **in, size_t in_len)
{
struct cond_result *out = NULL;
- const struct ec_parse *root = NULL;
+ const struct ec_pnode *root = NULL;
(void)in;
if (out->htable == NULL)
goto fail;
- root = ec_parse_get_root(state);
+ root = EC_PNODE_GET_ROOT(pstate);
if (ec_htable_set(out->htable, &root, sizeof(root), NULL, NULL) < 0)
goto fail;
}
static struct cond_result *
-eval_current(const struct ec_parse *state, struct cond_result **in,
+eval_current(const struct ec_pnode *pstate, struct cond_result **in,
size_t in_len)
{
struct cond_result *out = NULL;
if (out->htable == NULL)
goto fail;
- if (ec_htable_set(out->htable, &state, sizeof(state), NULL, NULL) < 0)
+ if (ec_htable_set(out->htable, &pstate, sizeof(pstate), NULL, NULL) < 0)
goto fail;
cond_result_table_free(in, in_len);
}
static struct cond_result *
-eval_bool(const struct ec_parse *state, struct cond_result **in, size_t in_len)
+eval_bool(const struct ec_pnode *pstate, struct cond_result **in, size_t in_len)
{
struct cond_result *out = NULL;
- (void)state;
+ (void)pstate;
if (in_len != 1) {
EC_LOG(LOG_ERR, "bool() takes one argument.\n");
}
static struct cond_result *
-eval_or(const struct ec_parse *state, struct cond_result **in, size_t in_len)
+eval_or(const struct ec_pnode *pstate, struct cond_result **in, size_t in_len)
{
struct cond_result *out = NULL;
size_t i;
- (void)state;
+ (void)pstate;
if (in_len < 2) {
EC_LOG(LOG_ERR, "or() takes at least two arguments\n");
}
static struct cond_result *
-eval_and(const struct ec_parse *state, struct cond_result **in, size_t in_len)
+eval_and(const struct ec_pnode *pstate, struct cond_result **in, size_t in_len)
{
struct cond_result *out = NULL;
size_t i;
- (void)state;
+ (void)pstate;
if (in_len < 2) {
EC_LOG(LOG_ERR, "or() takes at least two arguments\n");
}
static struct cond_result *
-eval_first_child(const struct ec_parse *state, struct cond_result **in,
+eval_first_child(const struct ec_pnode *pstate, struct cond_result **in,
size_t in_len)
{
struct cond_result *out = NULL;
struct ec_htable_elt_ref *iter;
- const struct ec_parse * const *pparse;
- struct ec_parse *parse;
+ const struct ec_pnode * const *pparse;
+ struct ec_pnode *parse;
- (void)state;
+ (void)pstate;
if (in_len != 1 || in[0]->type != NODESET) {
EC_LOG(LOG_ERR, "first_child() takes one argument of type nodeset.\n");
for (iter = ec_htable_iter(in[0]->htable);
iter != NULL; iter = ec_htable_iter_next(iter)) {
pparse = ec_htable_iter_get_key(iter);
- parse = ec_parse_get_first_child(*pparse);
+ parse = ec_pnode_get_first_child(*pparse);
if (parse == NULL)
continue;
if (ec_htable_set(out->htable, &parse, sizeof(parse), NULL,
}
static struct cond_result *
-eval_find(const struct ec_parse *state, struct cond_result **in,
+eval_find(const struct ec_pnode *pstate, struct cond_result **in,
size_t in_len)
{
struct cond_result *out = NULL;
struct ec_htable_elt_ref *iter;
- struct ec_parse * const *pparse;
- struct ec_parse *parse;
+ struct ec_pnode * const *pparse;
+ struct ec_pnode *parse;
const char *id;
- (void)state;
+ (void)pstate;
if (in_len != 2 || in[0]->type != NODESET || in[1]->type != STR) {
EC_LOG(LOG_ERR, "find() takes two arguments (nodeset, str).\n");
for (iter = ec_htable_iter(in[0]->htable);
iter != NULL; iter = ec_htable_iter_next(iter)) {
pparse = ec_htable_iter_get_key(iter);
- parse = ec_parse_find(*pparse, id);
+ parse = ec_pnode_find(*pparse, id);
while (parse != NULL) {
if (ec_htable_set(out->htable, &parse,
sizeof(parse), NULL,
NULL) < 0)
goto fail;
- parse = ec_parse_find_next(*pparse, parse, id, 1);
+ parse = ec_pnode_find_next(*pparse, parse, id, 1);
}
}
}
static struct cond_result *
-eval_func(const char *name, const struct ec_parse *state,
+eval_cmp(const struct ec_pnode *pstate, struct cond_result **in,
+ size_t in_len)
+{
+ struct cond_result *out = NULL;
+ struct ec_htable_elt_ref *iter;
+ bool eq = false, gt = false;
+
+ (void)pstate;
+
+ if (in_len != 3 || in[0]->type != STR || in[1]->type != in[2]->type) {
+ EC_LOG(LOG_ERR, "cmp() takes 3 arguments (str, <type>, <type>).\n");
+ errno = EINVAL;
+ goto fail;
+ }
+
+ if (strcmp(in[0]->str, "eq") && strcmp(in[0]->str, "ne") &&
+ strcmp(in[0]->str, "gt") && strcmp(in[0]->str, "lt") &&
+ strcmp(in[0]->str, "ge") && strcmp(in[0]->str, "le")) {
+ EC_LOG(LOG_ERR, "invalid comparison operator in cmp().\n");
+ errno = EINVAL;
+ goto fail;
+ }
+
+ if (strcmp(in[0]->str, "eq") && strcmp(in[0]->str, "ne") &&
+ in[1]->type != INT) {
+ EC_LOG(LOG_ERR, "cmp(gt|lt|ge|le, ...) is only allowed with integers.\n");
+ errno = EINVAL;
+ goto fail;
+ }
+
+ if (in[1]->type == INT) {
+ eq = in[1]->int64 == in[2]->int64;
+ gt = in[1]->int64 > in[2]->int64;
+ } else if (in[1]->type == NODESET &&
+ ec_htable_len(in[1]->htable) !=
+ ec_htable_len(in[2]->htable)) {
+ eq = false;
+ } else if (in[1]->type == NODESET) {
+ eq = true;
+ for (iter = ec_htable_iter(in[1]->htable);
+ iter != NULL; iter = ec_htable_iter_next(iter)) {
+ if (ec_htable_get(
+ in[2]->htable,
+ ec_htable_iter_get_key(iter),
+ sizeof(struct ec_pnode *)) == NULL) {
+ eq = false;
+ break;
+ }
+ }
+ } else if (in[1]->type == STR) {
+ eq = !strcmp(in[1]->str, in[2]->str);;
+ } else if (in[1]->type == BOOLEAN) {
+ eq = in[1]->boolean == in[2]->boolean;
+ }
+
+ out = ec_malloc(sizeof(*out));
+ if (out == NULL)
+ goto fail;
+
+ out->type = BOOLEAN;
+ if (!strcmp(in[0]->str, "eq"))
+ out->boolean = eq;
+ else if (!strcmp(in[0]->str, "ne"))
+ out->boolean = !eq;
+ else if (!strcmp(in[0]->str, "lt"))
+ out->boolean = !gt && !eq;
+ else if (!strcmp(in[0]->str, "gt"))
+ out->boolean = gt && !eq;
+ else if (!strcmp(in[0]->str, "le"))
+ out->boolean = !gt || eq;
+ else if (!strcmp(in[0]->str, "ge"))
+ out->boolean = gt || eq;
+
+ cond_result_table_free(in, in_len);
+ return out;
+
+fail:
+ cond_result_free(out);
+ cond_result_table_free(in, in_len);
+ return NULL;
+}
+
+static struct cond_result *
+eval_count(const struct ec_pnode *pstate, struct cond_result **in, size_t in_len)
+{
+ struct cond_result *out = NULL;
+
+ (void)pstate;
+
+ if (in_len != 1 || in[0]->type != NODESET) {
+ EC_LOG(LOG_ERR, "count() takes one argument of type nodeset.\n");
+ errno = EINVAL;
+ goto fail;
+ }
+
+ out = ec_malloc(sizeof(*out));
+ if (out == NULL)
+ goto fail;
+
+ out->type = INT;
+ out->int64 = ec_htable_len(in[0]->htable);
+
+ cond_result_table_free(in, in_len);
+ return out;
+
+fail:
+ cond_result_free(out);
+ cond_result_table_free(in, in_len);
+ return NULL;
+}
+
+static struct cond_result *
+eval_func(const char *name, const struct ec_pnode *pstate,
struct cond_result **in, size_t in_len)
{
cond_func_t *f;
return NULL;
}
- return f(state, in, in_len);
+ return f(pstate, in, in_len);
}
static struct cond_result *
-eval_condition(const struct ec_parse *cond, const struct ec_parse *state)
+eval_condition(const struct ec_pnode *cond, const struct ec_pnode *pstate)
{
- const struct ec_parse *iter;
+ const struct ec_pnode *iter;
struct cond_result *res = NULL;
struct cond_result **args = NULL;
- const struct ec_parse *func = NULL, *func_name = NULL, *arg_list = NULL;
- const struct ec_parse *value = NULL;
+ const struct ec_pnode *func = NULL, *func_name = NULL, *arg_list = NULL;
+ const struct ec_pnode *value = NULL;
const char *id;
size_t n_arg = 0;
// XXX fix cast (x3)
- func = ec_parse_find((void *)cond, "id_function");
- value = ec_parse_find((void *)cond, "id_value");
+ func = ec_pnode_find((void *)cond, "id_function");
if (func != NULL) {
- EC_PARSE_FOREACH_CHILD(iter, func) {
- id = ec_node_id(ec_parse_get_node(iter));
+ EC_PNODE_FOREACH_CHILD(iter, func) {
+ id = ec_node_id(ec_pnode_get_node(iter));
if (!strcmp(id, "id_function_name"))
func_name = iter;
if (!strcmp(id, "id_arg_list"))
arg_list = iter;
}
- iter = ec_parse_find((void *)arg_list, "id_arg");
+ iter = ec_pnode_find((void *)arg_list, "id_arg");
while (iter != NULL) {
args = ec_realloc(args, (n_arg + 1) * sizeof(*args));
- args[n_arg] = eval_condition(iter, state);
+ args[n_arg] = eval_condition(iter, pstate);
if (args[n_arg] == NULL)
goto fail;
n_arg++;
- iter = ec_parse_find_next((void *)arg_list,
+ iter = ec_pnode_find_next((void *)arg_list,
(void *)iter, "id_arg", 0);
}
- res = eval_func(ec_strvec_val(ec_parse_strvec(func_name), 0),
- state, args, n_arg);
- printf("%s(%p[%zd]) -> %p\n", ec_strvec_val(ec_parse_strvec(func_name), 0),
- args, n_arg, res);
+ res = eval_func(ec_strvec_val(ec_pnode_get_strvec(func_name), 0),
+ pstate, args, n_arg);
args = NULL;
- } else if (value != NULL) {
- printf("%s\n", ec_strvec_val(ec_parse_strvec(value), 0));
+ return res;
+ }
+
+ value = ec_pnode_find((void *)cond, "id_value_str");
+ if (value != NULL) {
res = ec_malloc(sizeof(*res));
if (res == NULL)
goto fail;
res->type = STR;
- res->str = ec_strdup(ec_strvec_val(ec_parse_strvec(value), 0));
+ res->str = ec_strdup(ec_strvec_val(ec_pnode_get_strvec(value), 0));
if (res->str == NULL)
goto fail;
- } else {
- goto fail;
+ return res;
}
- return res;
+ value = ec_pnode_find((void *)cond, "id_value_int");
+ if (value != NULL) {
+ res = ec_malloc(sizeof(*res));
+ if (res == NULL)
+ goto fail;
+ res->type = INT;
+ if (ec_str_parse_llint(ec_strvec_val(ec_pnode_get_strvec(value), 0),
+ 0, LLONG_MIN, LLONG_MAX,
+ &res->int64) < 0)
+ goto fail;
+ return res;
+ }
fail:
cond_result_free(res);
}
static int
-validate_condition(const struct ec_parse *cond, const struct ec_parse *state)
+validate_condition(const struct ec_pnode *cond, const struct ec_pnode *pstate)
{
struct cond_result *res;
int ret;
- res = eval_condition(cond, state);
+ res = eval_condition(cond, pstate);
if (res == NULL)
return -1;
}
static int
-ec_node_cond_parse(const struct ec_node *gen_node, struct ec_parse *state,
+ec_node_cond_parse(const struct ec_node *node, struct ec_pnode *pstate,
const struct ec_strvec *strvec)
{
- struct ec_node_cond *node = (struct ec_node_cond *)gen_node;
- int ret;
+ struct ec_node_cond *priv = ec_node_priv(node);
+ struct ec_pnode *child;
+ int ret, valid;
- ret = validate_condition(node->parsed_cond, state);
- if (ret < 0)
+ ret = ec_parse_child(priv->child, pstate, strvec);
+ if (ret <= 0)
return ret;
- if (ret == 0)
+ valid = validate_condition(priv->parsed_cond, pstate);
+ if (valid < 0)
+ return valid;
+
+ if (valid == 0) {
+ child = ec_pnode_get_last_child(pstate);
+ ec_pnode_unlink_child(child);
+ ec_pnode_free(child);
return EC_PARSE_NOMATCH;
+ }
- return ec_node_parse_child(node->child, state, strvec);
+ return ret;
}
static int
-ec_node_cond_complete(const struct ec_node *gen_node,
+ec_node_cond_complete(const struct ec_node *node,
struct ec_comp *comp,
const struct ec_strvec *strvec)
{
- struct ec_node_cond *node = (struct ec_node_cond *)gen_node;
+ struct ec_node_cond *priv = ec_node_priv(node);
// XXX eval condition
// XXX before or after completing ? configurable ?
- return ec_node_complete_child(node->child, comp, strvec);
+ return ec_complete_child(priv->child, comp, strvec);
}
-static void ec_node_cond_free_priv(struct ec_node *gen_node)
+static void ec_node_cond_free_priv(struct ec_node *node)
{
- struct ec_node_cond *node = (struct ec_node_cond *)gen_node;
+ struct ec_node_cond *priv = ec_node_priv(node);
- ec_free(node->cond_str);
- node->cond_str = NULL;
- ec_parse_free(node->parsed_cond);
- node->parsed_cond = NULL;
- ec_node_free(node->child);
+ ec_free(priv->cond_str);
+ priv->cond_str = NULL;
+ ec_pnode_free(priv->parsed_cond);
+ priv->parsed_cond = NULL;
+ ec_node_free(priv->child);
}
static const struct ec_config_schema ec_node_cond_schema[] = {
},
};
-static int ec_node_cond_set_config(struct ec_node *gen_node,
+static int ec_node_cond_set_config(struct ec_node *node,
const struct ec_config *config)
{
- struct ec_node_cond *node = (struct ec_node_cond *)gen_node;
+ struct ec_node_cond *priv = ec_node_priv(node);
const struct ec_config *cond = NULL;
- struct ec_parse *parsed_cond = NULL;
+ struct ec_pnode *parsed_cond = NULL;
const struct ec_config *child;
char *cond_str = NULL;
goto fail;
/* ok, store the config */
- ec_parse_free(node->parsed_cond);
- node->parsed_cond = parsed_cond;
- ec_free(node->cond_str);
- node->cond_str = cond_str;
- ec_node_free(node->child);
- node->child = ec_node_clone(child->node);
+ ec_pnode_free(priv->parsed_cond);
+ priv->parsed_cond = parsed_cond;
+ ec_free(priv->cond_str);
+ priv->cond_str = cond_str;
+ ec_node_free(priv->child);
+ priv->child = ec_node_clone(child->node);
return 0;
fail:
- ec_parse_free(parsed_cond);
+ ec_pnode_free(parsed_cond);
ec_free(cond_str);
return -1;
}
static size_t
-ec_node_cond_get_children_count(const struct ec_node *gen_node)
+ec_node_cond_get_children_count(const struct ec_node *node)
{
- struct ec_node_cond *node = (struct ec_node_cond *)gen_node;
+ struct ec_node_cond *priv = ec_node_priv(node);
- if (node->child == NULL)
+ if (priv->child == NULL)
return 0;
return 1;
}
static int
-ec_node_cond_get_child(const struct ec_node *gen_node, size_t i,
+ec_node_cond_get_child(const struct ec_node *node, size_t i,
struct ec_node **child, unsigned int *refs)
{
- struct ec_node_cond *node = (struct ec_node_cond *)gen_node;
+ struct ec_node_cond *priv = ec_node_priv(node);
if (i > 0)
return -1;
- *child = node->child;
+ *child = priv->child;
*refs = 1;
return 0;
}
struct ec_node *child)
{
struct ec_config *config = NULL;
- struct ec_node *gen_node = NULL;
+ struct ec_node *node = NULL;
int ret;
if (child == NULL)
return NULL;
- gen_node = ec_node_from_type(&ec_node_cond_type, id);
- if (gen_node == NULL)
+ node = ec_node_from_type(&ec_node_cond_type, id);
+ if (node == NULL)
goto fail;
config = ec_config_dict();
}
child = NULL;
- ret = ec_node_set_config(gen_node, config);
+ ret = ec_node_set_config(node, config);
config = NULL; /* freed */
if (ret < 0)
goto fail;
- return gen_node;
+ return node;
fail:
- ec_node_free(gen_node);
+ ec_node_free(node);
ec_node_free(child);
ec_config_free(config);
goto fail;
if (add_func("find", eval_find) < 0)
goto fail;
+ if (add_func("cmp", eval_cmp) < 0)
+ goto fail;
+ if (add_func("count", eval_count) < 0)
+ goto fail;
return 0;
struct ec_node *node;
int testres = 0;
+ if (0) {
node = EC_NODE_SEQ(EC_NO_ID,
EC_NODE_SUBSET(EC_NO_ID,
ec_node_str("id_node1", "node1"),
testres |= EC_TEST_CHECK_PARSE(node, -1, "node3", "ok");
testres |= EC_TEST_CHECK_PARSE(node, -1, "node4", "ok");
ec_node_free(node);
+ }
+ node = ec_node_cond(EC_NO_ID,
+ "cmp(le, count(find(root(), id_node)), 3)",
+ ec_node_many(EC_NO_ID,
+ ec_node_str("id_node", "foo"), 0, 0));
+ if (node == NULL) {
+ EC_LOG(EC_LOG_ERR, "cannot create node\n");
+ return -1;
+ }
+ testres |= EC_TEST_CHECK_PARSE(node, 0);
+ testres |= EC_TEST_CHECK_PARSE(node, 1, "foo");
+ testres |= EC_TEST_CHECK_PARSE(node, 2, "foo", "foo");
+ testres |= EC_TEST_CHECK_PARSE(node, 3, "foo", "foo", "foo");
+ testres |= EC_TEST_CHECK_PARSE(node, -1, "foo", "foo", "foo", "foo");
+ ec_node_free(node);
// XXX test completion
git.droids-corp.org / protos / libecoli.git / blobdiff