save

diff --git a/lib/ecoli_completed.c b/lib/ecoli_completed.c
index 4836803c7ea20e8c158769fa0c31bfe656272efb..a39c719fc19930b0abb0727ead925b2127cb16c2 100644 (file)
--- a/lib/ecoli_completed.c
+++ b/lib/ecoli_completed.c
@@ -103,7 +103,7 @@ ec_node_complete_child(struct ec_node *node,
        child_state = ec_parsed();
        if (child_state == NULL)
                return -ENOMEM;
-       child_state->node = node;
+       ec_parsed_set_node(child_state, node);
        ec_parsed_add_child(parsed_state, child_state);
 
        ret = node->type->complete(node, completed, child_state, strvec);
@@ -119,7 +119,7 @@ ec_node_complete_child(struct ec_node *node,
 #endif
 
        ec_parsed_del_child(parsed_state, child_state);
-       assert(TAILQ_EMPTY(&child_state->children));
+       assert(!ec_parsed_has_child(child_state));
        ec_parsed_free(child_state);
 
        return 0;
@@ -223,7 +223,7 @@ ec_completed_item(struct ec_parsed *state, const struct ec_node *node)
        /* write path in array */
        for (p = state, len = 0; p != NULL;
             p = ec_parsed_get_parent(p), len++)
-               item->path[len] = p->node;
+               item->path[len] = ec_parsed_get_node(p);
 
        item->type = EC_NO_MATCH;
        item->node = node;
@@ -371,6 +371,12 @@ ec_completed_item_get_type(const struct ec_completed_item *item)
        return item->type;
 }
 
+const struct ec_node *
+ec_completed_item_get_node(const struct ec_completed_item *item)
+{
+       return item->node;
+}
+
 void ec_completed_item_free(struct ec_completed_item *item)
 {
        if (item == NULL)

diff --git a/lib/ecoli_completed.h b/lib/ecoli_completed.h
index e66cd71e251af364a7401ed7a11edb733976db26..4054a1a9710b4e8920148c546e80c207c52db89e 100644 (file)
--- a/lib/ecoli_completed.h
+++ b/lib/ecoli_completed.h
@@ -154,6 +154,14 @@ ec_completed_item_get_display(const struct ec_completed_item *item);
 enum ec_completed_type
 ec_completed_item_get_type(const struct ec_completed_item *item);
 
+/**
+ * Get the node associated to a completion item.
+ *
+ *
+ */
+const struct ec_node *
+ec_completed_item_get_node(const struct ec_completed_item *item);
+
 /**
  *
  *

diff --git a/lib/ecoli_keyval.c b/lib/ecoli_keyval.c
index dbc552225314cd8ce0fbe1793025eef53ba64f82..5345ccfb8d5acc48277bfafe661eb316924fbb09 100644 (file)
--- a/lib/ecoli_keyval.c
+++ b/lib/ecoli_keyval.c
@@ -49,19 +49,24 @@ EC_LOG_TYPE_REGISTER(keyval);
 static uint32_t ec_keyval_seed;
 
 struct ec_keyval_elt {
-       LIST_ENTRY(ec_keyval_elt) next;
        char *key;
        void *val;
        uint32_t hash;
        ec_keyval_elt_free_t free;
+       unsigned int refcount;
 };
 
-LIST_HEAD(ec_keyval_elt_list, ec_keyval_elt);
+struct ec_keyval_elt_ref {
+       LIST_ENTRY(ec_keyval_elt_ref) next;
+       struct ec_keyval_elt *elt;
+};
+
+LIST_HEAD(ec_keyval_elt_ref_list, ec_keyval_elt_ref);
 
 struct ec_keyval {
        size_t len;
        size_t table_size;
-       struct ec_keyval_elt_list *table;
+       struct ec_keyval_elt_ref_list *table;
 };
 
 struct ec_keyval *ec_keyval(void)
@@ -75,10 +80,10 @@ struct ec_keyval *ec_keyval(void)
        return keyval;
 }
 
-static struct ec_keyval_elt *ec_keyval_lookup(const struct ec_keyval *keyval,
-       const char *key)
+static struct ec_keyval_elt_ref *
+ec_keyval_lookup(const struct ec_keyval *keyval, const char *key)
 {
-       struct ec_keyval_elt *elt;
+       struct ec_keyval_elt_ref *ref;
        uint32_t h, mask = keyval->table_size - 1;
 
        if (keyval == NULL || key == NULL) {
@@ -91,10 +96,10 @@ static struct ec_keyval_elt *ec_keyval_lookup(const struct ec_keyval *keyval,
        }
 
        h = ec_murmurhash3(key, strlen(key), ec_keyval_seed);
-       LIST_FOREACH(elt, &keyval->table[h & mask], next) {
-               if (strcmp(elt->key, key) == 0) {
+       LIST_FOREACH(ref, &keyval->table[h & mask], next) {
+               if (strcmp(ref->elt->key, key) == 0) {
                        errno = 0;
-                       return elt;
+                       return ref;
                }
        }
 
@@ -102,15 +107,21 @@ static struct ec_keyval_elt *ec_keyval_lookup(const struct ec_keyval *keyval,
        return NULL;
 }
 
-static void ec_keyval_elt_free(struct ec_keyval_elt *elt)
+static void ec_keyval_elt_ref_free(struct ec_keyval_elt_ref *ref)
 {
-       if (elt == NULL)
+       struct ec_keyval_elt *elt;
+
+       if (ref == NULL)
                return;
 
-       ec_free(elt->key);
-       if (elt->free != NULL)
-               elt->free(elt->val);
-       ec_free(elt);
+       elt = ref->elt;
+       if (elt != NULL && --elt->refcount == 0) {
+               ec_free(elt->key);
+               if (elt->free != NULL)
+                       elt->free(elt->val);
+               ec_free(elt);
+       }
+       ec_free(ref);
 }
 
 bool ec_keyval_has_key(const struct ec_keyval *keyval, const char *key)
@@ -120,27 +131,27 @@ bool ec_keyval_has_key(const struct ec_keyval *keyval, const char *key)
 
 void *ec_keyval_get(const struct ec_keyval *keyval, const char *key)
 {
-       struct ec_keyval_elt *elt;
+       struct ec_keyval_elt_ref *ref;
 
-       elt = ec_keyval_lookup(keyval, key);
-       if (elt == NULL)
+       ref = ec_keyval_lookup(keyval, key);
+       if (ref == NULL)
                return NULL;
 
-       return elt->val;
+       return ref->elt->val;
 }
 
 int ec_keyval_del(struct ec_keyval *keyval, const char *key)
 {
-       struct ec_keyval_elt *elt;
+       struct ec_keyval_elt_ref *ref;
 
-       elt = ec_keyval_lookup(keyval, key);
-       if (elt == NULL)
+       ref = ec_keyval_lookup(keyval, key);
+       if (ref == NULL)
                return -1;
 
        /* we could resize table here */
 
-       LIST_REMOVE(elt, next);
-       ec_keyval_elt_free(elt);
+       LIST_REMOVE(ref, next);
+       ec_keyval_elt_ref_free(ref);
        keyval->len--;
 
        return 0;
@@ -148,8 +159,8 @@ int ec_keyval_del(struct ec_keyval *keyval, const char *key)
 
 static int ec_keyval_table_resize(struct ec_keyval *keyval, size_t new_size)
 {
-       struct ec_keyval_elt_list *new_table;
-       struct ec_keyval_elt *elt;
+       struct ec_keyval_elt_ref_list *new_table;
+       struct ec_keyval_elt_ref *ref;
        size_t i;
 
        if (new_size == 0 || (new_size & (new_size - 1))) {
@@ -163,10 +174,11 @@ static int ec_keyval_table_resize(struct ec_keyval *keyval, size_t new_size)
 
        for (i = 0; i < keyval->table_size; i++) {
                while (!LIST_EMPTY(&keyval->table[i])) {
-                       elt = LIST_FIRST(&keyval->table[i]);
-                       LIST_REMOVE(elt, next);
-                       LIST_INSERT_HEAD(&new_table[elt->hash & (new_size - 1)],
-                                       elt, next);
+                       ref = LIST_FIRST(&keyval->table[i]);
+                       LIST_REMOVE(ref, next);
+                       LIST_INSERT_HEAD(
+                               &new_table[ref->elt->hash & (new_size - 1)],
+                               ref, next);
                }
        }
 
@@ -177,27 +189,15 @@ static int ec_keyval_table_resize(struct ec_keyval *keyval, size_t new_size)
        return 0;
 }
 
-int ec_keyval_set(struct ec_keyval *keyval, const char *key, void *val,
-       ec_keyval_elt_free_t free_cb)
+static int
+__ec_keyval_set(struct ec_keyval *keyval, struct ec_keyval_elt_ref *ref)
 {
-       struct ec_keyval_elt *elt;
-       uint32_t h, mask;
        size_t new_size;
+       uint32_t mask;
        int ret;
 
-       if (keyval == NULL || key == NULL) {
-               errno = EINVAL;
-               return -1;
-       }
-
-       elt = ec_keyval_lookup(keyval, key);
-       if (elt != NULL) {
-               if (elt->free != NULL)
-                       elt->free(elt->val);
-               elt->val = val;
-               elt->free = free_cb;
-               return 0;
-       }
+       /* remove previous entry if any */
+       ec_keyval_del(keyval, ref->elt->key);
 
        if (keyval->len >= keyval->table_size) {
                if (keyval->table_size != 0)
@@ -206,40 +206,62 @@ int ec_keyval_set(struct ec_keyval *keyval, const char *key, void *val,
                        new_size =  1 << FACTOR;
                ret = ec_keyval_table_resize(keyval, new_size);
                if (ret < 0)
-                       goto fail;
+                       return ret;
        }
 
+       mask = keyval->table_size - 1;
+       LIST_INSERT_HEAD(&keyval->table[ref->elt->hash & mask], ref, next);
+       keyval->len++;
+
+       return 0;
+}
+
+int ec_keyval_set(struct ec_keyval *keyval, const char *key, void *val,
+       ec_keyval_elt_free_t free_cb)
+{
+       struct ec_keyval_elt *elt = NULL;
+       struct ec_keyval_elt_ref *ref = NULL;
+       uint32_t h;
+
+       if (keyval == NULL || key == NULL) {
+               errno = EINVAL;
+               return -1;
+       }
+
+       ref = ec_calloc(1, sizeof(*ref));
+       if (ref == NULL)
+               goto fail;
+
        elt = ec_calloc(1, sizeof(*elt));
        if (elt == NULL)
                goto fail;
+
+       ref->elt = elt;
+       elt->refcount = 1;
+       elt->val = val;
+       val = NULL;
+       elt->free = free_cb;
        elt->key = ec_strdup(key);
        if (elt->key == NULL)
                goto fail;
-       elt->val = val;
-       elt->free = free_cb;
        h = ec_murmurhash3(key, strlen(key), ec_keyval_seed);
        elt->hash = h;
 
-       mask = keyval->table_size - 1;
-       LIST_INSERT_HEAD(&keyval->table[h & mask], elt, next);
-       keyval->len++;
+       if (__ec_keyval_set(keyval, ref) < 0)
+               goto fail;
 
        return 0;
 
 fail:
-       if (free_cb != NULL)
+       if (free_cb != NULL && val != NULL)
                free_cb(val);
-       if (elt != NULL) {
-               ec_free(elt->key);
-               ec_free(elt);
-       }
-
-       return ret;
+       ec_keyval_elt_ref_free(ref);
+       return -1;
 }
 
 void ec_keyval_free(struct ec_keyval *keyval)
 {
-       struct ec_keyval_elt *elt;
+       struct ec_keyval_elt_ref *ref;
        size_t i;
 
        if (keyval == NULL)
@@ -247,9 +269,9 @@ void ec_keyval_free(struct ec_keyval *keyval)
 
        for (i = 0; i < keyval->table_size; i++) {
                while (!LIST_EMPTY(&keyval->table[i])) {
-                       elt = LIST_FIRST(&keyval->table[i]);
-                       LIST_REMOVE(elt, next);
-                       ec_keyval_elt_free(elt);
+                       ref = LIST_FIRST(&keyval->table[i]);
+                       LIST_REMOVE(ref, next);
+                       ec_keyval_elt_ref_free(ref);
                }
        }
        ec_free(keyval->table);
@@ -263,7 +285,7 @@ size_t ec_keyval_len(const struct ec_keyval *keyval)
 
 void ec_keyval_dump(FILE *out, const struct ec_keyval *keyval)
 {
-       struct ec_keyval_elt *elt;
+       struct ec_keyval_elt_ref *ref;
        size_t i;
 
        if (keyval == NULL) {
@@ -273,13 +295,44 @@ void ec_keyval_dump(FILE *out, const struct ec_keyval *keyval)
 
        fprintf(out, "keyval:\n");
        for (i = 0; i < keyval->table_size; i++) {
-               LIST_FOREACH(elt, &keyval->table[i], next) {
+               LIST_FOREACH(ref, &keyval->table[i], next) {
                        fprintf(out, "  %s: %p\n",
-                               elt->key, elt->val);
+                               ref->elt->key, ref->elt->val);
                }
        }
 }
 
+struct ec_keyval *ec_keyval_dup(const struct ec_keyval *keyval)
+{
+       struct ec_keyval *dup = NULL;
+       struct ec_keyval_elt_ref *ref, *dup_ref = NULL;
+       size_t i;
+
+       dup = ec_keyval();
+       if (dup == NULL)
+               return NULL;
+
+       for (i = 0; i < keyval->table_size; i++) {
+               LIST_FOREACH(ref, &keyval->table[i], next) {
+                       dup_ref = ec_calloc(1, sizeof(*ref));
+                       if (dup_ref == NULL)
+                               goto fail;
+                       dup_ref->elt = ref->elt;
+                       ref->elt->refcount++;
+
+                       if (__ec_keyval_set(dup, dup_ref) < 0)
+                               goto fail;
+               }
+       }
+
+       return dup;
+
+fail:
+       ec_keyval_elt_ref_free(dup_ref);
+       ec_keyval_free(dup);
+       return NULL;
+}
+
 static int ec_keyval_init_func(void)
 {
        int fd;
@@ -309,7 +362,7 @@ EC_INIT_REGISTER(ec_keyval_init);
 /* LCOV_EXCL_START */
 static int ec_keyval_testcase(void)
 {
-       struct ec_keyval *keyval;
+       struct ec_keyval *keyval, *dup;
        char *val;
        size_t i;
        int ret;
@@ -355,11 +408,23 @@ static int ec_keyval_testcase(void)
        ec_keyval_dump(stdout, keyval);
 
        for (i = 0; i < 100; i++) {
-               char buf[8];
-               snprintf(buf, sizeof(buf), "k%zd", i);
-               ret = ec_keyval_set(keyval, buf, "val", NULL);
+               char key[8];
+               snprintf(key, sizeof(key), "k%zd", i);
+               ret = ec_keyval_set(keyval, key, "val", NULL);
                EC_TEST_ASSERT_STR(ret == 0, "cannot set key");
        }
+       dup = ec_keyval_dup(keyval);
+       EC_TEST_ASSERT_STR(dup != NULL, "cannot duplicate keyval");
+       if (dup != NULL) {
+               for (i = 0; i < 100; i++) {
+                       char key[8];
+                       snprintf(key, sizeof(key), "k%zd", i);
+                       val = ec_keyval_get(dup, key);
+                       EC_TEST_ASSERT(val != NULL && !strcmp(val, "val"));
+               }
+               ec_keyval_free(dup);
+               dup = NULL;
+       }
 
        /* einval */
        ret = ec_keyval_set(keyval, NULL, "val1", NULL);
@@ -369,7 +434,6 @@ static int ec_keyval_testcase(void)
 
        ec_keyval_free(keyval);
 
-
        return 0;
 }
 /* LCOV_EXCL_STOP */

diff --git a/lib/ecoli_keyval.h b/lib/ecoli_keyval.h
index 3d739ff7cf8c70cf19dcc08c36929686a16baf1e..5622b23a2537d2cd180386fe391b701138358b17 100644 (file)
--- a/lib/ecoli_keyval.h
+++ b/lib/ecoli_keyval.h
@@ -101,6 +101,7 @@ int ec_keyval_del(struct ec_keyval *keyval, const char *key);
  *   object is destroyed (ec_keyval_del() or ec_keyval_free()).
  * @return
  *   0 on success, or -1 on error (errno is set).
+ *   On error, the passed value is freed (free_cb(val) is called).
  */
 int ec_keyval_set(struct ec_keyval *keyval, const char *key, void *val,
        ec_keyval_elt_free_t free_cb);
@@ -123,6 +124,9 @@ void ec_keyval_free(struct ec_keyval *keyval);
  */
 size_t ec_keyval_len(const struct ec_keyval *keyval);
 
+/* XXX help */
+struct ec_keyval *ec_keyval_dup(const struct ec_keyval *keyval);
+
 /**
  * Dump a hash table.
  *

diff --git a/lib/ecoli_node_cmd.c b/lib/ecoli_node_cmd.c
index 0aca9b139afbd8e2168cb9d6e94a9e88482833a7..3068fc0f35c9df692e306687505919f79691c671 100644 (file)
--- a/lib/ecoli_node_cmd.c
+++ b/lib/ecoli_node_cmd.c
@@ -353,9 +353,9 @@ static int ec_node_cmd_build(struct ec_node *gen_node)
        ret = -EINVAL;
        if (!ec_parsed_matches(p))
                goto fail;
-       if (TAILQ_EMPTY(&p->children))
+       if (!ec_parsed_has_child(p))
                goto fail;
-       if (TAILQ_EMPTY(&TAILQ_FIRST(&p->children)->children))
+       if (!ec_parsed_has_child(ec_parsed_get_first_child(p)))
                goto fail;
 
        ret = -ENOMEM;
@@ -363,7 +363,7 @@ static int ec_node_cmd_build(struct ec_node *gen_node)
        if (cmd == NULL)
                goto fail;
 
-       TAILQ_FOREACH(child, &TAILQ_FIRST(&p->children)->children, next) {
+       EC_PARSED_FOREACH_CHILD(child, ec_parsed_get_first_child(p)) {
                ret = ec_node_expr_eval(&result, expr, child,
                        &test_ops, node);
                if (ret < 0)

diff --git a/lib/ecoli_node_expr.c b/lib/ecoli_node_expr.c
index 9207e4d4d15a8ee49eeeeb1912e77e54a84ba59e..58d4969e2a2d0370173cee5e16b8baf1f9f288fa 100644 (file)
--- a/lib/ecoli_node_expr.c
+++ b/lib/ecoli_node_expr.c
@@ -527,7 +527,7 @@ static int eval_expression(struct result *result,
        memset(result, 0, sizeof(*result));
        memset(&child_result, 0, sizeof(child_result));
 
-       type = get_node_type(expr_gen_node, parsed->node);
+       type = get_node_type(expr_gen_node, ec_parsed_get_node(parsed));
        if (type == VAL) {
                ret = ops->eval_var(&result->val, userctx, parsed);
                if (ret < 0)
@@ -538,9 +538,9 @@ static int eval_expression(struct result *result,
                result->op_type = type;
        }
 
-       TAILQ_FOREACH(child, &parsed->children, next) {
+       EC_PARSED_FOREACH_CHILD(child, parsed) {
 
-               type = get_node_type(expr_gen_node, child->node);
+               type = get_node_type(expr_gen_node, ec_parsed_get_node(child));
                if (type == PAREN_OPEN) {
                        open = child;
                        continue;

diff --git a/lib/ecoli_node_many.c b/lib/ecoli_node_many.c
index b40b3bdbfa1db0ad7b961ce068b21253df55c03b..cc5f738e366539e150dd23b8108de856a71f94e8 100644 (file)
--- a/lib/ecoli_node_many.c
+++ b/lib/ecoli_node_many.c
@@ -71,13 +71,14 @@ static int ec_node_many_parse(const struct ec_node *gen_node,
                }
 
                ret = ec_node_parse_child(node->child, state, childvec);
+               if (ret < 0)
+                       goto fail;
+
                ec_strvec_free(childvec);
                childvec = NULL;
 
                if (ret == EC_PARSED_NOMATCH)
                        break;
-               else if (ret < 0)
-                       goto fail;
 
                /* it matches an empty strvec, no need to continue */
                if (ret == 0) {
@@ -133,7 +134,7 @@ __ec_node_many_complete(struct ec_node_many *node, unsigned int max,
                        goto fail;
 
                ret = ec_node_parse_child(node->child, parsed, childvec);
-               if (ret < 0 && ret != EC_PARSED_NOMATCH)
+               if (ret < 0)
                        goto fail;
 
                ec_strvec_free(childvec);

diff --git a/lib/ecoli_node_once.c b/lib/ecoli_node_once.c
index 54aa67b2ce7ee193bf400bd4be64714bcfee4411..0df4bcd2548835f6809b6207d909eec365780a7e 100644 (file)
--- a/lib/ecoli_node_once.c
+++ b/lib/ecoli_node_once.c
@@ -60,10 +60,10 @@ count_node(struct ec_parsed *parsed, const struct ec_node *node)
        if (parsed == NULL)
                return 0;
 
-       if (parsed->node == node)
+       if (ec_parsed_get_node(parsed) == node)
                count++;
 
-       TAILQ_FOREACH(child, &parsed->children, next)
+       EC_PARSED_FOREACH_CHILD(child, parsed)
                count += count_node(child, node);
 
        return count;

diff --git a/lib/ecoli_node_option.c b/lib/ecoli_node_option.c
index 1dcdd88698d7c3caaf1ad0461b12f79ff4a0a534..ab4f9f3040deaee7c46be24c3ffad0bfbc475ee0 100644 (file)
--- a/lib/ecoli_node_option.c
+++ b/lib/ecoli_node_option.c
@@ -57,10 +57,11 @@ ec_node_option_parse(const struct ec_node *gen_node,
        int ret;
 
        ret = ec_node_parse_child(node->child, state, strvec);
+       if (ret < 0)
+               return ret;
+
        if (ret == EC_PARSED_NOMATCH)
                return 0;
-       else if (ret < 0)
-               return ret;
 
        return ret;
 }

diff --git a/lib/ecoli_node_re_lex.c b/lib/ecoli_node_re_lex.c
index 669c9fb17a39dfdef0fb0ba12a82a93d78439fe3..14b3e46a6df884600f7e89ec9578ff66033a5c36 100644 (file)
--- a/lib/ecoli_node_re_lex.c
+++ b/lib/ecoli_node_re_lex.c
@@ -113,15 +113,16 @@ ec_node_re_lex_parse(const struct ec_node *gen_node,
        }
 
        ret = ec_node_parse_child(node->child, state, new_vec);
-       if (ret >= 0) {
-               if ((unsigned)ret == ec_strvec_len(new_vec)) {
-                       ret = 1;
-               } else {
-                       child_parsed = ec_parsed_get_last_child(state);
-                       ec_parsed_del_child(state, child_parsed);
-                       ec_parsed_free(child_parsed);
-                       ret = EC_PARSED_NOMATCH;
-               }
+       if (ret < 0)
+               goto fail;
+
+       if ((unsigned)ret == ec_strvec_len(new_vec)) {
+               ret = 1;
+       } else if (ret != EC_PARSED_NOMATCH) {
+               child_parsed = ec_parsed_get_last_child(state);
+               ec_parsed_del_child(state, child_parsed);
+               ec_parsed_free(child_parsed);
+               ret = EC_PARSED_NOMATCH;
        }
 
        ec_strvec_free(new_vec);

diff --git a/lib/ecoli_node_seq.c b/lib/ecoli_node_seq.c
index 9240e4f6cce85eff0ca7e675363242148a5e3e13..2b33503118ead9164fb15d88d91f59dbe5f7b53c 100644 (file)
--- a/lib/ecoli_node_seq.c
+++ b/lib/ecoli_node_seq.c
@@ -74,13 +74,15 @@ ec_node_seq_parse(const struct ec_node *gen_node,
                }
 
                ret = ec_node_parse_child(node->table[i], state, childvec);
+               if (ret < 0)
+                       goto fail;
+
                ec_strvec_free(childvec);
                childvec = NULL;
+
                if (ret == EC_PARSED_NOMATCH) {
                        ec_parsed_free_children(state);
                        return EC_PARSED_NOMATCH;
-               } else if (ret < 0) {
-                       goto fail;
                }
 
                len += ret;
@@ -130,7 +132,7 @@ __ec_node_seq_complete(struct ec_node **table, size_t table_len,
                        goto fail;
 
                ret = ec_node_parse_child(table[0], parsed, childvec);
-               if (ret < 0 && ret != EC_PARSED_NOMATCH)
+               if (ret < 0)
                        goto fail;
 
                ec_strvec_free(childvec);

diff --git a/lib/ecoli_node_sh_lex.c b/lib/ecoli_node_sh_lex.c
index 87b3175155ec27540734c4a6c8024db5e4e384c9..94d0d73e39e685d65a10c4d4b04135d868354c58 100644 (file)
--- a/lib/ecoli_node_sh_lex.c
+++ b/lib/ecoli_node_sh_lex.c
@@ -255,15 +255,16 @@ ec_node_sh_lex_parse(const struct ec_node *gen_node,
        }
 
        ret = ec_node_parse_child(node->child, state, new_vec);
-       if (ret >= 0) {
-               if ((unsigned)ret == ec_strvec_len(new_vec)) {
-                       ret = 1;
-               } else {
-                       child_parsed = ec_parsed_get_last_child(state);
-                       ec_parsed_del_child(state, child_parsed);
-                       ec_parsed_free(child_parsed);
-                       ret = EC_PARSED_NOMATCH;
-               }
+       if (ret < 0)
+               goto fail;
+
+       if ((unsigned)ret == ec_strvec_len(new_vec)) {
+               ret = 1;
+       } else if (ret != EC_PARSED_NOMATCH) {
+               child_parsed = ec_parsed_get_last_child(state);
+               ec_parsed_del_child(state, child_parsed);
+               ec_parsed_free(child_parsed);
+               ret = EC_PARSED_NOMATCH;
        }
 
        ec_strvec_free(new_vec);

diff --git a/lib/ecoli_node_subset.c b/lib/ecoli_node_subset.c
index 1803b4d25845b8b3eb11a12fba76593f191a2a4c..18de0cb298d9287006c2cc38ef507e51289d13f9 100644 (file)
--- a/lib/ecoli_node_subset.c
+++ b/lib/ecoli_node_subset.c
@@ -85,10 +85,11 @@ __ec_node_subset_parse(struct parse_result *out, struct ec_node **table,
        for (i = 0; i < table_len; i++) {
                /* try to parse elt i */
                ret = ec_node_parse_child(table[i], state, strvec);
+               if (ret < 0)
+                       goto fail;
+
                if (ret == EC_PARSED_NOMATCH)
                        continue;
-               else if (ret < 0)
-                       goto fail;
 
                /* build a new table without elt i */
                for (j = 0; j < table_len; j++) {
@@ -213,10 +214,11 @@ __ec_node_subset_complete(struct ec_node **table, size_t table_len,
                        continue;
 
                ret = ec_node_parse_child(table[i], parsed, strvec);
+               if (ret < 0)
+                       goto fail;
+
                if (ret == EC_PARSED_NOMATCH)
                        continue;
-               else if (ret < 0)
-                       goto fail;
 
                len = ret;
                childvec = ec_strvec_ndup(strvec, len,

diff --git a/lib/ecoli_parsed.c b/lib/ecoli_parsed.c
index e8f3cb9b9ea93b860f1a1eaac95f1359e57fd074..d338953ac37af7a959aa3179405f94b330d3d5ca 100644 (file)
--- a/lib/ecoli_parsed.c
+++ b/lib/ecoli_parsed.c
@@ -39,6 +39,17 @@
 #include <ecoli_node.h>
 #include <ecoli_parsed.h>
 
+TAILQ_HEAD(ec_parsed_list, ec_parsed);
+
+struct ec_parsed {
+       TAILQ_ENTRY(ec_parsed) next;
+       struct ec_parsed_list children;
+       struct ec_parsed *parent;
+       const struct ec_node *node;
+       struct ec_strvec *strvec;
+       struct ec_keyval *attrs;
+};
+
 int ec_node_parse_child(struct ec_node *node, struct ec_parsed *state,
                        const struct ec_strvec *strvec)
 {
@@ -65,16 +76,17 @@ int ec_node_parse_child(struct ec_node *node, struct ec_parsed *state,
        if (child == NULL)
                return -ENOMEM;
 
-       child->node = node;
+       ec_parsed_set_node(child, node);
        ec_parsed_add_child(state, child);
        ret = node->type->parse(node, child, strvec);
+       if (ret < 0)
+               return ret;
+
        if (ret == EC_PARSED_NOMATCH) {
                ec_parsed_del_child(state, child);
                assert(TAILQ_EMPTY(&child->children));
                ec_parsed_free(child);
                return ret;
-       } else if (ret < 0) {
-               return ret;
        }
 
        match_strvec = ec_strvec_ndup(strvec, 0, ret);
@@ -97,10 +109,12 @@ struct ec_parsed *ec_node_parse_strvec(struct ec_node *node,
                return NULL;
 
        ret = ec_node_parse_child(node, parsed, strvec);
-       if (ret < 0 && ret != EC_PARSED_NOMATCH) {
+       if (ret < 0) {
                ec_parsed_free(parsed);
-               parsed = NULL;
-       } else if (ret != EC_PARSED_NOMATCH) {
+               return NULL;
+       }
+
+       if (ret != EC_PARSED_NOMATCH) {
                /* remove dummy root node */
                child_parsed = ec_parsed_get_last_child(parsed);
                ec_parsed_del_child(parsed, child_parsed);
@@ -161,6 +175,45 @@ struct ec_parsed *ec_parsed(void)
        return NULL;
 }
 
+struct ec_parsed *ec_parsed_dup(const struct ec_parsed *parsed)
+{
+       struct ec_parsed *dup = NULL;
+       struct ec_parsed *child, *dup_child;
+       struct ec_keyval *attrs = NULL;
+
+       if (parsed == NULL)
+               return NULL;
+
+       dup = ec_parsed();
+       if (dup == NULL)
+               return NULL;
+
+       attrs = ec_keyval_dup(parsed->attrs);
+       if (attrs == NULL)
+               goto fail;
+       ec_keyval_free(dup->attrs);
+       dup->attrs = attrs;
+
+       if (parsed->strvec != NULL) {
+               dup->strvec = ec_strvec_dup(parsed->strvec);
+               if (dup->strvec == NULL)
+                       goto fail;
+       }
+
+       TAILQ_FOREACH(child, &parsed->children, next) {
+               dup_child = ec_parsed_dup(child);
+               if (dup_child == NULL)
+                       goto fail;
+               ec_parsed_add_child(dup, dup_child);
+       }
+
+       return dup;
+
+fail:
+       ec_parsed_free(dup);
+       return NULL;
+}
+
 void ec_parsed_free_children(struct ec_parsed *parsed)
 {
        struct ec_parsed *child;
@@ -247,11 +300,37 @@ void ec_parsed_del_child(struct ec_parsed *parsed, // XXX rename del in unlink?
 }
 
 struct ec_parsed *
-ec_parsed_get_last_child(struct ec_parsed *parsed)
+ec_parsed_get_first_child(const struct ec_parsed *parsed)
+{
+       return TAILQ_FIRST(&parsed->children);
+}
+
+struct ec_parsed *
+ec_parsed_get_last_child(const struct ec_parsed *parsed)
 {
        return TAILQ_LAST(&parsed->children, ec_parsed_list);
 }
 
+struct ec_parsed *ec_parsed_get_next(const struct ec_parsed *parsed)
+{
+       return TAILQ_NEXT(parsed, next);
+}
+
+bool ec_parsed_has_child(const struct ec_parsed *parsed)
+{
+       return !TAILQ_EMPTY(&parsed->children);
+}
+
+const struct ec_node *ec_parsed_get_node(const struct ec_parsed *parsed)
+{
+       return parsed->node;
+}
+
+void ec_parsed_set_node(struct ec_parsed *parsed, const struct ec_node *node)
+{
+       parsed->node = node;
+}
+
 void ec_parsed_del_last_child(struct ec_parsed *parsed) // rename in free
 {
        struct ec_parsed *child;

diff --git a/lib/ecoli_parsed.h b/lib/ecoli_parsed.h
index 0755336d22f3fd831617da7a412ab08d6132d708..afb765e706a438f14ad733598e333d4974069d56 100644 (file)
--- a/lib/ecoli_parsed.h
+++ b/lib/ecoli_parsed.h
@@ -25,6 +25,14 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+/**
+ * Node parse API.
+ *
+ * The parse operation is to check if an input (a string or vector of
+ * strings) matches the node tree. On success, the result is stored in a
+ * tree that describes which part of the input matches which node.
+ */
+
 #ifndef ECOLI_PARSED_
 #define ECOLI_PARSED_
 
@@ -34,26 +42,42 @@
 #include <stdio.h>
 
 struct ec_node;
+struct ec_parsed;
 
-TAILQ_HEAD(ec_parsed_list, ec_parsed);
-
-/*
-  node == NULL + empty children list means "no match"
-  XXX still valid?
-*/
-struct ec_parsed {
-       TAILQ_ENTRY(ec_parsed) next;
-       struct ec_parsed_list children;
-       struct ec_parsed *parent;
-       const struct ec_node *node;
-       struct ec_strvec *strvec;
-       struct ec_keyval *attrs;
-};
-
+/**
+ * Create an empty parse tree.
+ *
+ * @return
+ *   The empty parse tree.
+ */
 struct ec_parsed *ec_parsed(void);
+
+/**
+ *
+ *
+ *
+ */
 void ec_parsed_free(struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
 void ec_parsed_free_children(struct ec_parsed *parsed);
 
+/**
+ *
+ *
+ *
+ */
+struct ec_parsed *ec_parsed_dup(const struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
 const struct ec_strvec *ec_parsed_strvec(const struct ec_parsed *parsed);
 
 /* XXX we could use a cache to store possible completions or match: the
@@ -63,12 +87,28 @@ const struct ec_strvec *ec_parsed_strvec(const struct ec_parsed *parsed);
 /* a NULL return value is an error, with errno set
   ENOTSUP: no ->parse() operation
 */
+/**
+ *
+ *
+ *
+ */
 struct ec_parsed *ec_node_parse(struct ec_node *node, const char *str);
 
+/**
+ *
+ *
+ *
+ */
 struct ec_parsed *ec_node_parse_strvec(struct ec_node *node,
                                const struct ec_strvec *strvec);
 
-#define EC_PARSED_NOMATCH INT_MIN
+/**
+ *
+ *
+ *
+ */
+#define EC_PARSED_NOMATCH INT_MAX
+
 /* internal: used by nodes
  *
  * state is the current parse tree, which is built piece by piece while
@@ -79,8 +119,7 @@ struct ec_parsed *ec_node_parse_strvec(struct ec_node *node,
  *   possible descendants.
  *
  * return:
- * XXX change EC_PARSED_NOMATCH to INT_MAX?
- * EC_PARSED_NOMATCH (negative) if it does not match
+ * EC_PARSED_NOMATCH (positive) if it does not match
  * any other negative value (-errno) for other errors
  * the number of matched strings in strvec
  * XXX state is not freed on error ?
@@ -89,23 +128,127 @@ int ec_node_parse_child(struct ec_node *node,
                        struct ec_parsed *state,
                        const struct ec_strvec *strvec);
 
+/**
+ *
+ *
+ *
+ */
 void ec_parsed_add_child(struct ec_parsed *parsed,
                        struct ec_parsed *child);
+/**
+ *
+ *
+ *
+ */
 void ec_parsed_del_child(struct ec_parsed *parsed,
                        struct ec_parsed *child);
 
+/**
+ *
+ *
+ *
+ */
 struct ec_parsed *ec_parsed_get_root(struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
 struct ec_parsed *ec_parsed_get_parent(struct ec_parsed *parsed);
-struct ec_parsed *ec_parsed_get_last_child(struct ec_parsed *parsed);
+
+/**
+ * Get the first child of a tree.
+ *
+ */
+struct ec_parsed *ec_parsed_get_first_child(const struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
+struct ec_parsed *ec_parsed_get_last_child(const struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
+struct ec_parsed *ec_parsed_get_next(const struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
+#define EC_PARSED_FOREACH_CHILD(child, parsed)                 \
+       for (child = ec_parsed_get_first_child(parsed);         \
+               child != NULL;                                  \
+               child = ec_parsed_get_next(child))              \
+
+/**
+ *
+ *
+ *
+ */
+bool ec_parsed_has_child(const struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
+const struct ec_node *ec_parsed_get_node(const struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
+void ec_parsed_set_node(struct ec_parsed *parsed, const struct ec_node *node);
+
+/**
+ *
+ *
+ *
+ */
 void ec_parsed_del_last_child(struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
 int ec_parsed_get_path(struct ec_parsed *parsed, struct ec_node **path);
 
+/**
+ *
+ *
+ *
+ */
 void ec_parsed_dump(FILE *out, const struct ec_parsed *parsed);
 
+/**
+ *
+ *
+ *
+ */
 struct ec_parsed *ec_parsed_find_first(struct ec_parsed *parsed,
        const char *id);
 
+/**
+ *
+ *
+ *
+ */
 size_t ec_parsed_len(const struct ec_parsed *parsed);
+
+/**
+ *
+ *
+ *
+ */
 size_t ec_parsed_matches(const struct ec_parsed *parsed);
 
 #endif

diff --git a/lib/main-readline.c b/lib/main-readline.c
index 5bbe18e7a08977816a4a49781c5bfd6e6c96eb9f..da447d8714870cc9444b5929206a96b0007f2859 100644 (file)
--- a/lib/main-readline.c
+++ b/lib/main-readline.c
@@ -126,21 +126,17 @@ static char **my_attempted_completion(const char *text, int start, int end)
 }
 
 /* this function builds the help string */
-static char *get_node_help(const struct ec_completed_node *compnode)
+static char *get_node_help(const struct ec_completed_item *item)
 {
-//     const struct ec_completed_item *item;
-//     const struct ec_node *node;
+       const struct ec_node *node;
        char *help = NULL;
        const char *node_help = NULL;
        const char *node_desc = NULL;
 //     size_t i;
 
-       (void)compnode;
+       (void)item;
 #if 0 //XXX
-       /* Since we display only one help per node, only look at the first item
-        * to get the path. The objective is to retrieve the most precise
-        * help for this node. */
-       item = TAILQ_FIRST(&compnode->items);
+       /* Retrieve the most precise help for this node. */
        for (i = 0; i < item->pathlen; i++) {
                node = item->path[i];
                if (node_help == NULL)
@@ -148,10 +144,14 @@ static char *get_node_help(const struct ec_completed_node *compnode)
                if (node_desc == NULL)
                        node_desc = ec_node_desc(node);
        }
+#else
+       node = ec_completed_item_get_node(item);
+       node_help = ec_keyval_get(ec_node_attrs(node), "help");
+       node_desc = ec_node_desc(node);
 #endif
 
        if (node_help == NULL)
-               node_help = "";
+               node_help = "-";
        if (node_desc == NULL)
                return NULL;
 
@@ -163,11 +163,13 @@ static char *get_node_help(const struct ec_completed_node *compnode)
 
 static int show_help(int ignore, int invoking_key)
 {
-       const struct ec_completed_node *compnode;
+       struct ec_completed_iter *iter;
+       const struct ec_completed_item *item;
+       const struct ec_node *prev_node = NULL;
        struct ec_completed *c;
        struct ec_parsed *p;
-       char *line;
-       unsigned int count, i;
+       char *line = NULL;
+       unsigned int count;
        char **helps = NULL;
        int match = 0;
 
@@ -176,54 +178,74 @@ static int show_help(int ignore, int invoking_key)
 
        line = strdup(rl_line_buffer);
        if (line == NULL)
-               return 1;
+               goto fail;
 
        /* check if the current line matches */
        p = ec_node_parse(commands, line);
        if (ec_parsed_matches(p))
                match = 1;
        ec_parsed_free(p);
+       p = NULL;
 
        /* complete at current cursor position */
        line[rl_point] = '\0';
        c = ec_node_complete(commands, line);
-       //ec_completed_dump(stdout, c);
        free(line);
+       line = NULL;
        if (c == NULL)
-               return 1;
+               goto fail;
+
+       //ec_completed_dump(stdout, c);
 
        /* let's display one contextual help per node */
        count = 0;
-       TAILQ_FOREACH(compnode, &c->nodes, next) {
-               if (TAILQ_EMPTY(&compnode->items))
-                       continue;
-               count++;
-       }
+       iter = ec_completed_iter(c, EC_NO_MATCH | EC_MATCH | EC_PARTIAL_MATCH);
+       if (iter == NULL)
+               goto fail;
 
-       helps = calloc(count + match + 1, sizeof(char *));
+       /* strangely, rl_display_match_list() expects first index at 1 */
+       helps = calloc(match + 1, sizeof(char *));
        if (helps == NULL)
-               return 1;
-
+               goto fail;
        if (match)
                helps[1] = "<return>";
 
-       /* strangely, rl_display_match_list() expects first index at 1 */
-       i = match + 1;
-       TAILQ_FOREACH(compnode, &c->nodes, next) {
-               if (TAILQ_EMPTY(&compnode->items))
+       while ((item = ec_completed_iter_next(iter)) != NULL) {
+               const struct ec_node *node;
+               char **tmp;
+
+               /* keep one help per node, skip other items  */
+               node = ec_completed_item_get_node(item);
+               if (node == prev_node)
                        continue;
-               helps[i++] = get_node_help(compnode);
+
+               tmp = realloc(helps, (count + match + 2) * sizeof(char *));
+               if (tmp == NULL)
+                       goto fail;
+               helps = tmp;
+               helps[count + match + 1] = get_node_help(item);
+               count++;
        }
 
+       ec_completed_iter_free(iter);
        ec_completed_free(c);
-
        rl_display_match_list(helps, count + match, 1000); /* XXX 1000 */
-
        rl_forced_update_display();
 
        return 0;
 
-       // free helps[n] XXX on error ?
+fail:
+       ec_completed_iter_free(iter);
+       ec_parsed_free(p);
+       free(line);
+       ec_completed_free(c);
+       if (helps != NULL) {
+               while (count--)
+                       free(helps[count + match + 1]);
+       }
+       free(helps);
+
+       return 1;
 }
 
 static int create_commands(void)

diff --git a/lib/todo.txt b/lib/todo.txt
index 0001de189546a73270a837c3c0744ecaadf74217..58b7996dd1483e16970a72659082e1d980f21509 100644 (file)
--- a/lib/todo.txt
+++ b/lib/todo.txt
@@ -202,7 +202,7 @@ return values:
 - 0: success, child->strvec is set by node (NULL = no_match)
 - -1: error (errno is set)
 maybe complex to use:
-- the node must set it (ex: "return ec_parsed_node_match()")
+- the node must set the match (ex: "return ec_parsed_node_match()")
 - the caller must use accessor to check if it matches or not
 
 alternative idea for return values:
@@ -210,6 +210,7 @@ alternative idea for return values:
 - -1: error (errno is set)
 - -2 or MAX_INT: success, but no match
 This is strange to have a specific value for no match
+With MAX_INT, this is the best (less bad) alternative
 
 alternative idea for return values:
 - ec_parse_result_match(n_tokens >= 0)
@@ -251,6 +252,11 @@ partial: beginning of a completion, does not match the token
          (good example is a directory in a path)
 unknown: could complete, but the node does not know how
 
+struct completion_item {
+  const char *value;
+  const char *disp;
+}
+
 struct completed_elt {
   ec_parsed *parse_tree; // current tree state
   ec_node *last;         // last node of the tree
@@ -274,15 +280,15 @@ a node can filter the completions
 
 [] ->
   foo   3 str(foo)
-  seq
-    option
-      str(foo) <-
+    seq
+      option
+        str(foo) <-
 
-  ?       5 int(1,10)
-  seq
-    option
-    or
-      int <-
+  ""    5 int(1,10)
+    seq
+      option
+      or
+        int <-
 
   bar   6 str(bar)
   foo   7 str(bar)
@@ -308,7 +314,6 @@ a node can filter the completions
 changes:
 - a completion item should contain a strvec for the value
   (the display string remains a string)
-- use a INT_MIN or a specific
 - there is maybe no good reason to split in:
   - ec_completed_item()
   - ec_completed_item_set()