lib/ecoli_parsed.c

   1 /*
   2  * Copyright (c) 2016, Olivier MATZ <zer0@droids-corp.org>
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   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.
  15  *
  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.
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <stdint.h>
  31 #include <string.h>
  32 #include <assert.h>
  33 #include <errno.h>
  34
  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>
  42
  43 TAILQ_HEAD(ec_parsed_list, ec_parsed);
  44
  45 struct ec_parsed {
  46         TAILQ_ENTRY(ec_parsed) next;
  47         struct ec_parsed_list children;
  48         struct ec_parsed *parent;
  49         const struct ec_node *node;
  50         struct ec_strvec *strvec;
  51         struct ec_keyval *attrs;
  52 };
  53
  54 static int __ec_node_parse_child(struct ec_node *node, struct ec_parsed *state,
  55                                 bool is_root, const struct ec_strvec *strvec)
  56 {
  57         struct ec_strvec *match_strvec;
  58         struct ec_parsed *child;
  59         int ret;
  60
  61         /* build the node if required */
  62         if (node->type->build != NULL) {
  63                 if ((node->flags & EC_NODE_F_BUILT) == 0) {
  64                         ret = node->type->build(node);
  65                         if (ret < 0)
  66                                 return ret;
  67                 }
  68         }
  69         node->flags |= EC_NODE_F_BUILT;
  70
  71         if (node->type->parse == NULL)
  72                 return -ENOTSUP;
  73
  74         if (!is_root) {
  75                 child = ec_parsed();
  76                 if (child == NULL)
  77                         return -ENOMEM;
  78
  79                 ec_parsed_add_child(state, child);
  80         } else {
  81                 child = state;
  82         }
  83         ec_parsed_set_node(child, node);
  84         ret = node->type->parse(node, child, strvec);
  85         if (ret < 0) // XXX should we free state, child?
  86                 return ret;
  87
  88         if (ret == EC_PARSED_NOMATCH) {
  89                 if (!is_root) {
  90                         ec_parsed_del_child(state, child);
  91                         assert(TAILQ_EMPTY(&child->children));
  92                         ec_parsed_free(child);
  93                 }
  94                 return ret;
  95         }
  96
  97         match_strvec = ec_strvec_ndup(strvec, 0, ret);
  98         if (match_strvec == NULL)
  99                 return -ENOMEM;
 100
 101         child->strvec = match_strvec;
 102
 103         return ret;
 104 }
 105
 106 int ec_node_parse_child(struct ec_node *node, struct ec_parsed *state,
 107                         const struct ec_strvec *strvec)
 108 {
 109         assert(state != NULL);
 110         return __ec_node_parse_child(node, state, false, strvec);
 111 }
 112
 113 struct ec_parsed *ec_node_parse_strvec(struct ec_node *node,
 114                                 const struct ec_strvec *strvec)
 115 {
 116         struct ec_parsed *parsed = ec_parsed();
 117         int ret;
 118
 119         if (parsed == NULL)
 120                 return NULL;
 121
 122         ret = __ec_node_parse_child(node, parsed, true, strvec);
 123         if (ret < 0) {
 124                 ec_parsed_free(parsed);
 125                 return NULL;
 126         }
 127
 128         return parsed;
 129 }
 130
 131 struct ec_parsed *ec_node_parse(struct ec_node *node, const char *str)
 132 {
 133         struct ec_strvec *strvec = NULL;
 134         struct ec_parsed *parsed = NULL;
 135
 136         errno = ENOMEM;
 137         strvec = ec_strvec();
 138         if (strvec == NULL)
 139                 goto fail;
 140
 141         if (ec_strvec_add(strvec, str) < 0)
 142                 goto fail;
 143
 144         parsed = ec_node_parse_strvec(node, strvec);
 145         if (parsed == NULL)
 146                 goto fail;
 147
 148         ec_strvec_free(strvec);
 149         return parsed;
 150
 151  fail:
 152         ec_strvec_free(strvec);
 153         ec_parsed_free(parsed);
 154         return NULL;
 155 }
 156
 157 struct ec_parsed *ec_parsed(void)
 158 {
 159         struct ec_parsed *parsed = NULL;
 160
 161         parsed = ec_calloc(1, sizeof(*parsed));
 162         if (parsed == NULL)
 163                 goto fail;
 164
 165         TAILQ_INIT(&parsed->children);
 166
 167         parsed->attrs = ec_keyval();
 168         if (parsed->attrs == NULL)
 169                 goto fail;
 170
 171         return parsed;
 172
 173  fail:
 174         if (parsed != NULL)
 175                 ec_keyval_free(parsed->attrs);
 176         ec_free(parsed);
 177
 178         return NULL;
 179 }
 180
 181 static struct ec_parsed *
 182 __ec_parsed_dup(const struct ec_parsed *root, const struct ec_parsed *ref,
 183                 struct ec_parsed **new_ref)
 184 {
 185         struct ec_parsed *dup = NULL;
 186         struct ec_parsed *child, *dup_child;
 187         struct ec_keyval *attrs = NULL;
 188
 189         if (root == NULL)
 190                 return NULL;
 191
 192         dup = ec_parsed();
 193         if (dup == NULL)
 194                 return NULL;
 195
 196         if (root == ref)
 197                 *new_ref = dup;
 198
 199         attrs = ec_keyval_dup(root->attrs);
 200         if (attrs == NULL)
 201                 goto fail;
 202         ec_keyval_free(dup->attrs);
 203         dup->attrs = attrs;
 204         dup->node = root->node;
 205
 206         if (root->strvec != NULL) {
 207                 dup->strvec = ec_strvec_dup(root->strvec);
 208                 if (dup->strvec == NULL)
 209                         goto fail;
 210         }
 211
 212         TAILQ_FOREACH(child, &root->children, next) {
 213                 dup_child = __ec_parsed_dup(child, ref, new_ref);
 214                 if (dup_child == NULL)
 215                         goto fail;
 216                 ec_parsed_add_child(dup, dup_child);
 217         }
 218
 219         return dup;
 220
 221 fail:
 222         ec_parsed_free(dup);
 223         return NULL;
 224 }
 225
 226 struct ec_parsed *ec_parsed_dup(struct ec_parsed *parsed) //XXX const
 227 {
 228         struct ec_parsed *root, *dup_root, *dup = NULL;
 229
 230         root = ec_parsed_get_root(parsed);
 231         dup_root = __ec_parsed_dup(root, parsed, &dup);
 232         if (dup_root == NULL)
 233                 return NULL;
 234         assert(dup != NULL);
 235
 236         return dup;
 237 }
 238
 239 void ec_parsed_free_children(struct ec_parsed *parsed)
 240 {
 241         struct ec_parsed *child;
 242
 243         if (parsed == NULL)
 244                 return;
 245
 246         while (!TAILQ_EMPTY(&parsed->children)) {
 247                 child = TAILQ_FIRST(&parsed->children);
 248                 TAILQ_REMOVE(&parsed->children, child, next);
 249                 ec_parsed_free(child);
 250         }
 251 }
 252
 253 void ec_parsed_free(struct ec_parsed *parsed)
 254 {
 255         if (parsed == NULL)
 256                 return;
 257
 258         // assert(parsed->parent == NULL); XXX
 259         // or
 260         // parsed = ec_parsed_get_root(parsed);
 261
 262         ec_parsed_free_children(parsed);
 263         ec_strvec_free(parsed->strvec);
 264         ec_keyval_free(parsed->attrs);
 265         ec_free(parsed);
 266 }
 267
 268 static void __ec_parsed_dump(FILE *out,
 269         const struct ec_parsed *parsed, size_t indent)
 270 {
 271         struct ec_parsed *child;
 272         const struct ec_strvec *vec;
 273         size_t i;
 274         const char *id = "none", *typename = "none";
 275
 276         if (parsed->node != NULL) {
 277                 if (parsed->node->id != NULL)
 278                         id = parsed->node->id;
 279                 typename = parsed->node->type->name;
 280         }
 281
 282         /* XXX enhance */
 283         for (i = 0; i < indent; i++) {
 284                 if (i % 2)
 285                         fprintf(out, " ");
 286                 else
 287                         fprintf(out, "|");
 288         }
 289
 290         fprintf(out, "node_type=%s id=%s vec=", typename, id);
 291         vec = ec_parsed_strvec(parsed);
 292         ec_strvec_dump(out, vec);
 293
 294         TAILQ_FOREACH(child, &parsed->children, next)
 295                 __ec_parsed_dump(out, child, indent + 2);
 296 }
 297
 298 void ec_parsed_dump(FILE *out, const struct ec_parsed *parsed)
 299 {
 300         fprintf(out, "------------------- parsed dump:\n"); //XXX
 301
 302         if (parsed == NULL) {
 303                 fprintf(out, "parsed is NULL, error in parse\n");
 304                 return;
 305         }
 306
 307         /* only exist if it does not match (strvec == NULL) and if it
 308          * does not have children: an incomplete parse, like those
 309          * generated by complete() don't match but have children that
 310          * may match. */
 311         if (!ec_parsed_matches(parsed) && TAILQ_EMPTY(&parsed->children)) {
 312                 fprintf(out, "no match\n");
 313                 return;
 314         }
 315
 316         __ec_parsed_dump(out, parsed, 0);
 317 }
 318
 319 void ec_parsed_add_child(struct ec_parsed *parsed,
 320         struct ec_parsed *child)
 321 {
 322         TAILQ_INSERT_TAIL(&parsed->children, child, next);
 323         child->parent = parsed;
 324 }
 325
 326 // XXX we can remove the first arg ? parsed == child->parent ?
 327 void ec_parsed_del_child(struct ec_parsed *parsed, // XXX rename del in unlink?
 328         struct ec_parsed *child)
 329 {
 330         TAILQ_REMOVE(&parsed->children, child, next);
 331         child->parent = NULL;
 332 }
 333
 334 struct ec_parsed *
 335 ec_parsed_get_first_child(const struct ec_parsed *parsed)
 336 {
 337         return TAILQ_FIRST(&parsed->children);
 338 }
 339
 340 struct ec_parsed *
 341 ec_parsed_get_last_child(const struct ec_parsed *parsed)
 342 {
 343         return TAILQ_LAST(&parsed->children, ec_parsed_list);
 344 }
 345
 346 struct ec_parsed *ec_parsed_get_next(const struct ec_parsed *parsed)
 347 {
 348         return TAILQ_NEXT(parsed, next);
 349 }
 350
 351 bool ec_parsed_has_child(const struct ec_parsed *parsed)
 352 {
 353         return !TAILQ_EMPTY(&parsed->children);
 354 }
 355
 356 const struct ec_node *ec_parsed_get_node(const struct ec_parsed *parsed)
 357 {
 358         return parsed->node;
 359 }
 360
 361 void ec_parsed_set_node(struct ec_parsed *parsed, const struct ec_node *node)
 362 {
 363         parsed->node = node;
 364 }
 365
 366 void ec_parsed_del_last_child(struct ec_parsed *parsed) // rename in free
 367 {
 368         struct ec_parsed *child;
 369
 370         child = ec_parsed_get_last_child(parsed);
 371         ec_parsed_del_child(parsed, child);
 372         ec_parsed_free(child);
 373 }
 374
 375 struct ec_parsed *ec_parsed_get_root(struct ec_parsed *parsed)
 376 {
 377         if (parsed == NULL)
 378                 return NULL;
 379
 380         while (parsed->parent != NULL)
 381                 parsed = parsed->parent;
 382
 383         return parsed;
 384 }
 385
 386 struct ec_parsed *ec_parsed_get_parent(struct ec_parsed *parsed)
 387 {
 388         if (parsed == NULL)
 389                 return NULL;
 390
 391         return parsed->parent;
 392 }
 393
 394 struct ec_parsed *ec_parsed_find_first(struct ec_parsed *parsed,
 395         const char *id)
 396 {
 397         struct ec_parsed *child, *ret;
 398
 399         if (parsed == NULL)
 400                 return NULL;
 401
 402         if (parsed->node != NULL &&
 403                         parsed->node->id != NULL &&
 404                         !strcmp(parsed->node->id, id))
 405                 return parsed;
 406
 407         TAILQ_FOREACH(child, &parsed->children, next) {
 408                 ret = ec_parsed_find_first(child, id);
 409                 if (ret != NULL)
 410                         return ret;
 411         }
 412
 413         return NULL;
 414 }
 415
 416 const struct ec_strvec *ec_parsed_strvec(const struct ec_parsed *parsed)
 417 {
 418         if (parsed == NULL || parsed->strvec == NULL)
 419                 return NULL;
 420
 421         return parsed->strvec;
 422 }
 423
 424 /* number of strings in the parsed vector */
 425 size_t ec_parsed_len(const struct ec_parsed *parsed)
 426 {
 427         if (parsed == NULL || parsed->strvec == NULL)
 428                 return 0;
 429
 430         return ec_strvec_len(parsed->strvec);
 431 }
 432
 433 size_t ec_parsed_matches(const struct ec_parsed *parsed)
 434 {
 435         if (parsed == NULL)
 436                 return 0;
 437
 438         if (parsed->strvec == NULL)
 439                 return 0;
 440
 441         return 1;
 442 }