save

diff --git a/lib/ecoli_tk.c b/lib/ecoli_tk.c
index 7fed400ce6badd6b369a10be9e86e64d5e560b77..5867fbe11f996252fe725b727290531e68a79a64 100644 (file)
--- a/lib/ecoli_tk.c
+++ b/lib/ecoli_tk.c
@@ -56,6 +56,9 @@ int ec_tk_type_register(struct ec_tk_type *type)
 {
        if (ec_tk_type_lookup(type->name) != NULL)
                return -EEXIST;
+       if (type->size < sizeof(struct ec_tk))
+               return -EINVAL;
+
        TAILQ_INSERT_TAIL(&tk_type_list, type, next);
 
        return 0;
@@ -69,17 +72,14 @@ void ec_tk_type_dump(FILE *out)
                fprintf(out, "%s\n", type->name);
 }
 
-struct ec_tk *ec_tk_new(const char *id, const struct ec_tk_type *type,
-       size_t size)
+struct ec_tk *__ec_tk_new(const struct ec_tk_type *type, const char *id)
 {
        struct ec_tk *tk = NULL;
        char buf[256]; // XXX
 
-       assert(size >= sizeof(*tk));
-
        ec_log(EC_LOG_DEBUG, "create node type=%s id=%s\n", type->name, id);
 
-       tk = ec_calloc(1, size);
+       tk = ec_calloc(1, type->size);
        if (tk == NULL)
                goto fail;
 
@@ -109,6 +109,19 @@ struct ec_tk *ec_tk_new(const char *id, const struct ec_tk_type *type,
        return NULL;
 }
 
+struct ec_tk *ec_tk_new(const char *typename, const char *id)
+{
+       struct ec_tk_type *type;
+
+       type = ec_tk_type_lookup(typename);
+       if (type == NULL) {
+               ec_log(EC_LOG_ERR, "type=%s does not exist\n", typename);
+               return NULL;
+       }
+
+       return __ec_tk_new(type, id);
+}
+
 void ec_tk_free(struct ec_tk *tk)
 {
        if (tk == NULL)

diff --git a/lib/ecoli_tk.h b/lib/ecoli_tk.h
index 6aa1c77a36cbb661bb0a96d0f10edc222e08a113..cdcf625ac470c83dd8955f09ce3b399911fe4552 100644 (file)
--- a/lib/ecoli_tk.h
+++ b/lib/ecoli_tk.h
@@ -47,6 +47,7 @@ typedef struct ec_parsed_tk *(*ec_tk_parse_t)(const struct ec_tk *tk,
 typedef struct ec_completed_tk *(*ec_tk_complete_t)(const struct ec_tk *tk,
        const struct ec_strvec *strvec);
 typedef const char * (*ec_tk_desc_t)(const struct ec_tk *);
+typedef void (*ec_tk_init_priv_t)(struct ec_tk *);
 typedef void (*ec_tk_free_priv_t)(struct ec_tk *);
 
 #define EC_TK_TYPE_REGISTER(t)                                         \
@@ -70,6 +71,8 @@ struct ec_tk_type {
        ec_tk_parse_t parse;
        ec_tk_complete_t complete;
        ec_tk_desc_t desc;
+       size_t size;
+       ec_tk_init_priv_t init_priv;
        ec_tk_free_priv_t free_priv;
 };
 
@@ -116,8 +119,12 @@ struct ec_tk {
        struct ec_tk_list children;
 };
 
-struct ec_tk *ec_tk_new(const char *id, const struct ec_tk_type *type,
-       size_t priv_size);
+/* create a new token when the type is known, typically called from the node
+ * code */
+struct ec_tk *__ec_tk_new(const struct ec_tk_type *type, const char *id);
+
+/* create a_new token node */
+struct ec_tk *ec_tk_new(const char *typename, const char *id);
 
 void ec_tk_free(struct ec_tk *tk);
 

diff --git a/lib/ecoli_tk_cmd.c b/lib/ecoli_tk_cmd.c
index 2f702ee7322eddc0b1613a9c0243d37e9fb1cea1..03ccb608db4993aaad90b6867c10f2b044dcad14 100644 (file)
--- a/lib/ecoli_tk_cmd.c
+++ b/lib/ecoli_tk_cmd.c
@@ -273,7 +273,7 @@ static int ec_tk_cmd_build(struct ec_tk *gen_tk)
 
        /* build the expression parser */
        ret = -ENOMEM;
-       expr = ec_tk_expr("expr");
+       expr = ec_tk_new("expr", "expr");
        if (expr == NULL)
                goto fail;
        ret = ec_tk_expr_set_val_tk(expr, ec_tk_re(NULL, "[a-zA-Z0-9]+"));
@@ -338,7 +338,7 @@ static int ec_tk_cmd_build(struct ec_tk *gen_tk)
                goto fail;
 
        ret = -ENOMEM;
-       cmd = ec_tk_seq(NULL);
+       cmd = ec_tk_new("seq", NULL);
        if (cmd == NULL)
                goto fail;
 
@@ -375,6 +375,7 @@ static struct ec_tk_type ec_tk_cmd_type = {
        .build = ec_tk_cmd_build,
        .parse = ec_tk_cmd_parse,
        .complete = ec_tk_cmd_complete,
+       .size = sizeof(struct ec_tk_cmd),
        .free_priv = ec_tk_cmd_free_priv,
 };
 
@@ -416,7 +417,7 @@ struct ec_tk *ec_tk_cmd(const char *id, const char *cmd_str)
        struct ec_tk *gen_tk = NULL;
        struct ec_tk_cmd *tk = NULL;
 
-       gen_tk = ec_tk_new(id, &ec_tk_cmd_type, sizeof(*tk));
+       gen_tk = __ec_tk_new(&ec_tk_cmd_type, id);
        if (gen_tk == NULL)
                goto fail;
 

diff --git a/lib/ecoli_tk_empty.c b/lib/ecoli_tk_empty.c
index be487d048320860b2f0f798f65f11169b1ea221a..a2b366c36465ba8d30b70c63ead7abc068aa2269 100644 (file)
--- a/lib/ecoli_tk_empty.c
+++ b/lib/ecoli_tk_empty.c
@@ -69,22 +69,17 @@ static struct ec_tk_type ec_tk_empty_type = {
        .name = "empty",
        .parse = ec_tk_empty_parse,
        .complete = ec_tk_default_complete,
+       .size = sizeof(struct ec_tk_empty),
 };
 
 EC_TK_TYPE_REGISTER(ec_tk_empty_type);
 
-struct ec_tk *ec_tk_empty(const char *id)
-{
-       return ec_tk_new(id, &ec_tk_empty_type,
-               sizeof(struct ec_tk_empty));
-}
-
 static int ec_tk_empty_testcase(void)
 {
        struct ec_tk *tk;
        int ret = 0;
 
-       tk = ec_tk_empty(NULL);
+       tk = ec_tk_new("empty", NULL);
        if (tk == NULL) {
                ec_log(EC_LOG_ERR, "cannot create tk\n");
                return -1;
@@ -95,7 +90,7 @@ static int ec_tk_empty_testcase(void)
        ec_tk_free(tk);
 
        /* never completes */
-       tk = ec_tk_empty(NULL);
+       tk = ec_tk_new("empty", NULL);
        if (tk == NULL) {
                ec_log(EC_LOG_ERR, "cannot create tk\n");
                return -1;

diff --git a/lib/ecoli_tk_expr.c b/lib/ecoli_tk_expr.c
index 40dbd1b7be8d9e658bc3a3be1e0d66b3794f659a..661e75603d1b31014414e2e3c213ee5b2f5aebce 100644 (file)
--- a/lib/ecoli_tk_expr.c
+++ b/lib/ecoli_tk_expr.c
@@ -125,12 +125,12 @@ static int ec_tk_expr_build(struct ec_tk *gen_tk)
        /* create the object, we will initialize it later: this is
         * needed because we have a circular dependency */
        ret = -ENOMEM;
-       weak = ec_tk_weakref_empty("weak");
+       weak = ec_tk_new("weakref", "weak");
        if (weak == NULL)
                return -1;
 
        /* prefix unary operators */
-       pre_op = ec_tk_or("pre-op");
+       pre_op = ec_tk_new("or", "pre-op");
        if (pre_op == NULL)
                goto fail;
        for (i = 0; i < tk->pre_ops_len; i++) {
@@ -139,7 +139,7 @@ static int ec_tk_expr_build(struct ec_tk *gen_tk)
        }
 
        /* suffix unary operators */
-       post_op = ec_tk_or("post-op");
+       post_op = ec_tk_new("or", "post-op");
        if (post_op == NULL)
                goto fail;
        for (i = 0; i < tk->post_ops_len; i++) {
@@ -147,7 +147,7 @@ static int ec_tk_expr_build(struct ec_tk *gen_tk)
                        goto fail;
        }
 
-       post = ec_tk_or("post");
+       post = ec_tk_new("or", "post");
        if (post == NULL)
                goto fail;
        if (ec_tk_or_add(post, ec_tk_clone(tk->val_tk)) < 0)
@@ -224,24 +224,12 @@ static struct ec_tk_type ec_tk_expr_type = {
        .build = ec_tk_expr_build,
        .parse = ec_tk_expr_parse,
        .complete = ec_tk_expr_complete,
+       .size = sizeof(struct ec_tk_expr),
        .free_priv = ec_tk_expr_free_priv,
 };
 
 EC_TK_TYPE_REGISTER(ec_tk_expr_type);
 
-struct ec_tk *ec_tk_expr(const char *id)
-{
-       struct ec_tk_expr *tk = NULL;
-       struct ec_tk *gen_tk = NULL;
-
-       gen_tk = ec_tk_new(id, &ec_tk_expr_type, sizeof(*tk));
-       if (gen_tk == NULL)
-               return NULL;
-       tk = (struct ec_tk_expr *)gen_tk;
-
-       return gen_tk;
-}
-
 int ec_tk_expr_set_val_tk(struct ec_tk *gen_tk, struct ec_tk *val_tk)
 {
        struct ec_tk_expr *tk = (struct ec_tk_expr *)gen_tk;

diff --git a/lib/ecoli_tk_expr_test.c b/lib/ecoli_tk_expr_test.c
index be28797b06c9d916467166472326ee9e988d6c4d..4a00cdf7d6ca89591bd94071cf7978768a869883 100644 (file)
--- a/lib/ecoli_tk_expr_test.c
+++ b/lib/ecoli_tk_expr_test.c
@@ -219,7 +219,7 @@ static int ec_tk_expr_testcase(void)
        struct ec_tk *tk = NULL, *lex_tk = NULL;
        int ret = 0;
 
-       tk = ec_tk_expr("expr");
+       tk = ec_tk_new("expr", "my_expr");
        if (tk == NULL)
                return -1;
 

diff --git a/lib/ecoli_tk_int.c b/lib/ecoli_tk_int.c
index a3510b30150f4ed176904812b33e1c06a8b6525e..905f5163de333ea4f8d74aad59997ff9a7844ef2 100644 (file)
--- a/lib/ecoli_tk_int.c
+++ b/lib/ecoli_tk_int.c
@@ -28,6 +28,8 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
 #include <limits.h>
 #include <ctype.h>
 #include <errno.h>
@@ -41,7 +43,9 @@
 
 struct ec_tk_int {
        struct ec_tk gen;
+       bool check_min;
        long long int min;
+       bool check_max;
        long long int max;
        unsigned int base;
 };
@@ -59,7 +63,10 @@ static int parse_llint(struct ec_tk_int *tk, const char *str,
                        (errno != 0 && *val == 0))
                return -1;
 
-       if (*val < tk->min || *val > tk->max)
+       if (tk->check_min && *val < tk->min)
+               return -1;
+
+       if (tk->check_max && *val > tk->max)
                return -1;
 
        if (*endptr != 0)
@@ -105,6 +112,7 @@ static struct ec_tk_type ec_tk_int_type = {
        .name = "int",
        .parse = ec_tk_int_parse,
        .complete = ec_tk_default_complete,
+       .size = sizeof(struct ec_tk_int),
 };
 
 EC_TK_TYPE_REGISTER(ec_tk_int_type);
@@ -115,12 +123,14 @@ struct ec_tk *ec_tk_int(const char *id, long long int min,
        struct ec_tk *gen_tk = NULL;
        struct ec_tk_int *tk = NULL;
 
-       gen_tk = ec_tk_new(id, &ec_tk_int_type, sizeof(*tk));
+       gen_tk = __ec_tk_new(&ec_tk_int_type, id);
        if (gen_tk == NULL)
                return NULL;
        tk = (struct ec_tk_int *)gen_tk;
 
+       tk->check_min = true;
        tk->min = min;
+       tk->check_max = true;
        tk->max = max;
        tk->base = base;
 

diff --git a/lib/ecoli_tk_many.c b/lib/ecoli_tk_many.c
index 09e5b51d1b78a0f751c836e132d5f4d25d91a082..235f22ab650ed70c983d51dd9fa206a14e37515d 100644 (file)
--- a/lib/ecoli_tk_many.c
+++ b/lib/ecoli_tk_many.c
@@ -177,6 +177,7 @@ static struct ec_tk_type ec_tk_many_type = {
        .parse = ec_tk_many_parse,
        .complete = ec_tk_default_complete,
 //XXX  .complete = ec_tk_many_complete,
+       .size = sizeof(struct ec_tk_many),
        .free_priv = ec_tk_many_free_priv,
 };
 
@@ -190,8 +191,7 @@ struct ec_tk *ec_tk_many(const char *id, struct ec_tk *child,
        if (child == NULL)
                return NULL;
 
-       tk = (struct ec_tk_many *)ec_tk_new(id, &ec_tk_many_type,
-               sizeof(*tk));
+       tk = (struct ec_tk_many *)__ec_tk_new(&ec_tk_many_type, id);
        if (tk == NULL) {
                ec_tk_free(child);
                return NULL;

diff --git a/lib/ecoli_tk_option.c b/lib/ecoli_tk_option.c
index 0038a521e8a6def52f7aaafcbfb33fd29cc5d5c3..080ca37eb9e24d475c0ae10a8de0173b56087b5c 100644 (file)
--- a/lib/ecoli_tk_option.c
+++ b/lib/ecoli_tk_option.c
@@ -98,6 +98,7 @@ static struct ec_tk_type ec_tk_option_type = {
        .name = "option",
        .parse = ec_tk_option_parse,
        .complete = ec_tk_option_complete,
+       .size = sizeof(struct ec_tk_option),
        .free_priv = ec_tk_option_free_priv,
 };
 
@@ -111,7 +112,7 @@ struct ec_tk *ec_tk_option_new(const char *id, struct ec_tk *child)
        if (child == NULL)
                return NULL;
 
-       gen_tk = ec_tk_new(id, &ec_tk_option_type, sizeof(*tk));
+       gen_tk = __ec_tk_new(&ec_tk_option_type, id);
        if (gen_tk == NULL) {
                ec_tk_free(child);
                return NULL;

diff --git a/lib/ecoli_tk_or.c b/lib/ecoli_tk_or.c
index 30e2de4599590bbc252642d3cf68f1da8379a99c..0debd9cabb75b0861f22cd63d30dc028bd5397e3 100644 (file)
--- a/lib/ecoli_tk_or.c
+++ b/lib/ecoli_tk_or.c
@@ -150,30 +150,15 @@ int ec_tk_or_add(struct ec_tk *gen_tk, struct ec_tk *child)
 }
 
 static struct ec_tk_type ec_tk_or_type = {
-       .name = "tk_or",
+       .name = "or",
        .parse = ec_tk_or_parse,
        .complete = ec_tk_or_complete,
+       .size = sizeof(struct ec_tk_or),
        .free_priv = ec_tk_or_free_priv,
 };
 
 EC_TK_TYPE_REGISTER(ec_tk_or_type);
 
-struct ec_tk *ec_tk_or(const char *id)
-{
-       struct ec_tk *gen_tk = NULL;
-       struct ec_tk_or *tk = NULL;
-
-       gen_tk = ec_tk_new(id, &ec_tk_or_type, sizeof(*tk));
-       if (gen_tk == NULL)
-               return NULL;
-
-       tk = (struct ec_tk_or *)gen_tk;
-       tk->table = NULL;
-       tk->len = 0;
-
-       return gen_tk;
-}
-
 struct ec_tk *__ec_tk_or(const char *id, ...)
 {
        struct ec_tk *gen_tk = NULL;
@@ -184,7 +169,7 @@ struct ec_tk *__ec_tk_or(const char *id, ...)
 
        va_start(ap, id);
 
-       gen_tk = ec_tk_or(id);
+       gen_tk = __ec_tk_new(&ec_tk_or_type, id);
        tk = (struct ec_tk_or *)gen_tk;
        if (tk == NULL)
                fail = 1;;

diff --git a/lib/ecoli_tk_re.c b/lib/ecoli_tk_re.c
index e5aec250ced33934193ac7ce45d6f76cf18215ef..fc5c184f971cfecf6f787c9f4d51d6c4f83b2e82 100644 (file)
--- a/lib/ecoli_tk_re.c
+++ b/lib/ecoli_tk_re.c
@@ -91,22 +91,12 @@ static struct ec_tk_type ec_tk_re_type = {
        .name = "re",
        .parse = ec_tk_re_parse,
        .complete = ec_tk_default_complete,
+       .size = sizeof(struct ec_tk_re),
        .free_priv = ec_tk_re_free_priv,
 };
 
 EC_TK_TYPE_REGISTER(ec_tk_re_type);
 
-struct ec_tk *ec_tk_re_new(const char *id)
-{
-       struct ec_tk *gen_tk = NULL;
-
-       gen_tk = ec_tk_new(id, &ec_tk_re_type, sizeof(struct ec_tk_re));
-       if (gen_tk == NULL)
-               return NULL;
-
-       return gen_tk;
-}
-
 int ec_tk_re_set_regexp(struct ec_tk *gen_tk, const char *str)
 {
        struct ec_tk_re *tk = (struct ec_tk_re *)gen_tk;
@@ -137,7 +127,7 @@ struct ec_tk *ec_tk_re(const char *id, const char *re_str)
 {
        struct ec_tk *gen_tk = NULL;
 
-       gen_tk = ec_tk_re_new(id);
+       gen_tk = __ec_tk_new(&ec_tk_re_type, id);
        if (gen_tk == NULL)
                goto fail;
 

diff --git a/lib/ecoli_tk_re_lex.c b/lib/ecoli_tk_re_lex.c
index fb1d73cf37a5bf59e390ee67dbba902cc31e5150..984ec3f15307ff6da37238eac30f5699f09442aa 100644 (file)
--- a/lib/ecoli_tk_re_lex.c
+++ b/lib/ecoli_tk_re_lex.c
@@ -156,6 +156,7 @@ static struct ec_tk_type ec_tk_re_lex_type = {
        .name = "re_lex",
        .parse = ec_tk_re_lex_parse,
        //.complete = ec_tk_re_lex_complete, //XXX
+       .size = sizeof(struct ec_tk_re_lex),
        .free_priv = ec_tk_re_lex_free_priv,
 };
 
@@ -210,8 +211,7 @@ struct ec_tk *ec_tk_re_lex(const char *id, struct ec_tk *child)
        if (child == NULL)
                return NULL;
 
-       tk = (struct ec_tk_re_lex *)ec_tk_new(id, &ec_tk_re_lex_type,
-               sizeof(*tk));
+       tk = (struct ec_tk_re_lex *)__ec_tk_new(&ec_tk_re_lex_type, id);
        if (tk == NULL) {
                ec_tk_free(child);
                return NULL;

diff --git a/lib/ecoli_tk_seq.c b/lib/ecoli_tk_seq.c
index 91bb91cc98c89287a55040701b78dc250ab92c48..17673d6704c800af4a139ee0574df6565ad7eb53 100644 (file)
--- a/lib/ecoli_tk_seq.c
+++ b/lib/ecoli_tk_seq.c
@@ -167,6 +167,7 @@ static struct ec_tk_type ec_tk_seq_type = {
        .name = "seq",
        .parse = ec_tk_seq_parse,
        .complete = ec_tk_seq_complete,
+       .size = sizeof(struct ec_tk_seq),
        .free_priv = ec_tk_seq_free_priv,
 };
 
@@ -202,22 +203,6 @@ int ec_tk_seq_add(struct ec_tk *gen_tk, struct ec_tk *child)
        return 0;
 }
 
-struct ec_tk *ec_tk_seq(const char *id)
-{
-       struct ec_tk *gen_tk = NULL;
-       struct ec_tk_seq *tk = NULL;
-
-       gen_tk = ec_tk_new(id, &ec_tk_seq_type, sizeof(*tk));
-       if (gen_tk == NULL)
-               return NULL;
-
-       tk = (struct ec_tk_seq *)gen_tk;
-       tk->table = NULL;
-       tk->len = 0;
-
-       return gen_tk;
-}
-
 struct ec_tk *__ec_tk_seq(const char *id, ...)
 {
        struct ec_tk *gen_tk = NULL;
@@ -228,7 +213,7 @@ struct ec_tk *__ec_tk_seq(const char *id, ...)
 
        va_start(ap, id);
 
-       gen_tk = ec_tk_seq(id);
+       gen_tk = __ec_tk_new(&ec_tk_seq_type, id);
        tk = (struct ec_tk_seq *)gen_tk;
        if (tk == NULL)
                fail = 1;;

diff --git a/lib/ecoli_tk_sh_lex.c b/lib/ecoli_tk_sh_lex.c
index add0186aed80e82a4078a3ba553e5aebdf4f3e30..204ed791ba49e3e9a2d4ae223f0d69ee24f4f5e3 100644 (file)
--- a/lib/ecoli_tk_sh_lex.c
+++ b/lib/ecoli_tk_sh_lex.c
@@ -375,6 +375,7 @@ static struct ec_tk_type ec_tk_sh_lex_type = {
        .name = "sh_lex",
        .parse = ec_tk_sh_lex_parse,
        .complete = ec_tk_sh_lex_complete,
+       .size = sizeof(struct ec_tk_sh_lex),
        .free_priv = ec_tk_sh_lex_free_priv,
 };
 
@@ -387,8 +388,7 @@ struct ec_tk *ec_tk_sh_lex_new(const char *id, struct ec_tk *child)
        if (child == NULL)
                return NULL;
 
-       tk = (struct ec_tk_sh_lex *)ec_tk_new(id, &ec_tk_sh_lex_type,
-               sizeof(*tk));
+       tk = (struct ec_tk_sh_lex *)__ec_tk_new(&ec_tk_sh_lex_type, id);
        if (tk == NULL) {
                ec_tk_free(child);
                return NULL;

diff --git a/lib/ecoli_tk_space.c b/lib/ecoli_tk_space.c
index 8b26d99e8a1abf0a4c78cb499def323f914823b9..2162afe571094c0d1fc0b8bc6073760e401182b7 100644 (file)
--- a/lib/ecoli_tk_space.c
+++ b/lib/ecoli_tk_space.c
@@ -79,21 +79,17 @@ static struct ec_tk_type ec_tk_space_type = {
        .name = "space",
        .parse = ec_tk_space_parse,
        .complete = ec_tk_default_complete,
+       .size = sizeof(struct ec_tk_space),
 };
 
 EC_TK_TYPE_REGISTER(ec_tk_space_type);
 
-struct ec_tk *ec_tk_space_new(const char *id)
-{
-       return ec_tk_new(id, &ec_tk_space_type, sizeof(struct ec_tk_space));
-}
-
 static int ec_tk_space_testcase(void)
 {
        struct ec_tk *tk;
        int ret = 0;
 
-       tk = ec_tk_space_new(NULL);
+       tk = ec_tk_new("space", NULL);
        if (tk == NULL) {
                ec_log(EC_LOG_ERR, "cannot create tk\n");
                return -1;
@@ -106,7 +102,7 @@ static int ec_tk_space_testcase(void)
        ec_tk_free(tk);
 
        /* test completion */
-       tk = ec_tk_space_new(NULL);
+       tk = ec_tk_new("space", NULL);
        if (tk == NULL) {
                ec_log(EC_LOG_ERR, "cannot create tk\n");
                return -1;

diff --git a/lib/ecoli_tk_str.c b/lib/ecoli_tk_str.c
index e4b78def6d2e62c8212b41e70b578afabdfbd6ff..997f71785e2764877b806ebdc8ccfce73355915b 100644 (file)
--- a/lib/ecoli_tk_str.c
+++ b/lib/ecoli_tk_str.c
@@ -132,22 +132,12 @@ static struct ec_tk_type ec_tk_str_type = {
        .parse = ec_tk_str_parse,
        .complete = ec_tk_str_complete,
        .desc = ec_tk_str_desc,
+       .size = sizeof(struct ec_tk_str),
        .free_priv = ec_tk_str_free_priv,
 };
 
 EC_TK_TYPE_REGISTER(ec_tk_str_type);
 
-struct ec_tk *ec_tk_str_new(const char *id)
-{
-       struct ec_tk *gen_tk = NULL;
-
-       gen_tk = ec_tk_new(id, &ec_tk_str_type, sizeof(struct ec_tk_str));
-       if (gen_tk == NULL)
-               return NULL;
-
-       return gen_tk;
-}
-
 int ec_tk_str_set_str(struct ec_tk *gen_tk, const char *str)
 {
        struct ec_tk_str *tk = (struct ec_tk_str *)gen_tk;
@@ -170,7 +160,7 @@ struct ec_tk *ec_tk_str(const char *id, const char *str)
 {
        struct ec_tk *gen_tk = NULL;
 
-       gen_tk = ec_tk_str_new(id);
+       gen_tk = __ec_tk_new(&ec_tk_str_type, id);
        if (gen_tk == NULL)
                goto fail;
 

diff --git a/lib/ecoli_tk_subset.c b/lib/ecoli_tk_subset.c
index b73eb04451abae2e99b1a45378be4c256436d8d0..6762eeeb0959124f083ddde67168bedd60af6b26 100644 (file)
--- a/lib/ecoli_tk_subset.c
+++ b/lib/ecoli_tk_subset.c
@@ -342,30 +342,15 @@ int ec_tk_subset_add(struct ec_tk *gen_tk, struct ec_tk *child)
 }
 
 static struct ec_tk_type ec_tk_subset_type = {
-       .name = "tk_subset",
+       .name = "subset",
        .parse = ec_tk_subset_parse,
        .complete = ec_tk_subset_complete,
+       .size = sizeof(struct ec_tk_subset),
        .free_priv = ec_tk_subset_free_priv,
 };
 
 EC_TK_TYPE_REGISTER(ec_tk_subset_type);
 
-struct ec_tk *ec_tk_subset(const char *id)
-{
-       struct ec_tk *gen_tk = NULL;
-       struct ec_tk_subset *tk = NULL;
-
-       gen_tk = ec_tk_new(id, &ec_tk_subset_type, sizeof(*tk));
-       if (gen_tk == NULL)
-               return NULL;
-
-       tk = (struct ec_tk_subset *)gen_tk;
-       tk->table = NULL;
-       tk->len = 0;
-
-       return gen_tk;
-}
-
 struct ec_tk *__ec_tk_subset(const char *id, ...)
 {
        struct ec_tk *gen_tk = NULL;
@@ -376,7 +361,7 @@ struct ec_tk *__ec_tk_subset(const char *id, ...)
 
        va_start(ap, id);
 
-       gen_tk = ec_tk_subset(id);
+       gen_tk = __ec_tk_new(&ec_tk_subset_type, id);
        tk = (struct ec_tk_subset *)gen_tk;
        if (tk == NULL)
                fail = 1;;

diff --git a/lib/ecoli_tk_weakref.c b/lib/ecoli_tk_weakref.c
index cd68d2581fbfc56085626c769377b612d384385c..6ce9a329de63ab779cac13af08028ab0d9152dda 100644 (file)
--- a/lib/ecoli_tk_weakref.c
+++ b/lib/ecoli_tk_weakref.c
@@ -66,24 +66,11 @@ static struct ec_tk_type ec_tk_weakref_type = {
        .name = "weakref",
        .parse = ec_tk_weakref_parse,
        .complete = ec_tk_weakref_complete,
+       .size = sizeof(struct ec_tk_weakref),
 };
 
 EC_TK_TYPE_REGISTER(ec_tk_weakref_type);
 
-struct ec_tk *ec_tk_weakref_empty(const char *id)
-{
-       struct ec_tk_weakref *tk = NULL;
-
-       tk = (struct ec_tk_weakref *)ec_tk_new(id,
-               &ec_tk_weakref_type, sizeof(*tk));
-       if (tk == NULL)
-               return NULL;
-
-       tk->child = NULL;
-
-       return &tk->gen;
-}
-
 int ec_tk_weakref_set(struct ec_tk *gen_tk, struct ec_tk *child)
 {
        struct ec_tk_weakref *tk = (struct ec_tk_weakref *)gen_tk;
@@ -112,7 +99,7 @@ struct ec_tk *ec_tk_weakref(const char *id, struct ec_tk *child)
        if (child == NULL)
                return NULL;
 
-       gen_tk = ec_tk_weakref_empty(id);
+       gen_tk = __ec_tk_new(&ec_tk_weakref_type, id);
        if (gen_tk == NULL)
                return NULL;
 

diff --git a/lib/main-readline.c b/lib/main-readline.c
index e79795386698013423ee8181dfac4d97f446c0c4..241d2c9b983ff0b765794b782aac3b5edc3a1ec1 100644 (file)
--- a/lib/main-readline.c
+++ b/lib/main-readline.c
@@ -173,7 +173,7 @@ static int create_commands(void)
 {
        struct ec_tk *cmdlist = NULL, *cmd = NULL;
 
-       cmdlist = ec_tk_or(NULL);
+       cmdlist = ec_tk_new("or", NULL);
        if (cmdlist == NULL)
                goto fail;
 

diff --git a/lib/todo.txt b/lib/todo.txt
index f90f008036bc545ccd9d1c1a0e9074196fe1092a..6791965cccf2a92755d51f79a5d4371ca5c63e52 100644 (file)
--- a/lib/todo.txt
+++ b/lib/todo.txt
@@ -10,19 +10,26 @@ cleanup
 =======
 
 - check XXX in code
-- remove the _new() functions
+X remove the _new() functions
 - add a tk vector type: will be used in several nodes (ex: or, seq, ...)
 - check allocation model everywhere
 - checkpatch?
 - use linux style (update .emacs)
 - better logs
 - return values
+- use errno when returning pointers
 - missing static / const
 - license: "s/neither the name...may/the names of its contributors may not/"
 - check all completion nodes
 - split ecoli_tk.h
 - cache results when appropriate?
 - size_t or unsigned int?
+- rename:
+  - ec_tk -> ec_node
+  - ec_parsed_tk -> ec_parsed
+  - ec_completed_tk -> ec_completed
+  - tk, gen_tk, token, ... -> node
+  - tokens -> input_str / input_strvec ?
 
 logs
 ====