2 * Copyright (c) 2016, Olivier MATZ <zer0@droids-corp.org>
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * * Neither the name of the University of California, Berkeley nor the
13 * names of its contributors may be used to endorse or promote products
14 * derived from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 #include <ecoli_assert.h>
36 #include <ecoli_malloc.h>
37 #include <ecoli_strvec.h>
38 #include <ecoli_keyval.h>
39 #include <ecoli_log.h>
40 #include <ecoli_node.h>
41 #include <ecoli_parsed.h>
43 TAILQ_HEAD(ec_parsed_list, ec_parsed);
45 /* XXX idea for parse: maintain a "cursor" ?
47 struct ec_parsed_tree *root;
48 stuct ec_parsed_tree *cursor;
53 TAILQ_ENTRY(ec_parsed) next;
54 struct ec_parsed_list children;
55 struct ec_parsed *parent;
56 const struct ec_node *node;
57 struct ec_strvec *strvec;
58 struct ec_keyval *attrs;
61 static int __ec_node_parse_child(struct ec_node *node, struct ec_parsed *state,
62 bool is_root, const struct ec_strvec *strvec)
64 struct ec_strvec *match_strvec;
65 struct ec_parsed *child;
68 /* build the node if required */
69 if (node->type->build != NULL) {
70 if ((node->flags & EC_NODE_F_BUILT) == 0) {
71 ret = node->type->build(node);
76 node->flags |= EC_NODE_F_BUILT;
78 if (node->type->parse == NULL)
82 child = ec_parsed(node);
86 ec_parsed_add_child(state, child);
90 ret = node->type->parse(node, child, strvec);
91 if (ret < 0) // XXX should we free state, child?
94 if (ret == EC_PARSED_NOMATCH) {
96 ec_parsed_del_child(state, child);
97 assert(TAILQ_EMPTY(&child->children));
98 ec_parsed_free(child);
103 match_strvec = ec_strvec_ndup(strvec, 0, ret);
104 if (match_strvec == NULL)
107 child->strvec = match_strvec;
112 int ec_node_parse_child(struct ec_node *node, struct ec_parsed *state,
113 const struct ec_strvec *strvec)
115 assert(state != NULL);
116 return __ec_node_parse_child(node, state, false, strvec);
119 struct ec_parsed *ec_node_parse_strvec(struct ec_node *node,
120 const struct ec_strvec *strvec)
122 struct ec_parsed *parsed = ec_parsed(node);
128 ret = __ec_node_parse_child(node, parsed, true, strvec);
130 ec_parsed_free(parsed);
137 struct ec_parsed *ec_node_parse(struct ec_node *node, const char *str)
139 struct ec_strvec *strvec = NULL;
140 struct ec_parsed *parsed = NULL;
143 strvec = ec_strvec();
147 if (ec_strvec_add(strvec, str) < 0)
150 parsed = ec_node_parse_strvec(node, strvec);
154 ec_strvec_free(strvec);
158 ec_strvec_free(strvec);
159 ec_parsed_free(parsed);
163 struct ec_parsed *ec_parsed(const struct ec_node *node)
165 struct ec_parsed *parsed = NULL;
167 parsed = ec_calloc(1, sizeof(*parsed));
171 TAILQ_INIT(&parsed->children);
174 parsed->attrs = ec_keyval();
175 if (parsed->attrs == NULL)
182 ec_keyval_free(parsed->attrs);
188 static struct ec_parsed *
189 __ec_parsed_dup(const struct ec_parsed *root, const struct ec_parsed *ref,
190 struct ec_parsed **new_ref)
192 struct ec_parsed *dup = NULL;
193 struct ec_parsed *child, *dup_child;
194 struct ec_keyval *attrs = NULL;
199 dup = ec_parsed(root->node);
206 attrs = ec_keyval_dup(root->attrs);
209 ec_keyval_free(dup->attrs);
212 if (root->strvec != NULL) {
213 dup->strvec = ec_strvec_dup(root->strvec);
214 if (dup->strvec == NULL)
218 TAILQ_FOREACH(child, &root->children, next) {
219 dup_child = __ec_parsed_dup(child, ref, new_ref);
220 if (dup_child == NULL)
222 ec_parsed_add_child(dup, dup_child);
232 struct ec_parsed *ec_parsed_dup(struct ec_parsed *parsed) //XXX const
234 struct ec_parsed *root, *dup_root, *dup = NULL;
236 root = ec_parsed_get_root(parsed);
237 dup_root = __ec_parsed_dup(root, parsed, &dup);
238 if (dup_root == NULL)
245 void ec_parsed_free_children(struct ec_parsed *parsed)
247 struct ec_parsed *child;
252 while (!TAILQ_EMPTY(&parsed->children)) {
253 child = TAILQ_FIRST(&parsed->children);
254 TAILQ_REMOVE(&parsed->children, child, next);
255 ec_parsed_free(child);
259 void ec_parsed_free(struct ec_parsed *parsed)
264 // assert(parsed->parent == NULL); XXX
266 // parsed = ec_parsed_get_root(parsed);
268 ec_parsed_free_children(parsed);
269 ec_strvec_free(parsed->strvec);
270 ec_keyval_free(parsed->attrs);
274 static void __ec_parsed_dump(FILE *out,
275 const struct ec_parsed *parsed, size_t indent)
277 struct ec_parsed *child;
278 const struct ec_strvec *vec;
280 const char *id = "none", *typename = "none";
282 if (parsed->node != NULL) {
283 if (parsed->node->id != NULL)
284 id = parsed->node->id;
285 typename = parsed->node->type->name;
289 for (i = 0; i < indent; i++) {
296 fprintf(out, "node_type=%s id=%s vec=", typename, id);
297 vec = ec_parsed_strvec(parsed);
298 ec_strvec_dump(out, vec);
300 TAILQ_FOREACH(child, &parsed->children, next)
301 __ec_parsed_dump(out, child, indent + 2);
304 void ec_parsed_dump(FILE *out, const struct ec_parsed *parsed)
306 fprintf(out, "------------------- parsed dump:\n"); //XXX
308 if (parsed == NULL) {
309 fprintf(out, "parsed is NULL, error in parse\n");
313 /* only exist if it does not match (strvec == NULL) and if it
314 * does not have children: an incomplete parse, like those
315 * generated by complete() don't match but have children that
317 if (!ec_parsed_matches(parsed) && TAILQ_EMPTY(&parsed->children)) {
318 fprintf(out, "no match\n");
322 __ec_parsed_dump(out, parsed, 0);
325 void ec_parsed_add_child(struct ec_parsed *parsed,
326 struct ec_parsed *child)
328 TAILQ_INSERT_TAIL(&parsed->children, child, next);
329 child->parent = parsed;
332 // XXX we can remove the first arg ? parsed == child->parent ?
333 void ec_parsed_del_child(struct ec_parsed *parsed, // XXX rename del in unlink?
334 struct ec_parsed *child)
336 TAILQ_REMOVE(&parsed->children, child, next);
337 child->parent = NULL;
341 ec_parsed_get_first_child(const struct ec_parsed *parsed)
343 return TAILQ_FIRST(&parsed->children);
347 ec_parsed_get_last_child(const struct ec_parsed *parsed)
349 return TAILQ_LAST(&parsed->children, ec_parsed_list);
352 struct ec_parsed *ec_parsed_get_next(const struct ec_parsed *parsed)
354 return TAILQ_NEXT(parsed, next);
357 bool ec_parsed_has_child(const struct ec_parsed *parsed)
359 return !TAILQ_EMPTY(&parsed->children);
362 const struct ec_node *ec_parsed_get_node(const struct ec_parsed *parsed)
367 void ec_parsed_del_last_child(struct ec_parsed *parsed) // rename in free
369 struct ec_parsed *child;
371 child = ec_parsed_get_last_child(parsed);
372 ec_parsed_del_child(parsed, child);
373 ec_parsed_free(child);
376 struct ec_parsed *ec_parsed_get_root(struct ec_parsed *parsed)
381 while (parsed->parent != NULL)
382 parsed = parsed->parent;
387 struct ec_parsed *ec_parsed_get_parent(struct ec_parsed *parsed)
392 return parsed->parent;
395 struct ec_parsed *ec_parsed_iter_next(struct ec_parsed *parsed)
397 struct ec_parsed *child, *parent, *next;
399 child = TAILQ_FIRST(&parsed->children);
402 parent = parsed->parent;
403 while (parent != NULL) {
404 next = TAILQ_NEXT(parsed, next);
408 parent = parsed->parent;
413 struct ec_parsed *ec_parsed_find_first(struct ec_parsed *parsed,
416 struct ec_parsed *child, *ret;
421 if (parsed->node != NULL &&
422 parsed->node->id != NULL &&
423 !strcmp(parsed->node->id, id))
426 TAILQ_FOREACH(child, &parsed->children, next) {
427 ret = ec_parsed_find_first(child, id);
436 ec_parsed_get_attrs(struct ec_parsed *parsed)
441 return parsed->attrs;
444 const struct ec_strvec *ec_parsed_strvec(const struct ec_parsed *parsed)
446 if (parsed == NULL || parsed->strvec == NULL)
449 return parsed->strvec;
452 /* number of strings in the parsed vector */
453 size_t ec_parsed_len(const struct ec_parsed *parsed)
455 if (parsed == NULL || parsed->strvec == NULL)
458 return ec_strvec_len(parsed->strvec);
461 size_t ec_parsed_matches(const struct ec_parsed *parsed)
466 if (parsed->strvec == NULL)