libsmartcols/src/filter-expr.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <unistd.h>
   5
   6 #include "smartcolsP.h"
   7
   8 struct filter_node *filter_new_expr(
   9                         struct libscols_filter *fltr __attribute__((__unused__)),
  10                         enum filter_etype type,
  11                         struct filter_node *left,
  12                         struct filter_node *right)
  13 {
  14         struct filter_expr *n = (struct filter_expr *) __filter_new_node(
  15                                         F_NODE_EXPR, sizeof(struct filter_expr));
  16
  17         n->type = type;
  18         switch (type) {
  19         case F_EXPR_AND:
  20         case F_EXPR_OR:
  21         case F_EXPR_EQ:
  22         case F_EXPR_NE:
  23         case F_EXPR_LE:
  24         case F_EXPR_LT:
  25         case F_EXPR_GE:
  26         case F_EXPR_GT:
  27         case F_EXPR_REG:
  28         case F_EXPR_NREG:
  29                 n->left = left;
  30                 n->right = right;
  31                 break;
  32         case F_EXPR_NEG:
  33                 n->right = right;
  34                 break;
  35
  36         }
  37         return (struct filter_node *) n;
  38 }
  39
  40 void filter_free_expr(struct filter_expr *n)
  41 {
  42         filter_unref_node(n->left);
  43         filter_unref_node(n->right);
  44         free(n);
  45 }
  46
  47 static const char *expr_type_as_string(struct filter_expr *n)
  48 {
  49         switch (n->type) {
  50         case F_EXPR_AND:
  51                 return "AND";
  52         case F_EXPR_OR:
  53                 return "OR";
  54         case F_EXPR_EQ:
  55                 return "EQ";
  56         case F_EXPR_NE:
  57                 return "NE";
  58         case F_EXPR_LE:
  59                 return "LE";
  60         case F_EXPR_LT:
  61                 return "LT";
  62         case F_EXPR_GE:
  63                 return "GE";
  64         case F_EXPR_GT:
  65                 return "GT";
  66         case F_EXPR_REG:
  67                 return "REG";
  68         case F_EXPR_NREG:
  69                 return "NREG";
  70         case F_EXPR_NEG:
  71                 return "NOT";
  72         }
  73         return "";
  74 }
  75
  76 void filter_dump_expr(struct ul_jsonwrt *json, struct filter_expr *n)
  77 {
  78         ul_jsonwrt_object_open(json, "expr");
  79         ul_jsonwrt_value_s(json, "type", expr_type_as_string(n));
  80
  81         if (n->left)
  82                 filter_dump_node(json, n->left);
  83         if (n->right)
  84                 filter_dump_node(json, n->right);
  85
  86         ul_jsonwrt_object_close(json);
  87 }
  88
  89
  90 int filter_eval_expr(struct libscols_filter *fltr, struct filter_expr *n,
  91                      struct libscols_line *ln, int *status)
  92 {
  93         int rc = 0;
  94         enum filter_etype oper = n->type;
  95
  96         /* logical operators */
  97         switch (oper) {
  98         case F_EXPR_AND:
  99                 rc = filter_eval_node(fltr, n->left, ln, status);
 100                 if (rc == 0 && *status)
 101                         rc = filter_eval_node(fltr, n->right, ln, status);
 102                 return rc;
 103         case F_EXPR_OR:
 104                 rc = filter_eval_node(fltr, n->left, ln, status);
 105                 if (rc == 0 && !*status)
 106                         rc = filter_eval_node(fltr, n->right, ln, status);
 107                 return rc;
 108         case F_EXPR_NEG:
 109                 rc = filter_eval_node(fltr, n->right, ln, status);
 110                 if (rc == 0)
 111                         *status = !*status;
 112                 return rc;
 113         default:
 114                 break;
 115         }
 116
 117         return rc;
 118 }