lib/ecoli_node_re_lex.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2016, Olivier MATZ <zer0@droids-corp.org>
   3  */
   4
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <stdbool.h>
   8 #include <string.h>
   9 #include <regex.h>
  10 #include <errno.h>
  11
  12 #include <ecoli_malloc.h>
  13 #include <ecoli_log.h>
  14 #include <ecoli_test.h>
  15 #include <ecoli_strvec.h>
  16 #include <ecoli_node.h>
  17 #include <ecoli_parsed.h>
  18 #include <ecoli_node_many.h>
  19 #include <ecoli_node_or.h>
  20 #include <ecoli_node_str.h>
  21 #include <ecoli_node_int.h>
  22 #include <ecoli_node_re_lex.h>
  23
  24 EC_LOG_TYPE_REGISTER(node_re_lex);
  25
  26 struct regexp_pattern {
  27         char *pattern;
  28         regex_t r;
  29         bool keep;
  30 };
  31
  32 struct ec_node_re_lex {
  33         struct ec_node gen;
  34         struct ec_node *child;
  35         struct regexp_pattern *table;
  36         size_t len;
  37 };
  38
  39 static struct ec_strvec *
  40 tokenize(struct regexp_pattern *table, size_t table_len, const char *str)
  41 {
  42         struct ec_strvec *strvec = NULL;
  43         char *dup = NULL;
  44         char c;
  45         size_t len, off = 0;
  46         size_t i;
  47         int ret;
  48         regmatch_t pos;
  49
  50         dup = ec_strdup(str);
  51         if (dup == NULL)
  52                 goto fail;
  53
  54         strvec = ec_strvec();
  55         if (strvec == NULL)
  56                 goto fail;
  57
  58         len = strlen(dup);
  59         while (off < len) {
  60                 for (i = 0; i < table_len; i++) {
  61                         ret = regexec(&table[i].r, &dup[off], 1, &pos, 0);
  62                         if (ret != 0)
  63                                 continue;
  64                         if (pos.rm_so != 0 || pos.rm_eo == 0) {
  65                                 ret = -1;
  66                                 continue;
  67                         }
  68
  69                         if (table[i].keep == 0)
  70                                 break;
  71
  72                         c = dup[pos.rm_eo + off];
  73                         dup[pos.rm_eo + off] = '\0';
  74                         EC_LOG(EC_LOG_DEBUG, "re_lex match <%s>\n", &dup[off]);
  75                         if (ec_strvec_add(strvec, &dup[off]) < 0)
  76                                 goto fail;
  77
  78                         dup[pos.rm_eo + off] = c;
  79                         break;
  80                 }
  81
  82                 if (ret != 0)
  83                         goto fail;
  84
  85                 off += pos.rm_eo;
  86         }
  87
  88         ec_free(dup);
  89         return strvec;
  90
  91 fail:
  92         ec_free(dup);
  93         ec_strvec_free(strvec);
  94         return NULL;
  95 }
  96
  97 static int
  98 ec_node_re_lex_parse(const struct ec_node *gen_node,
  99                 struct ec_parsed *state,
 100                 const struct ec_strvec *strvec)
 101 {
 102         struct ec_node_re_lex *node = (struct ec_node_re_lex *)gen_node;
 103         struct ec_strvec *new_vec = NULL;
 104         struct ec_parsed *child_parsed;
 105         const char *str;
 106         int ret;
 107
 108         if (ec_strvec_len(strvec) == 0) {
 109                 new_vec = ec_strvec();
 110         } else {
 111                 str = ec_strvec_val(strvec, 0);
 112                 new_vec = tokenize(node->table, node->len, str);
 113         }
 114         if (new_vec == NULL) {
 115                 ret = -ENOMEM;
 116                 goto fail;
 117         }
 118
 119         ret = ec_node_parse_child(node->child, state, new_vec);
 120         if (ret < 0)
 121                 goto fail;
 122
 123         if ((unsigned)ret == ec_strvec_len(new_vec)) {
 124                 ret = 1;
 125         } else if (ret != EC_PARSED_NOMATCH) {
 126                 child_parsed = ec_parsed_get_last_child(state);
 127                 ec_parsed_del_child(state, child_parsed);
 128                 ec_parsed_free(child_parsed);
 129                 ret = EC_PARSED_NOMATCH;
 130         }
 131
 132         ec_strvec_free(new_vec);
 133         new_vec = NULL;
 134
 135         return ret;
 136
 137  fail:
 138         ec_strvec_free(new_vec);
 139         return ret;
 140 }
 141
 142 static void ec_node_re_lex_free_priv(struct ec_node *gen_node)
 143 {
 144         struct ec_node_re_lex *node = (struct ec_node_re_lex *)gen_node;
 145         unsigned int i;
 146
 147         for (i = 0; i < node->len; i++) {
 148                 ec_free(node->table[i].pattern);
 149                 regfree(&node->table[i].r);
 150         }
 151
 152         ec_free(node->table);
 153         ec_node_free(node->child);
 154 }
 155
 156 static struct ec_node_type ec_node_re_lex_type = {
 157         .name = "re_lex",
 158         .parse = ec_node_re_lex_parse,
 159         //.complete = ec_node_re_lex_complete, //XXX
 160         .size = sizeof(struct ec_node_re_lex),
 161         .free_priv = ec_node_re_lex_free_priv,
 162 };
 163
 164 EC_NODE_TYPE_REGISTER(ec_node_re_lex_type);
 165
 166 int ec_node_re_lex_add(struct ec_node *gen_node, const char *pattern, int keep)
 167 {
 168         struct ec_node_re_lex *node = (struct ec_node_re_lex *)gen_node;
 169         struct regexp_pattern *table;
 170         int ret;
 171         char *pat_dup = NULL;
 172
 173         ret = -ENOMEM;
 174         pat_dup = ec_strdup(pattern);
 175         if (pat_dup == NULL)
 176                 goto fail;
 177
 178         ret = -ENOMEM;
 179         table = ec_realloc(node->table, sizeof(*table) * (node->len + 1));
 180         if (table == NULL)
 181                 goto fail;
 182
 183         ret = regcomp(&table[node->len].r, pattern, REG_EXTENDED);
 184         if (ret != 0) {
 185                 EC_LOG(EC_LOG_ERR,
 186                         "Regular expression <%s> compilation failed: %d\n",
 187                         pattern, ret);
 188                 if (ret == REG_ESPACE)
 189                         ret = -ENOMEM;
 190                 else
 191                         ret = -EINVAL;
 192
 193                 goto fail;
 194         }
 195
 196         table[node->len].pattern = pat_dup;
 197         table[node->len].keep = keep;
 198         node->len++;
 199         node->table = table;
 200
 201         return 0;
 202
 203 fail:
 204         ec_free(pat_dup);
 205         return ret;
 206 }
 207
 208 struct ec_node *ec_node_re_lex(const char *id, struct ec_node *child)
 209 {
 210         struct ec_node_re_lex *node = NULL;
 211
 212         if (child == NULL)
 213                 return NULL;
 214
 215         node = (struct ec_node_re_lex *)__ec_node(&ec_node_re_lex_type, id);
 216         if (node == NULL) {
 217                 ec_node_free(child);
 218                 return NULL;
 219         }
 220
 221         node->child = child;
 222
 223         return &node->gen;
 224 }
 225
 226 /* LCOV_EXCL_START */
 227 static int ec_node_re_lex_testcase(void)
 228 {
 229         struct ec_node *node;
 230         int ret, testres = 0;
 231
 232         node = ec_node_re_lex(EC_NO_ID,
 233                 ec_node_many(EC_NO_ID,
 234                         EC_NODE_OR(EC_NO_ID,
 235                                 ec_node_str(EC_NO_ID, "foo"),
 236                                 ec_node_str(EC_NO_ID, "bar"),
 237                                 ec_node_int(EC_NO_ID, 0, 1000, 0)
 238                         ), 0, 0
 239                 )
 240         );
 241         if (node == NULL) {
 242                 EC_LOG(EC_LOG_ERR, "cannot create node\n");
 243                 return -1;
 244         }
 245
 246         ret = ec_node_re_lex_add(node, "[a-zA-Z]+", 1);
 247         testres |= EC_TEST_CHECK(ret == 0, "cannot add regexp");
 248         ret = ec_node_re_lex_add(node, "[0-9]+", 1);
 249         testres |= EC_TEST_CHECK(ret == 0, "cannot add regexp");
 250         ret = ec_node_re_lex_add(node, "=", 1);
 251         testres |= EC_TEST_CHECK(ret == 0, "cannot add regexp");
 252         ret = ec_node_re_lex_add(node, "-", 1);
 253         testres |= EC_TEST_CHECK(ret == 0, "cannot add regexp");
 254         ret = ec_node_re_lex_add(node, "\\+", 1);
 255         testres |= EC_TEST_CHECK(ret == 0, "cannot add regexp");
 256         ret = ec_node_re_lex_add(node, "[       ]+", 0);
 257         testres |= EC_TEST_CHECK(ret == 0, "cannot add regexp");
 258         if (ret != 0) {
 259                 EC_LOG(EC_LOG_ERR, "cannot add regexp to node\n");
 260                 ec_node_free(node);
 261                 return -1;
 262         }
 263
 264         testres |= EC_TEST_CHECK_PARSE(node, 1, "  foo bar  324 bar234");
 265         testres |= EC_TEST_CHECK_PARSE(node, 1, "foo bar324");
 266         testres |= EC_TEST_CHECK_PARSE(node, 1, "");
 267         testres |= EC_TEST_CHECK_PARSE(node, -1, "foobar");
 268
 269         ec_node_free(node);
 270
 271         return testres;
 272 }
 273 /* LCOV_EXCL_STOP */
 274
 275 static struct ec_test ec_node_re_lex_test = {
 276         .name = "node_re_lex",
 277         .test = ec_node_re_lex_testcase,
 278 };
 279
 280 EC_TEST_REGISTER(ec_node_re_lex_test);