libsmartcols: (filter) cleanup data types

* split placeholders (e.g. column name) and data types
* make data type enums independent on params

Signed-off-by: Karel Zak <kzak@redhat.com>

diff --git a/libsmartcols/src/filter-expr.c b/libsmartcols/src/filter-expr.c
index 59e5df7888649b8dda6829ff64f5fdf90a26d03d..f782e2d2be20a9ab8e7b40321605efb52090c609 100644 (file)
--- a/libsmartcols/src/filter-expr.c
+++ b/libsmartcols/src/filter-expr.c
@@ -86,6 +86,7 @@ void filter_dump_expr(struct ul_jsonwrt *json, struct filter_expr *n)
        ul_jsonwrt_object_close(json);
 }
 
+
 int filter_eval_expr(struct libscols_filter *fltr, struct filter_expr *n,
                     struct libscols_line *ln, int *status)
 {

diff --git a/libsmartcols/src/filter-param.c b/libsmartcols/src/filter-param.c
index a5ef6abc27b234b6a140b8d4c0f9954abb94b970..a67acf02ae16a54fb6497cac8793a6a57ec5ab9d 100644 (file)
--- a/libsmartcols/src/filter-param.c
+++ b/libsmartcols/src/filter-param.c
@@ -7,7 +7,8 @@
 
 struct filter_node *filter_new_param(
                struct libscols_filter *fltr,
-               enum filter_ptype type,
+               enum filter_data type,
+               enum filter_holder holder,
                void *data)
 {
        char *p;
@@ -15,10 +16,11 @@ struct filter_node *filter_new_param(
                                        F_NODE_PARAM,
                                        sizeof(struct filter_param));
        n->type = type;
+       n->holder = holder;
        INIT_LIST_HEAD(&n->pr_params);
 
        switch (type) {
-       case F_PARAM_STRING:
+       case F_DATA_STRING:
                p = data;
                if (*p == '"') {
                        /* remove quotation marks */
@@ -28,18 +30,25 @@ struct filter_node *filter_new_param(
                        data = p + 1;
                }
                /* fallthrough */
-       case F_PARAM_NAME:
-               n->val.str = strdup((char *) data);
-               break;
-       case F_PARAM_NUMBER:
+       case F_DATA_NUMBER:
                n->val.num = *((unsigned long long *) data);
                break;
-       case F_PARAM_FLOAT:
+       case F_DATA_FLOAT:
                n->val.fnum = *((long double *) data);
                break;
-       case F_PARAM_BOOLEAN:
+       case F_DATA_BOOLEAN:
                n->val.boolean = *((bool *) data) == 0 ? 0 : 1;
                break;
+       default:
+               break;
+       }
+
+       switch (holder) {
+       case F_HOLDER_COLUMN:
+               n->val.str = strdup((char *) data);
+               break;
+       default:
+               break;
        }
 
        list_add_tail(&n->pr_params, &fltr->params);
@@ -49,7 +58,7 @@ struct filter_node *filter_new_param(
 
 void filter_free_param(struct filter_param *n)
 {
-       if (n->type == F_PARAM_NAME || n->type == F_PARAM_STRING)
+       if (n->type == F_DATA_STRING || n->holder == F_HOLDER_COLUMN)
                free(n->val.str);
 
        list_del_init(&n->pr_params);
@@ -62,22 +71,30 @@ void filter_dump_param(struct ul_jsonwrt *json, struct filter_param *n)
        ul_jsonwrt_object_open(json, "param");
 
        switch (n->type) {
-       case F_PARAM_NAME:
-               ul_jsonwrt_value_s(json, "name", n->val.str);
-               break;
-       case F_PARAM_STRING:
+       case F_DATA_STRING:
                ul_jsonwrt_value_s(json, "string", n->val.str);
                break;
-       case F_PARAM_NUMBER:
+       case F_DATA_NUMBER:
                ul_jsonwrt_value_u64(json, "number", n->val.num);
                break;
-       case F_PARAM_FLOAT:
+       case F_DATA_FLOAT:
                ul_jsonwrt_value_double(json, "float", n->val.fnum);
                break;
-       case F_PARAM_BOOLEAN:
+       case F_DATA_BOOLEAN:
                ul_jsonwrt_value_boolean(json, "bool", n->val.boolean);
                break;
+       default:
+               break;
        }
+
+       switch (n->holder) {
+       case F_HOLDER_COLUMN:
+               ul_jsonwrt_value_s(json, "column", n->val.str);
+               break;
+       default:
+               break;
+       }
+
        ul_jsonwrt_object_close(json);
 }
 
@@ -89,18 +106,19 @@ int filter_eval_param(struct libscols_filter *fltr  __attribute__((__unused__)),
        int rc = 0;
 
        switch (n->type) {
-       case F_PARAM_NAME: /* TODO */
+       case F_DATA_NONE:
+               /* probably holder without not-yet defined type */
                break;
-       case F_PARAM_STRING:
+       case F_DATA_STRING:
                *status = n->val.str != NULL && *n->val.str != '\0';
                break;
-       case F_PARAM_NUMBER:
+       case F_DATA_NUMBER:
                *status = n->val.num != 0;
                break;
-       case F_PARAM_FLOAT:
+       case F_DATA_FLOAT:
                *status = n->val.fnum != 0.0;
                break;
-       case F_PARAM_BOOLEAN:
+       case F_DATA_BOOLEAN:
                *status = n->val.boolean != false;
                break;
        default:

diff --git a/libsmartcols/src/filter-parser.y b/libsmartcols/src/filter-parser.y
index 69506ae2bb9010786f9848a56837ec5cec6f7d99..cf03b4f2d913a2a6821971402d84a6583a66c50f 100644 (file)
--- a/libsmartcols/src/filter-parser.y
+++ b/libsmartcols/src/filter-parser.y
@@ -75,17 +75,17 @@ expr:
 ;
 
 param:
-       T_NUMBER        { $$ = filter_new_param(fltr, F_PARAM_NUMBER, (void *) (&$1)); }
-       | T_FLOAT       { $$ = filter_new_param(fltr, F_PARAM_FLOAT, (void *) (&$1)); }
-       | T_NAME        { $$ = filter_new_param(fltr, F_PARAM_NAME, (void *) $1); }
-       | T_STRING      { $$ = filter_new_param(fltr, F_PARAM_STRING, (void *) $1); }
+       T_NUMBER        { $$ = filter_new_param(fltr, F_DATA_NUMBER, 0, (void *) (&$1)); }
+       | T_FLOAT       { $$ = filter_new_param(fltr, F_DATA_FLOAT, 0, (void *) (&$1)); }
+       | T_NAME        { $$ = filter_new_param(fltr, F_DATA_NONE, F_HOLDER_COLUMN, (void *) $1); }
+       | T_STRING      { $$ = filter_new_param(fltr, F_DATA_STRING, 0, (void *) $1); }
        | T_TRUE        {
                bool x = true;
-               $$ = filter_new_param(fltr, F_PARAM_BOOLEAN, (void *) &x);
+               $$ = filter_new_param(fltr, F_DATA_BOOLEAN, 0, (void *) &x);
        }
        | T_FALSE       {
                bool x = false;
-               $$ = filter_new_param(fltr, F_PARAM_BOOLEAN, (void *) &x);
+               $$ = filter_new_param(fltr, F_DATA_BOOLEAN, 0, (void *) &x);
        }
 
 ;

diff --git a/libsmartcols/src/filter.c b/libsmartcols/src/filter.c
index 3bb2e3d3e7adc9eb4395aaa507e17f3a0b857b73..2cef954ed4aa64639b5f914fe951ee1d9adcb7bc 100644 (file)
--- a/libsmartcols/src/filter.c
+++ b/libsmartcols/src/filter.c
@@ -163,7 +163,7 @@ int scols_filter_next_name(struct libscols_filter *fltr,
 
        do {
                rc = filter_next_param(fltr, itr, &prm);
-               if (rc == 0 && prm->type == F_PARAM_NAME)
+               if (rc == 0 && prm->holder == F_HOLDER_COLUMN)
                        *name = prm->val.str;
        } while (rc == 0 && !*name);
 
@@ -179,7 +179,7 @@ int scols_filter_assign_column(struct libscols_filter *fltr,
 
        scols_reset_iter(&itr, SCOLS_ITER_FORWARD);
        while (filter_next_param(fltr, &itr, &prm) == 0) {
-               if (prm->type != F_PARAM_NAME || strcmp(name, prm->val.str) != 0)
+               if (prm->holder != F_HOLDER_COLUMN || strcmp(name, prm->val.str) != 0)
                        continue;
                prm->col = col;
                scols_ref_column(col);

diff --git a/libsmartcols/src/smartcolsP.h b/libsmartcols/src/smartcolsP.h
index 93fc6c633f2de9e58ade6b1ba2a8b9a7b6e5446f..db9ad3991d07e7a11ccecbe47c3a4e3884e4e193 100644 (file)
--- a/libsmartcols/src/smartcolsP.h
+++ b/libsmartcols/src/smartcolsP.h
@@ -482,21 +482,25 @@ static inline int has_group_children(struct libscols_line *ln)
  * Filter stuff
  */
 
+enum filter_data {
+       F_DATA_NONE,
+       F_DATA_STRING,
+       F_DATA_NUMBER,
+       F_DATA_FLOAT,
+       F_DATA_BOOLEAN
+};
+
+enum filter_holder {
+       F_HOLDER_NONE,
+       F_HOLDER_COLUMN         /* column name */
+};
+
 /* node types */
 enum filter_ntype {
        F_NODE_PARAM,
        F_NODE_EXPR
 };
 
-/* param types */
-enum filter_ptype {
-       F_PARAM_NUMBER,
-       F_PARAM_FLOAT,
-       F_PARAM_NAME,
-       F_PARAM_STRING,
-       F_PARAM_BOOLEAN
-};
-
 /* expresion types */
 enum filter_etype {
        F_EXPR_AND,
@@ -524,7 +528,8 @@ struct filter_node {
 
 struct filter_param {
        struct filter_node node;
-       enum filter_ptype type;
+       enum filter_data type;
+       enum filter_holder holder;
 
        union {
                char *str;
@@ -579,7 +584,8 @@ int filter_eval_expr(struct libscols_filter *fltr, struct filter_expr *n,
 
 /* required by parser */
 struct filter_node *filter_new_param(struct libscols_filter *filter,
-                                 enum filter_ptype type,
+                                 enum filter_data type,
+                                enum filter_holder holder,
                                 void *data);
 struct filter_node *filter_new_expr(struct libscols_filter *filter,
                                  enum filter_etype type,