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