hphp/neo/neo_hdf.c

   1 /*
   2  * Copyright 2001-2004 Brandon Long
   3  * All Rights Reserved.
   4  *
   5  * ClearSilver Templating System
   6  *
   7  * This code is made available under the terms of the ClearSilver License.
   8  * http://www.clearsilver.net/license.hdf
   9  *
  10  */
  11
  12 #include "cs_config.h"
  13
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <stdio.h>
  17 #include <ctype.h>
  18 #include <errno.h>
  19 #include <limits.h>
  20 #include <stdarg.h>
  21 #include <sys/stat.h>
  22
  23 #ifdef _MSC_VER
  24 #include <windows.h>
  25 #include <direct.h>
  26 #include <io.h>
  27 #define PATH_MAX MAX_PATH
  28 #else
  29 #include <unistd.h>
  30 #endif
  31
  32 #include "neo_misc.h"
  33 #include "neo_err.h"
  34 #include "neo_rand.h"
  35 #include "neo_hdf.h"
  36 #include "neo_str.h"
  37 #include "neo_files.h"
  38 #include "ulist.h"
  39
  40 static NEOERR* hdf_read_file_internal (HDF *hdf, const char *path,
  41                                        int include_handle);
  42
  43
  44 static char *_read_file(FILE *f) {
  45   int size = 1024;
  46   char *ret = malloc(size + 1);
  47   char *newret;
  48
  49   size_t nread;
  50   char *buf = ret;
  51   int len = size;
  52   while ((nread = fread(buf, 1, len, f))) {
  53     buf += nread;
  54     len -= nread;
  55     if (len == 0) {
  56       len = size;
  57       size <<= 1;
  58
  59       newret = realloc(ret, size + 1);
  60       buf = buf - ret + newret;
  61       ret = newret;
  62     }
  63   }
  64   *buf = '\0';
  65   return ret;
  66 }
  67
  68 /* Ok, in order to use the hash, we have to support n-len strings
  69  * instead of null terminated strings (since in set_value and walk_hdf
  70  * we are merely using part of the HDF name for lookup, and that might
  71  * be a const, and we don't want the overhead of allocating/copying
  72  * that data out...)
  73  *
  74  * Since HASH doesn't maintain any data placed in it, merely pointers to
  75  * it, we use the HDF node itself as the key, and have specific
  76  * comp/hash functions which just use the name/name_len as the key.
  77  */
  78
  79 static int hash_hdf_comp(const void *a, const void *b)
  80 {
  81   HDF *ha = (HDF *)a;
  82   HDF *hb = (HDF *)b;
  83
  84   return (ha->name_len == hb->name_len) && !strncmp(ha->name, hb->name, ha->name_len);
  85 }
  86
  87 static UINT32 hash_hdf_hash(const void *a)
  88 {
  89   HDF *ha = (HDF *)a;
  90   return ne_crc((UINT8 *)(ha->name), ha->name_len);
  91 }
  92
  93 static NEOERR *_alloc_hdf (HDF **hdf, const char *name, size_t nlen,
  94                            const char *value, int dupl, int wf, HDF *top)
  95 {
  96   *hdf = calloc (1, sizeof (HDF));
  97   if (*hdf == NULL)
  98   {
  99     return nerr_raise (NERR_NOMEM, "Unable to allocate memory for hdf element");
 100   }
 101
 102   (*hdf)->top = top;
 103
 104   if (name != NULL)
 105   {
 106     (*hdf)->name_len = nlen;
 107     (*hdf)->name = (char *) malloc (nlen + 1);
 108     if ((*hdf)->name == NULL)
 109     {
 110       free((*hdf));
 111       (*hdf) = NULL;
 112       return nerr_raise (NERR_NOMEM,
 113           "Unable to allocate memory for hdf element: %s", name);
 114     }
 115     strncpy((*hdf)->name, name, nlen);
 116     (*hdf)->name[nlen] = '\0';
 117   }
 118   if (value != NULL)
 119   {
 120     if (dupl)
 121     {
 122       (*hdf)->alloc_value = 1;
 123       (*hdf)->value = strdup(value);
 124       if ((*hdf)->value == NULL)
 125       {
 126         free((*hdf)->name);
 127         free((*hdf));
 128         (*hdf) = NULL;
 129         return nerr_raise (NERR_NOMEM,
 130             "Unable to allocate memory for hdf element %s", name);
 131       }
 132     }
 133     else
 134     {
 135       (*hdf)->alloc_value = wf;
 136       /* We're overriding the const of value here for the set_buf case
 137        * where we overrode the char * to const char * earlier, since
 138        * alloc_value actually keeps track of the const-ness for us */
 139       (*hdf)->value = (char *)value;
 140     }
 141   }
 142   return STATUS_OK;
 143 }
 144
 145 static void _dealloc_hdf_attr(HDF_ATTR **attr)
 146 {
 147   HDF_ATTR *next;
 148
 149   while ((*attr) != NULL)
 150   {
 151     next = (*attr)->next;
 152     if ((*attr)->key) free((*attr)->key);
 153     if ((*attr)->value) free((*attr)->value);
 154     free(*attr);
 155     *attr = next;
 156   }
 157   *attr = NULL;
 158 }
 159
 160 static void _dealloc_hdf (HDF **hdf)
 161 {
 162   HDF *myhdf = *hdf;
 163   HDF *next = NULL;
 164
 165   if (myhdf == NULL) return;
 166   if (myhdf->child != NULL)
 167     _dealloc_hdf(&(myhdf->child));
 168
 169   /* This was easier recursively, but dangerous on long lists, so we
 170    * walk it ourselves */
 171   next = myhdf->next;
 172   while (next != NULL)
 173   {
 174     myhdf->next = next->next;
 175     next->next = NULL;
 176     _dealloc_hdf(&next);
 177     next = myhdf->next;
 178   }
 179   if (myhdf->name != NULL)
 180   {
 181     free (myhdf->name);
 182     myhdf->name = NULL;
 183   }
 184   if (myhdf->value != NULL)
 185   {
 186     if (myhdf->alloc_value)
 187       free (myhdf->value);
 188     myhdf->value = NULL;
 189   }
 190   if (myhdf->attr != NULL)
 191   {
 192     _dealloc_hdf_attr(&(myhdf->attr));
 193   }
 194   if (myhdf->hash != NULL)
 195   {
 196     ne_hash_destroy(&myhdf->hash);
 197   }
 198   free(myhdf);
 199   *hdf = NULL;
 200 }
 201
 202 NEOERR* hdf_init (HDF **hdf)
 203 {
 204   NEOERR *err;
 205   HDF *my_hdf;
 206
 207   *hdf = NULL;
 208
 209   err = nerr_init();
 210   if (err != STATUS_OK)
 211     return nerr_pass (err);
 212
 213   err = _alloc_hdf (&my_hdf, NULL, 0, NULL, 0, 0, NULL);
 214   if (err != STATUS_OK)
 215     return nerr_pass (err);
 216
 217   my_hdf->top = my_hdf;
 218
 219   *hdf = my_hdf;
 220
 221   return STATUS_OK;
 222 }
 223
 224 void hdf_destroy (HDF **hdf)
 225 {
 226   if (*hdf == NULL) return;
 227   if ((*hdf)->top == (*hdf))
 228   {
 229     _dealloc_hdf(hdf);
 230   }
 231 }
 232
 233 static int _walk_hdf (HDF *hdf, const char *name, HDF **node)
 234 {
 235   HDF *parent = NULL;
 236   HDF *hp = hdf;
 237   HDF hash_key;
 238   int x = 0;
 239   const char *s, *n;
 240   int r;
 241
 242   *node = NULL;
 243
 244   if (hdf == NULL) return -1;
 245   if (name == NULL || name[0] == '\0')
 246   {
 247     *node = hdf;
 248     return 0;
 249   }
 250
 251   if (hdf->link)
 252   {
 253     r = _walk_hdf (hdf->top, hdf->value, &hp);
 254     if (r) return r;
 255     if (hp)
 256     {
 257       parent = hp;
 258       hp = hp->child;
 259     }
 260   }
 261   else
 262   {
 263     parent = hdf;
 264     hp = hdf->child;
 265   }
 266   if (hp == NULL)
 267   {
 268     return -1;
 269   }
 270
 271   n = name;
 272   s = strchr (n, '.');
 273   x = (s == NULL) ? strlen(n) : s - n;
 274
 275   while (1)
 276   {
 277     if (parent && parent->hash)
 278     {
 279       hash_key.name = (char *)n;
 280       hash_key.name_len = x;
 281       hp = ne_hash_lookup(parent->hash, &hash_key);
 282     }
 283     else
 284     {
 285       while (hp != NULL)
 286       {
 287         if (hp->name && (x == hp->name_len) && !strncmp(hp->name, n, x))
 288         {
 289           break;
 290         }
 291         else
 292         {
 293           hp = hp->next;
 294         }
 295       }
 296     }
 297     if (hp == NULL)
 298     {
 299       return -1;
 300     }
 301     if (s == NULL) break;
 302
 303     if (hp->link)
 304     {
 305       r = _walk_hdf (hp->top, hp->value, &hp);
 306       if (r) {
 307         return r;
 308       }
 309       parent = hp;
 310       hp = hp->child;
 311     }
 312     else
 313     {
 314       parent = hp;
 315       hp = hp->child;
 316     }
 317     n = s + 1;
 318     s = strchr (n, '.');
 319     x = (s == NULL) ? strlen(n) : s - n;
 320   }
 321   if (hp->link)
 322   {
 323     return _walk_hdf (hp->top, hp->value, node);
 324   }
 325
 326   *node = hp;
 327   return 0;
 328 }
 329
 330 HDF* hdf_get_obj (HDF *hdf, const char *name)
 331 {
 332   HDF *obj;
 333
 334   _walk_hdf(hdf, name, &obj);
 335   return obj;
 336 }
 337
 338 HDF* hdf_get_child (HDF *hdf, const char *name)
 339 {
 340   HDF *obj;
 341   _walk_hdf(hdf, name, &obj);
 342   if (obj != NULL) return obj->child;
 343   return obj;
 344 }
 345
 346 void hdf_set_visited (HDF *hdf, int visited) {
 347   if (hdf) hdf->visited = visited;
 348 }
 349
 350 int hdf_is_visited (HDF *hdf) {
 351   return hdf ? hdf->visited : 0;
 352 }
 353
 354 HDF* hdf_obj_child (HDF *hdf)
 355 {
 356   HDF *obj;
 357   if (hdf == NULL) return NULL;
 358   if (hdf->link)
 359   {
 360     if (_walk_hdf(hdf->top, hdf->value, &obj))
 361       return NULL;
 362     return obj->child;
 363   }
 364   return hdf->child;
 365 }
 366
 367 HDF* hdf_obj_next (HDF *hdf)
 368 {
 369   if (hdf == NULL) return NULL;
 370   return hdf->next;
 371 }
 372
 373 char* hdf_obj_name (HDF *hdf)
 374 {
 375   if (hdf == NULL) return NULL;
 376   return hdf->name;
 377 }
 378
 379 char* hdf_obj_value (HDF *hdf)
 380 {
 381   int count = 0;
 382
 383   if (hdf == NULL) return NULL;
 384   while (hdf->link && count < 100)
 385   {
 386     if (_walk_hdf (hdf->top, hdf->value, &hdf))
 387       return NULL;
 388     count++;
 389   }
 390   return hdf->value;
 391 }
 392
 393 void _merge_attr (HDF_ATTR *dest, HDF_ATTR *src)
 394 {
 395   HDF_ATTR *da, *ld;
 396   HDF_ATTR *sa, *ls;
 397   char found;
 398
 399   sa = src;
 400   ls = src;
 401   while (sa != NULL)
 402   {
 403     da = dest;
 404     ld = da;
 405     found = 0;
 406     while (da != NULL)
 407     {
 408       if (!strcmp(da->key, sa->key))
 409       {
 410         if (da->value) free(da->value);
 411         da->value = sa->value;
 412         sa->value = NULL;
 413         found = 1;
 414         break;
 415       }
 416       ld = da;
 417       da = da->next;
 418     }
 419     if (!found)
 420     {
 421       ld->next = sa;
 422       ls->next = sa->next;
 423       if (src == sa) src = sa->next;
 424       ld->next->next = NULL;
 425       sa = ls->next;
 426     }
 427     else
 428     {
 429       ls = sa;
 430       sa = sa->next;
 431     }
 432   }
 433   _dealloc_hdf_attr(&src);
 434 }
 435
 436 NEOERR* _hdf_hash_level(HDF *hdf)
 437 {
 438   NEOERR *err;
 439   HDF *child;
 440
 441   err = ne_hash_init(&(hdf->hash), hash_hdf_hash, hash_hdf_comp);
 442   if (err) return nerr_pass(err);
 443
 444   child = hdf->child;
 445   while (child)
 446   {
 447     err = ne_hash_insert(hdf->hash, child, child);
 448     if (err) return nerr_pass(err);
 449     child = child->next;
 450   }
 451   return STATUS_OK;
 452 }
 453
 454 static NEOERR* _set_value (HDF *hdf, const char *name, const char *value,
 455                            int dupl, int wf, int lnk, HDF_ATTR *attr,
 456                            HDF **set_node)
 457 {
 458   NEOERR *err;
 459   HDF *hn, *hp, *hs;
 460   HDF hash_key;
 461   int x = 0;
 462   const char *s = name;
 463   const char *n = name;
 464   int count = 0;
 465
 466   if (set_node != NULL) *set_node = NULL;
 467   if (hdf == NULL)
 468   {
 469     return nerr_raise(NERR_ASSERT, "Unable to set %s on NULL hdf", name);
 470   }
 471
 472   /* HACK: allow setting of this node by passing an empty name */
 473   if (name == NULL || name[0] == '\0')
 474   {
 475     /* handle setting attr first */
 476     if (hdf->attr == NULL)
 477     {
 478       hdf->attr = attr;
 479     }
 480     else
 481     {
 482       _merge_attr(hdf->attr, attr);
 483     }
 484     /* set link flag */
 485     if (lnk) hdf->link = 1;
 486     else hdf->link = 0;
 487     /* if we're setting ourselves to ourselves... */
 488     if (hdf->value == value)
 489     {
 490       if (set_node != NULL) *set_node = hdf;
 491       return STATUS_OK;
 492     }
 493     if (hdf->alloc_value)
 494     {
 495       free(hdf->value);
 496       hdf->value = NULL;
 497     }
 498     if (value == NULL)
 499     {
 500       hdf->alloc_value = 0;
 501       hdf->value = NULL;
 502     }
 503     else if (dupl)
 504     {
 505       hdf->alloc_value = 1;
 506       hdf->value = strdup(value);
 507       if (hdf->value == NULL)
 508         return nerr_raise (NERR_NOMEM, "Unable to duplicate value %s for %s",
 509             value, hdf->name);
 510     }
 511     else
 512     {
 513       hdf->alloc_value = wf;
 514       hdf->value = (char *)value;
 515     }
 516     if (set_node != NULL) *set_node = hdf;
 517     return STATUS_OK;
 518   }
 519
 520   n = name;
 521   s = strchr (n, '.');
 522   x = (s != NULL) ? s - n : strlen(n);
 523   if (x == 0)
 524   {
 525     return nerr_raise(NERR_ASSERT, "Unable to set Empty component %s", name);
 526   }
 527
 528   if (hdf->link)
 529   {
 530     char *new_name = (char *) malloc(strlen(hdf->value) + 1 + strlen(name) + 1);
 531     if (new_name == NULL)
 532     {
 533       return nerr_raise(NERR_NOMEM, "Unable to allocate memory");
 534     }
 535     strcpy(new_name, hdf->value);
 536     strcat(new_name, ".");
 537     strcat(new_name, name);
 538     err = _set_value (hdf->top, new_name, value, dupl, wf, lnk, attr, set_node);
 539     free(new_name);
 540     return nerr_pass(err);
 541   }
 542   else
 543   {
 544     hn = hdf;
 545   }
 546
 547   while (1)
 548   {
 549     /* examine cache to see if we have a match */
 550     count = 0;
 551     hp = hn->last_hp;
 552     hs = hn->last_hs;
 553
 554     if ((hs == NULL && hp == hn->child) || (hs && hs->next == hp))
 555     {
 556       if (hp && hp->name && (x == hp->name_len) && !strncmp (hp->name, n, x))
 557       {
 558         goto skip_search;
 559       }
 560     }
 561
 562     hp = hn->child;
 563     hs = NULL;
 564
 565     /* Look for a matching node at this level */
 566     if (hn->hash != NULL)
 567     {
 568       hash_key.name = (char *)n;
 569       hash_key.name_len = x;
 570       hp = ne_hash_lookup(hn->hash, &hash_key);
 571       hs = hn->last_child;
 572     }
 573     else
 574     {
 575       while (hp != NULL)
 576       {
 577         if (hp->name && (x == hp->name_len) && !strncmp(hp->name, n, x))
 578         {
 579           break;
 580         }
 581         hs = hp;
 582         hp = hp->next;
 583         count++;
 584       }
 585     }
 586
 587     /* save in cache any value we found */
 588     if (hp) {
 589       hn->last_hp = hp;
 590       hn->last_hs = hs;
 591     }
 592
 593 skip_search:
 594
 595     if (hp == NULL)
 596     {
 597       /* If there was no matching node at this level, we need to
 598        * allocate an intersitial node (or the actual node if we're
 599        * at the last part of the HDF name) */
 600       if (s != NULL)
 601       {
 602         /* intersitial */
 603         err = _alloc_hdf (&hp, n, x, NULL, 0, 0, hdf->top);
 604       }
 605       else
 606       {
 607         err = _alloc_hdf (&hp, n, x, value, dupl, wf, hdf->top);
 608         if (lnk) hp->link = 1;
 609         else hp->link = 0;
 610         hp->attr = attr;
 611       }
 612       if (err != STATUS_OK)
 613         return nerr_pass (err);
 614       if (hn->child == NULL)
 615         hn->child = hp;
 616       else
 617         hs->next = hp;
 618       hn->last_child = hp;
 619
 620       /* This is the point at which we convert to a hash table
 621        * at this level, if we're over the count */
 622       if (count > FORCE_HASH_AT && hn->hash == NULL)
 623       {
 624         err = _hdf_hash_level(hn);
 625         if (err) return nerr_pass(err);
 626       }
 627       else if (hn->hash != NULL)
 628       {
 629         err = ne_hash_insert(hn->hash, hp, hp);
 630         if (err) return nerr_pass(err);
 631       }
 632     }
 633     else if (s == NULL)
 634     {
 635       /* If there is a matching node and we're at the end of the HDF
 636        * name, then we update the value of the node */
 637       /* handle setting attr first */
 638       if (hp->attr == NULL)
 639       {
 640         hp->attr = attr;
 641       }
 642       else
 643       {
 644         _merge_attr(hp->attr, attr);
 645       }
 646       if (hp->value != value)
 647       {
 648         if (hp->alloc_value)
 649         {
 650           free(hp->value);
 651           hp->value = NULL;
 652         }
 653         if (value == NULL)
 654         {
 655           hp->alloc_value = 0;
 656           hp->value = NULL;
 657         }
 658         else if (dupl)
 659         {
 660           hp->alloc_value = 1;
 661           hp->value = strdup(value);
 662           if (hp->value == NULL)
 663             return nerr_raise (NERR_NOMEM, "Unable to duplicate value %s for %s",
 664                 value, name);
 665         }
 666         else
 667         {
 668           hp->alloc_value = wf;
 669           hp->value = (char *)value;
 670         }
 671       }
 672       if (lnk) hp->link = 1;
 673       else hp->link = 0;
 674     }
 675     else if (hp->link)
 676     {
 677       char *new_name = (char *) malloc(strlen(hp->value) + strlen(s) + 1);
 678       if (new_name == NULL)
 679       {
 680         return nerr_raise(NERR_NOMEM, "Unable to allocate memory");
 681       }
 682       strcpy(new_name, hp->value);
 683       strcat(new_name, s);
 684       err = _set_value (hdf->top, new_name, value, dupl, wf, lnk, attr, set_node);
 685       free(new_name);
 686       return nerr_pass(err);
 687     }
 688     /* At this point, we're done if there is not more HDF name space to
 689      * traverse */
 690     if (s == NULL)
 691       break;
 692     /* Otherwise, we need to find the next part of the namespace */
 693     n = s + 1;
 694     s = strchr (n, '.');
 695     x = (s != NULL) ? s - n : strlen(n);
 696     if (x == 0)
 697     {
 698       return nerr_raise(NERR_ASSERT, "Unable to set Empty component %s", name);
 699     }
 700     hn = hp;
 701   }
 702   if (set_node != NULL) *set_node = hp;
 703   return STATUS_OK;
 704 }
 705
 706 NEOERR* hdf_set_value (HDF *hdf, const char *name, const char *value)
 707 {
 708   return nerr_pass(_set_value (hdf, name, value, 1, 1, 0, NULL, NULL));
 709 }
 710
 711 NEOERR* hdf_get_node (HDF *hdf, const char *name, HDF **ret)
 712 {
 713   _walk_hdf(hdf, name, ret);
 714   if (*ret == NULL)
 715   {
 716     return nerr_pass(_set_value (hdf, name, NULL, 0, 1, 0, NULL, ret));
 717   }
 718   return STATUS_OK;
 719 }
 720
 721 NEOERR* hdf_remove_tree (HDF *hdf, const char *name)
 722 {
 723   HDF *hp = hdf;
 724   HDF *lp = NULL, *ln = NULL; /* last parent, last node */
 725   int x = 0;
 726   const char *s = name;
 727   const char *n = name;
 728
 729   if (hdf == NULL) return STATUS_OK;
 730
 731   hp = hdf->child;
 732   if (hp == NULL)
 733   {
 734     return STATUS_OK;
 735   }
 736
 737   lp = hdf;
 738   ln = NULL;
 739
 740   n = name;
 741   s = strchr (n, '.');
 742   x = (s == NULL) ? strlen(n) : s - n;
 743
 744   while (1)
 745   {
 746     while (hp != NULL)
 747     {
 748       if (hp->name && (x == hp->name_len) && !strncmp(hp->name, n, x))
 749       {
 750       break;
 751       }
 752       else
 753       {
 754         ln = hp;
 755         hp = hp->next;
 756       }
 757     }
 758     if (hp == NULL)
 759     {
 760       return STATUS_OK;
 761     }
 762     if (s == NULL) break;
 763
 764     lp = hp;
 765     ln = NULL;
 766     hp = hp->child;
 767     n = s + 1;
 768     s = strchr (n, '.');
 769     x = (s == NULL) ? strlen(n) : s - n;
 770   }
 771
 772   if (lp->hash != NULL)
 773   {
 774     ne_hash_remove(lp->hash, hp);
 775   }
 776   if (ln)
 777   {
 778     ln->next = hp->next;
 779     /* check to see if we are the last parent's last_child, if so
 780      * repoint so hash table inserts will go to the right place */
 781     if (hp == lp->last_child)
 782       lp->last_child = ln;
 783     hp->next = NULL;
 784   }
 785   else
 786   {
 787     lp->child = hp->next;
 788     hp->next = NULL;
 789   }
 790   _dealloc_hdf (&hp);
 791
 792   return STATUS_OK;
 793 }
 794
 795 static NEOERR * _copy_attr (HDF_ATTR **dest, HDF_ATTR *src)
 796 {
 797   HDF_ATTR *copy, *last = NULL;
 798
 799   *dest = NULL;
 800   while (src != NULL)
 801   {
 802     copy = (HDF_ATTR *)malloc(sizeof(HDF_ATTR));
 803     if (copy == NULL)
 804     {
 805       _dealloc_hdf_attr(dest);
 806       return nerr_raise(NERR_NOMEM, "Unable to allocate copy of HDF_ATTR");
 807     }
 808     copy->key = strdup(src->key);
 809     copy->value = strdup(src->value);
 810     copy->next = NULL;
 811     if ((copy->key == NULL) || (copy->value == NULL))
 812     {
 813       _dealloc_hdf_attr(dest);
 814       return nerr_raise(NERR_NOMEM, "Unable to allocate copy of HDF_ATTR");
 815     }
 816     if (last) {
 817       last->next = copy;
 818     }
 819     else
 820     {
 821       *dest = copy;
 822     }
 823     last = copy;
 824     src = src->next;
 825   }
 826   return STATUS_OK;
 827 }
 828
 829 static NEOERR * _copy_nodes (HDF *dest, HDF *src)
 830 {
 831   NEOERR *err = STATUS_OK;
 832   HDF *dt, *st;
 833   HDF_ATTR *attr_copy;
 834
 835   st = src->child;
 836   while (st != NULL)
 837   {
 838     err = _copy_attr(&attr_copy, st->attr);
 839     if (err) return nerr_pass(err);
 840     err = _set_value(dest, st->name, st->value, 1, 1, st->link, attr_copy, &dt);
 841     if (err) {
 842       _dealloc_hdf_attr(&attr_copy);
 843       return nerr_pass(err);
 844     }
 845     if (src->child)
 846     {
 847       err = _copy_nodes (dt, st);
 848       if (err) return nerr_pass(err);
 849     }
 850     st = st->next;
 851   }
 852   return STATUS_OK;
 853 }
 854
 855 NEOERR* hdf_copy (HDF *dest, const char *name, HDF *src)
 856 {
 857   NEOERR *err;
 858   HDF *node;
 859   HDF_ATTR *attr_copy;
 860
 861   if (_walk_hdf(dest, name, &node) == -1)
 862   {
 863     err = _copy_attr(&attr_copy, src->attr);
 864     if (err) return nerr_pass(err);
 865     err = _set_value (dest, name, src->value, 1, 1, src->link, attr_copy,
 866                       &node);
 867     if (err) {
 868       _dealloc_hdf_attr(&attr_copy);
 869       return nerr_pass(err);
 870     }
 871   }
 872   return nerr_pass (_copy_nodes (node, src));
 873 }
 874
 875 /* BUG: currently, this only prints something if there is a value...
 876  * but we now allow attributes on nodes with no value... */
 877
 878 static void gen_ml_break(char *ml, size_t len)
 879 {
 880   int nlen;
 881   int x = 0;
 882
 883   ml[x++] = '\n';
 884   nlen = 2 + neo_rand(len-5);
 885   if (nlen == 0)
 886   {
 887     nlen = len / 2;
 888   }
 889   while (nlen)
 890   {
 891     ml[x++] = ('A' + neo_rand(26));
 892     nlen--;
 893   }
 894   ml[x++] = '\n';
 895   ml[x] = '\0';
 896 }
 897
 898 typedef NEOERR *(*DUMPF_CB)(void *rock, const char *fmt, ...);
 899
 900 static NEOERR *_fp_dump_cb (void *rock, const char *fmt, ...)
 901 {
 902   FILE *fp = (FILE *)rock;
 903   va_list ap;
 904
 905   va_start (ap, fmt);
 906   vfprintf(fp, fmt, ap);
 907   va_end(ap);
 908   return STATUS_OK;
 909 }
 910
 911 static NEOERR *_string_dump_cb (void *rock, const char *fmt, ...)
 912 {
 913   NEOERR *err;
 914   NEOSTRING *str = (NEOSTRING *)rock;
 915   va_list ap;
 916
 917   va_start (ap, fmt);
 918   err = string_appendvf(str, fmt, ap);
 919   va_end(ap);
 920   return nerr_pass(err);
 921 }
 922
 923 #define DUMP_TYPE_DOTTED 0
 924 #define DUMP_TYPE_COMPACT 1
 925 #define DUMP_TYPE_PRETTY 2
 926
 927 static NEOERR* hdf_dump_cb(HDF *hdf, const char *prefix, int dtype, int lvl,
 928                            void *rock, DUMPF_CB dump_cbf)
 929 {
 930   NEOERR *err;
 931   char *p, op;
 932   char ml[10] = "\nEOM\n";
 933   int ml_len = strlen(ml);
 934   char whsp[256] = "";
 935
 936   if (dtype == DUMP_TYPE_PRETTY)
 937   {
 938     memset(whsp, ' ', 256);
 939     if (lvl > 127)
 940       lvl = 127;
 941     whsp[lvl*2] = '\0';
 942   }
 943
 944   if (hdf != NULL) hdf = hdf->child;
 945
 946   while (hdf != NULL)
 947   {
 948     op = '=';
 949     if (hdf->value)
 950     {
 951       if (hdf->link) op = ':';
 952       if (prefix && (dtype == DUMP_TYPE_DOTTED))
 953       {
 954         err = dump_cbf(rock, "%s.%s", prefix, hdf->name);
 955       }
 956       else
 957       {
 958         err = dump_cbf(rock, "%s%s", whsp, hdf->name);
 959       }
 960       if (err) return nerr_pass (err);
 961       if (hdf->attr)
 962       {
 963         HDF_ATTR *attr = hdf->attr;
 964         char *v = NULL;
 965
 966         err = dump_cbf(rock, " [");
 967         if (err) return nerr_pass(err);
 968         while (attr != NULL)
 969         {
 970     //#undef strcmp
 971           if (attr->value == NULL || !strcmp(attr->value, "1"))
 972             err = dump_cbf(rock, "%s", attr->key);
 973           else
 974           {
 975             v = repr_string_alloc(attr->value);
 976
 977             if (v == NULL)
 978               return nerr_raise(NERR_NOMEM, "Unable to repr attr %s value %s", attr->key, attr->value);
 979             err = dump_cbf(rock, "%s=%s", attr->key, v);
 980             free(v);
 981           }
 982           if (err) return nerr_pass(err);
 983           if (attr->next)
 984           {
 985             err = dump_cbf(rock, ", ");
 986             if (err) return nerr_pass(err);
 987           }
 988           attr = attr->next;
 989         }
 990         err = dump_cbf(rock, "] ");
 991         if (err) return nerr_pass(err);
 992       }
 993       if (strchr (hdf->value, '\n'))
 994       {
 995         int vlen = strlen(hdf->value);
 996
 997         while (strstr(hdf->value, ml) || ((vlen > ml_len) && !strncmp(hdf->value + vlen - ml_len + 1, ml, strlen(ml) - 1)))
 998         {
 999           gen_ml_break(ml, sizeof(ml));
1000           ml_len = strlen(ml);
1001         }
1002         if (hdf->value[strlen(hdf->value)-1] != '\n')
1003           err = dump_cbf(rock, " << %s%s%s", ml+1, hdf->value, ml);
1004         else
1005           err = dump_cbf(rock, " << %s%s%s", ml+1, hdf->value, ml+1);
1006       }
1007       else
1008       {
1009         err = dump_cbf(rock, " %c %s\n", op, hdf->value);
1010       }
1011       if (err) return nerr_pass (err);
1012     }
1013     if (hdf->child)
1014     {
1015       if (prefix && (dtype == DUMP_TYPE_DOTTED))
1016       {
1017         p = (char *) malloc (strlen(hdf->name) + strlen(prefix) + 2);
1018         sprintf (p, "%s.%s", prefix, hdf->name);
1019         err = hdf_dump_cb (hdf, p, dtype, lvl+1, rock, dump_cbf);
1020         free(p);
1021       }
1022       else
1023       {
1024         if (hdf->name && (dtype != DUMP_TYPE_DOTTED))
1025         {
1026           err = dump_cbf(rock, "%s%s {\n", whsp, hdf->name);
1027           if (err) return nerr_pass (err);
1028           err = hdf_dump_cb (hdf, hdf->name, dtype, lvl+1, rock, dump_cbf);
1029           if (err) return nerr_pass (err);
1030           err = dump_cbf(rock, "%s}\n", whsp);
1031         }
1032         else
1033         {
1034           err = hdf_dump_cb (hdf, hdf->name, dtype, lvl+1, rock, dump_cbf);
1035         }
1036       }
1037       if (err) return nerr_pass (err);
1038     }
1039     hdf = hdf->next;
1040   }
1041   return STATUS_OK;
1042 }
1043
1044 NEOERR* hdf_dump_str (HDF *hdf, const char *prefix, int dtype, NEOSTRING *str)
1045 {
1046   return nerr_pass(hdf_dump_cb(hdf, prefix, dtype, 0, str, _string_dump_cb));
1047 }
1048
1049 NEOERR* hdf_dump_format (HDF *hdf, int lvl, FILE *fp)
1050 {
1051   return nerr_pass(hdf_dump_cb(hdf, "", DUMP_TYPE_PRETTY, 0, fp, _fp_dump_cb));
1052 }
1053
1054 NEOERR *hdf_write_file (HDF *hdf, const char *path)
1055 {
1056   NEOERR *err;
1057   FILE *fp;
1058
1059   fp = fopen(path, "w");
1060   if (fp == NULL)
1061     return nerr_raise_errno (NERR_IO, "Unable to open %s for writing", path);
1062
1063   err = hdf_dump_format (hdf, 0, fp);
1064
1065   fclose (fp);
1066   if (err)
1067   {
1068     unlink(path);
1069   }
1070   return nerr_pass(err);
1071 }
1072
1073 NEOERR *hdf_write_string (HDF *hdf, char **s)
1074 {
1075   NEOSTRING str;
1076   NEOERR *err;
1077
1078   *s = NULL;
1079
1080   string_init (&str);
1081
1082   err = hdf_dump_str (hdf, NULL, 2, &str);
1083   if (err)
1084   {
1085     string_clear (&str);
1086     return nerr_pass(err);
1087   }
1088   if (str.buf == NULL)
1089   {
1090     *s = strdup("");
1091     if (*s == NULL) return nerr_raise(NERR_NOMEM, "Unable to allocate empty string");
1092   }
1093   else
1094   {
1095     *s = str.buf;
1096   }
1097
1098   return STATUS_OK;
1099 }
1100
1101
1102 #define SKIPWS(s) while (*s && isspace(*s)) s++;
1103
1104 static int _copy_line (const char **s, char *buf, size_t buf_len)
1105 {
1106   int x = 0;
1107   const char *st = *s;
1108
1109   while (*st && x < buf_len-1)
1110   {
1111     buf[x++] = *st;
1112     if (*st++ == '\n') break;
1113   }
1114   buf[x] = '\0';
1115   *s = st;
1116
1117   return x;
1118 }
1119
1120 /* Copy the characters in the file (up to the next newline) into line
1121  * and advance s to the next line */
1122 static NEOERR *_copy_line_advance(const char **s, NEOSTRING *line)
1123 {
1124   NEOERR *err;
1125   int x = 0;
1126   const char *st = *s;
1127   const char *nl;
1128
1129   nl = strchr(st, '\n');
1130   if (nl == NULL)
1131   {
1132     x = strlen(st);
1133     err = string_appendn(line, st, x);
1134     if (err) return nerr_pass(err);
1135     *s = st + x;
1136   }
1137   else
1138   {
1139     x = nl - st;
1140     err = string_appendn(line, st, x);
1141     if (err) return nerr_pass(err);
1142     *s = nl + 1;
1143   }
1144
1145   return STATUS_OK;
1146 }
1147
1148 char *_strndup(const char *s, int len) {
1149   int x;
1150   char *dupl;
1151   if (s == NULL) return NULL;
1152   dupl = (char *) malloc(len+1);
1153   if (dupl == NULL) return NULL;
1154   for (x = 0; x < len && s[x]; x++)
1155   {
1156     dupl[x] = s[x];
1157   }
1158   dupl[x] = '\0';
1159   dupl[len] = '\0';
1160   return dupl;
1161 }
1162
1163 /* attributes are of the form [key1, key2, key3=value, key4="repr"] */
1164 static NEOERR* parse_attr(char **str, HDF_ATTR **attr)
1165 {
1166   NEOERR *err = STATUS_OK;
1167   char *s = *str;
1168   char *k, *v;
1169   int k_l, v_l;
1170   NEOSTRING buf;
1171   char c;
1172   HDF_ATTR *ha, *hal = NULL;
1173
1174   *attr = NULL;
1175
1176   string_init(&buf);
1177   while (*s && *s != ']')
1178   {
1179     k = s;
1180     k_l = 0;
1181     v = NULL;
1182     v_l = 0;
1183     while (*s && isalnum(*s)) s++;
1184     k_l = s-k;
1185     if (*s == '\0' || k_l == 0)
1186     {
1187       _dealloc_hdf_attr(attr);
1188       return nerr_raise(NERR_PARSE, "Malformed attribute specification: %s", *str);
1189     }
1190     SKIPWS(s);
1191     if (*s == '=')
1192     {
1193       s++;
1194       SKIPWS(s);
1195       if (*s == '"')
1196       {
1197         s++;
1198         while (*s && *s != '"')
1199         {
1200           if (*s == '\\')
1201           {
1202             if (isdigit(*(s+1)))
1203             {
1204               s++;
1205               c = *s - '0';
1206               if (isdigit(*(s+1)))
1207               {
1208                 s++;
1209                 c = (c * 8) + (*s - '0');
1210                 if (isdigit(*(s+1)))
1211                 {
1212                   s++;
1213                   c = (c * 8) + (*s - '0');
1214                 }
1215               }
1216             }
1217             else
1218             {
1219               s++;
1220               if (*s == 'n') c = '\n';
1221               else if (*s == 't') c = '\t';
1222               else if (*s == 'r') c = '\r';
1223               else c = *s;
1224             }
1225             err = string_append_char(&buf, c);
1226           }
1227           else
1228           {
1229             err = string_append_char(&buf, *s);
1230           }
1231           if (err)
1232           {
1233             string_clear(&buf);
1234             _dealloc_hdf_attr(attr);
1235             return nerr_pass(err);
1236           }
1237           s++;
1238         }
1239         if (*s == '\0')
1240         {
1241           _dealloc_hdf_attr(attr);
1242           string_clear(&buf);
1243           return nerr_raise(NERR_PARSE, "Malformed attribute specification: %s", *str);
1244         }
1245         s++;
1246         v = buf.buf;
1247         v_l = buf.len;
1248       }
1249       else
1250       {
1251         v = s;
1252         while (*s && *s != ' ' && *s != ',' && *s != ']') s++;
1253         if (*s == '\0')
1254         {
1255           _dealloc_hdf_attr(attr);
1256           return nerr_raise(NERR_PARSE, "Malformed attribute specification: %s", *str);
1257         }
1258         v_l = s-v;
1259       }
1260     }
1261     else
1262     {
1263       v = "1";
1264     }
1265     ha = (HDF_ATTR*) calloc (1, sizeof(HDF_ATTR));
1266     if (ha == NULL)
1267     {
1268       _dealloc_hdf_attr(attr);
1269       string_clear(&buf);
1270       return nerr_raise(NERR_NOMEM, "Unable to load attributes: %s", s);
1271     }
1272     if (*attr == NULL) *attr = ha;
1273     ha->key = _strndup(k, k_l);
1274     if (v)
1275       ha->value = _strndup(v, v_l);
1276     else
1277       ha->value = strdup("");
1278     if (ha->key == NULL || ha->value == NULL)
1279     {
1280       _dealloc_hdf_attr(attr);
1281       string_clear(&buf);
1282       return nerr_raise(NERR_NOMEM, "Unable to load attributes: %s", s);
1283     }
1284     if (hal != NULL) hal->next = ha;
1285     hal = ha;
1286     string_clear(&buf);
1287     SKIPWS(s);
1288     if (*s == ',')
1289     {
1290       s++;
1291       SKIPWS(s);
1292     }
1293   }
1294   if (*s == '\0')
1295   {
1296     _dealloc_hdf_attr(attr);
1297     return nerr_raise(NERR_PARSE, "Malformed attribute specification: %s", *str);
1298   }
1299   *str = s+1;
1300   return STATUS_OK;
1301 }
1302
1303 #define INCLUDE_ERROR -1
1304 #define INCLUDE_IGNORE -2
1305 #define INCLUDE_FILE 0
1306 #define INCLUDE_MAX_DEPTH 50
1307
1308 static NEOERR* _hdf_read_string (HDF *hdf, const char **str, NEOSTRING *line,
1309                                  const char *path, int *lineno,
1310                                  int include_handle, int expect_end_brace) {
1311   NEOERR *err;
1312   HDF *lower;
1313   char *s;
1314   char *name, *value;
1315   HDF_ATTR *attr = NULL;
1316
1317   while (**str != '\0')
1318   {
1319     /* Reset string length, but don't free the reserved buffer */
1320     line->len = 0;
1321     err = _copy_line_advance(str, line);
1322     if (err) return nerr_pass(err);
1323     attr = NULL;
1324     (*lineno)++;
1325     s = line->buf;
1326     SKIPWS(s);
1327     if ((!strncmp(s, "#include ", 9) || !strncmp(s, "-include ", 9)) && include_handle != INCLUDE_IGNORE)
1328     {
1329       int required = !strncmp(s, "#include ", 9);
1330       if (include_handle == INCLUDE_ERROR)
1331       {
1332         return nerr_raise (NERR_PARSE,
1333                            "[%d]: #include not supported in string parse",
1334                            *lineno);
1335       }
1336       else if (include_handle < INCLUDE_MAX_DEPTH)
1337       {
1338         int l;
1339         s += 9;
1340         name = neos_strip(s);
1341         l = strlen(name);
1342         if (name[0] == '"' && name[l-1] == '"')
1343         {
1344           name[l-1] = '\0';
1345           name++;
1346         }
1347         char fullpath[PATH_MAX];
1348         if (name[0] != '/') {
1349           memset(fullpath, 0, PATH_MAX);
1350
1351           char *p = strrchr(path, '/');
1352           if (p == NULL) {
1353             char pwd[PATH_MAX];
1354             memset(pwd, 0, PATH_MAX);
1355             getcwd(pwd, PATH_MAX);
1356             snprintf(fullpath, PATH_MAX, "%s/%s", pwd, name);
1357           } else {
1358             int dir_len = p - path + 1;
1359             snprintf(fullpath, PATH_MAX, "%s", path);
1360             snprintf(fullpath + dir_len, PATH_MAX - dir_len, "%s", name);
1361           }
1362           name = fullpath;
1363         }
1364         err = hdf_read_file_internal(hdf, name, include_handle + 1);
1365         if (err != STATUS_OK && required)
1366         {
1367           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1368         }
1369       }
1370       else {
1371         return nerr_raise (NERR_MAX_RECURSION,
1372                            "[%d]: Too many recursion levels.",
1373                            *lineno
1374                            );
1375       }
1376     }
1377     else if (s[0] == '#')
1378     {
1379       /* comment: pass */
1380     }
1381     else if (s[0] == '}') /* up */
1382     {
1383       s = neos_strip(s);
1384       if (strcmp(s, "}"))
1385       {
1386         err = nerr_raise(NERR_PARSE,
1387             "[%s:%d] Trailing garbage on line following }: %s", path, *lineno,
1388             line->buf);
1389         return err;
1390       }
1391       return STATUS_OK;
1392     }
1393     else if (s[0])
1394     {
1395       /* Valid hdf name is [0-9a-zA-Z_.*\]+ */
1396       int splice = *s == '@';
1397       if (splice) s++;
1398       name = s;
1399       while (*s && (isalnum(*s) || *s == '_' || *s == '.' || *s == '*' || *s == '\\')) s++;
1400       SKIPWS(s);
1401
1402       char num[256];
1403       static int counter = 0;
1404       char *p;
1405       int i = 0;
1406       for (p = name; p < s && i < 200; p++) {
1407         if (*p != '*') {
1408           num[i++] = *p;
1409         } else {
1410           i += snprintf(num + i, 256 - i, "%d", counter++);
1411           name = num;
1412         }
1413       }
1414       num[i] = '\0';
1415
1416       if (s[0] == '[') /* attributes */
1417       {
1418         *s = '\0';
1419         name = neos_strip(name);
1420         s++;
1421         err = parse_attr(&s, &attr);
1422         if (err)
1423         {
1424           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1425         }
1426         SKIPWS(s);
1427       }
1428       if (splice) {
1429         name = neos_strip(name);
1430         HDF *h = hdf_get_obj(hdf->top, name);
1431         if (h) {
1432           HDF *c = hdf_obj_child(h);
1433           while (c) {
1434             err = hdf_copy (hdf, hdf_obj_name(c), c);
1435             if (err != STATUS_OK) break;
1436             c = hdf_obj_next(c);
1437           }
1438         }
1439         if (err != STATUS_OK)
1440         {
1441           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1442         }
1443       } else if (s[0] == '=') /* assignment */
1444       {
1445         *s = '\0';
1446         name = neos_strip(name);
1447         s++;
1448         value = neos_strip(s);
1449         err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL);
1450         if (err != STATUS_OK)
1451         {
1452           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1453         }
1454       }
1455       else if (s[0] == ':' && s[1] == '=') /* copy */
1456       {
1457         *s = '\0';
1458         name = neos_strip(name);
1459         s+=2;
1460         value = neos_strip(s);
1461         HDF *h = hdf_get_obj(hdf->top, value);
1462         if (!h)
1463         {
1464           err = nerr_raise(NERR_PARSE,
1465                            "[%s:%d] Failed to copy a node that is not loaded "
1466                            "yet: %s", path, *lineno, value);
1467           return err;
1468         }
1469         err = hdf_copy(hdf, name, h);
1470         if (err != STATUS_OK)
1471         {
1472           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1473         }
1474       }
1475       else if (s[0] == '!' && s[1] == '=') /* exec */
1476       {
1477         *s = '\0';
1478         name = neos_strip(name);
1479         s+=2;
1480         value = neos_strip(s);
1481
1482 #ifdef _MSC_VER
1483         FILE *f = _popen(value, "r");
1484 #else
1485         FILE *f = popen(value, "r");
1486 #endif
1487         if (f == NULL)
1488         {
1489           err = nerr_raise(NERR_PARSE,
1490                            "[%s:%d] Failed to exec specified command: %s",
1491                            path, *lineno, line->buf);
1492           return err;
1493         }
1494         char *content = _read_file(f);
1495         fclose(f);
1496         int len = strlen(content);
1497         if (len > 0 && content[len - 1] == '\n') {
1498           content[len - 1] = '\0'; // remove \n artifact
1499         }
1500         err = _set_value (hdf, name, content, 1, 1, 0, attr, NULL);
1501         free(content);
1502
1503         if (err != STATUS_OK)
1504         {
1505           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1506         }
1507       }
1508       else if (s[0] == ':') /* link */
1509       {
1510         *s = '\0';
1511         name = neos_strip(name);
1512         s++;
1513         value = neos_strip(s);
1514         err = _set_value (hdf, name, value, 1, 1, 1, attr, NULL);
1515         if (err != STATUS_OK)
1516         {
1517           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1518         }
1519       }
1520       else if (s[0] == '{') /* deeper */
1521       {
1522         *s = '\0';
1523         name = neos_strip(name);
1524         lower = hdf_get_obj (hdf, name);
1525         if (lower == NULL)
1526         {
1527           err = _set_value (hdf, name, NULL, 1, 1, 0, attr, &lower);
1528         }
1529         else
1530         {
1531           err = _set_value (lower, NULL, lower->value, 1, 1, 0, attr, NULL);
1532         }
1533         if (err != STATUS_OK)
1534         {
1535           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1536         }
1537         err = _hdf_read_string (lower, str, line, path, lineno, include_handle,
1538                                 1);
1539         if (err != STATUS_OK)
1540         {
1541           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1542         }
1543       }
1544       else if (s[0] == '<' && s[1] == '<') /* multi-line assignment */
1545       {
1546         char *m;
1547         int msize = 0;
1548         int mmax = 128;
1549         int l;
1550
1551         *s = '\0';
1552         name = neos_strip(name);
1553         s+=2;
1554         value = neos_strip(s);
1555         l = strlen(value);
1556         if (l == 0)
1557         {
1558           err = nerr_raise(NERR_PARSE,
1559               "[%s:%d] No multi-assignment terminator given: %s", path, *lineno,
1560               line->buf);
1561           return err;
1562         }
1563         m = (char *) malloc (mmax * sizeof(char));
1564         if (m == NULL)
1565         {
1566           return nerr_raise(NERR_NOMEM,
1567             "[%s:%d] Unable to allocate memory for multi-line assignment to %s",
1568             path, *lineno, name);
1569         }
1570         while (_copy_line (str, m+msize, mmax-msize) != 0)
1571         {
1572           (*lineno)++;
1573           if (!strncmp(value, m+msize, l) && isspace(m[msize+l]))
1574           {
1575             m[msize] = '\0';
1576             break;
1577           }
1578           msize += strlen(m+msize);
1579           if (msize + l + 10 > mmax)
1580           {
1581             void *new_ptr;
1582             mmax += 128;
1583             new_ptr = realloc (m, mmax * sizeof(char));
1584             if (new_ptr == NULL)
1585             {
1586         free(m);
1587               return nerr_raise(NERR_NOMEM,
1588                   "[%s:%d] Unable to allocate memory for multi-line assignment to %s: size=%d",
1589                   path, *lineno, name, mmax);
1590       }
1591       m = (char *) new_ptr;
1592           }
1593         }
1594         err = _set_value (hdf, name, m, 0, 1, 0, attr, NULL);
1595         if (err != STATUS_OK)
1596         {
1597           free (m);
1598           return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
1599         }
1600
1601       }
1602       else
1603       {
1604         err = nerr_raise(NERR_PARSE, "[%s:%d] Unable to parse line %s", path,
1605             *lineno, line->buf);
1606         return err;
1607       }
1608     }
1609   }
1610   if (expect_end_brace) {
1611     err = nerr_raise(NERR_PARSE, "[%s:%d] Missing matching }", path, *lineno);
1612     return err;
1613   }
1614   return STATUS_OK;
1615 }
1616
1617 NEOERR * hdf_read_string (HDF *hdf, const char *str)
1618 {
1619   NEOERR *err;
1620   int lineno = 0;
1621   NEOSTRING line;
1622   string_init(&line);
1623   err = _hdf_read_string(hdf, &str, &line, "<string>", &lineno, INCLUDE_ERROR,
1624                          0);
1625   string_clear(&line);
1626   return nerr_pass(err);
1627 }
1628
1629 /* The search path is part of the HDF by convention */
1630 NEOERR* hdf_search_path (HDF *hdf, const char *path, char *full, int full_len)
1631 {
1632   HDF *paths;
1633   struct stat s;
1634
1635   for (paths = hdf_get_child (hdf, "hdf.loadpaths");
1636       paths;
1637       paths = hdf_obj_next (paths))
1638   {
1639     snprintf (full, full_len, "%s/%s", hdf_obj_value(paths), path);
1640     errno = 0;
1641     if (stat (full, &s) == -1)
1642     {
1643       if (errno != ENOENT)
1644         return nerr_raise_errno (NERR_SYSTEM, "Stat of %s failed", full);
1645     }
1646     else
1647     {
1648       return STATUS_OK;
1649     }
1650   }
1651
1652   strncpy (full, path, full_len);
1653   if (stat (full, &s) == -1)
1654   {
1655     if (errno != ENOENT)
1656       return nerr_raise_errno (NERR_SYSTEM, "Stat of %s failed", full);
1657   }
1658   else return STATUS_OK;
1659
1660   return nerr_raise (NERR_NOT_FOUND, "Path %s not found", path);
1661 }
1662
1663 static NEOERR* hdf_read_file_internal (HDF *hdf, const char *path,
1664                                        int include_handle)
1665 {
1666   NEOERR *err;
1667   int lineno = 0;
1668   char fpath[PATH_BUF_SIZE];
1669   char *ibuf = NULL;
1670   const char *ptr = NULL;
1671   NEOSTRING line;
1672
1673   string_init(&line);
1674
1675   if (path == NULL)
1676     return nerr_raise(NERR_ASSERT, "Can't read NULL file");
1677   if (path[0] != '/')
1678   {
1679     err = hdf_search_path (hdf, path, fpath, PATH_BUF_SIZE);
1680     if (err != STATUS_OK) return nerr_pass(err);
1681     path = fpath;
1682   }
1683
1684   err = ne_load_file (path, &ibuf);
1685   if (err) return nerr_pass(err);
1686
1687   ptr = ibuf;
1688   err = _hdf_read_string(hdf, &ptr, &line, path, &lineno, include_handle, 0);
1689   free(ibuf);
1690   string_clear(&line);
1691   return nerr_pass(err);
1692 }
1693
1694 NEOERR* hdf_read_file (HDF *hdf, const char *path)
1695 {
1696   NEOERR *err;
1697   err = hdf_read_file_internal (hdf, path, INCLUDE_FILE);
1698   return nerr_pass(err);
1699 }