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