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