static NEOERR * _copy_attr (HDF_ATTR **dest, HDF_ATTR *src)
{
HDF_ATTR *copy, *last = NULL;
*dest = NULL;
while (src != NULL)
{
copy = (HDF_ATTR *)malloc(sizeof(HDF_ATTR));
if (copy == NULL)
{
_dealloc_hdf_attr(dest);
return nerr_raise(NERR_NOMEM, "Unable to allocate copy of HDF_ATTR");
}
copy->key = strdup(src->key);
copy->value = strdup(src->value);
copy->next = NULL;
if ((copy->key == NULL) || (copy->value == NULL))
{
_dealloc_hdf_attr(dest);
return nerr_raise(NERR_NOMEM, "Unable to allocate copy of HDF_ATTR");
}
if (last) {
last->next = copy;
}
else
{
*dest = copy;
}
last = copy;
src = src->next;
}
return STATUS_OK;
}
static NEOERR * _copy_nodes (HDF *dest, HDF *src)
{
NEOERR *err = STATUS_OK;
HDF *dt, *st;
HDF_ATTR *attr_copy;
st = src->child;
while (st != NULL)
{
err = _copy_attr(&attr_copy, st->attr);
if (err) return nerr_pass(err);
err = _set_value(dest, st->name, st->value, 1, 1, st->link, attr_copy, &dt);
if (err) {
_dealloc_hdf_attr(&attr_copy);
return nerr_pass(err);
}
if (src->child)
{
err = _copy_nodes (dt, st);
if (err) return nerr_pass(err);
}
st = st->next;
}
return STATUS_OK;
}
NEOERR* hdf_copy (HDF *dest, const char *name, HDF *src)
{
NEOERR *err;
HDF *node;
HDF_ATTR *attr_copy;
if (_walk_hdf(dest, name, &node) == -1)
{
err = _copy_attr(&attr_copy, src->attr);
if (err) return nerr_pass(err);
err = _set_value (dest, name, src->value, 1, 1, src->link, attr_copy,
&node);
if (err) {
_dealloc_hdf_attr(&attr_copy);
return nerr_pass(err);
}
}
return nerr_pass (_copy_nodes (node, src));
}
void _merge_attr (HDF_ATTR *dest, HDF_ATTR *src)
{
HDF_ATTR *da, *ld;
HDF_ATTR *sa, *ls;
BOOL found;
sa = src;
ls = src;
while (sa != NULL)
{
da = dest;
ld = da;
found = 0;
while (da != NULL)
{
if (!strcmp(da->key, sa->key))
{
if (da->value) free(da->value);
da->value = sa->value;
sa->value = NULL;
found = 1;
break;
}
ld = da;
da = da->next;
}
if (!found)
{
ld->next = sa;
ls->next = sa->next;
if (src == sa) src = sa->next;
ld->next->next = NULL;
sa = ls->next;
}
else
{
ls = sa;
sa = sa->next;
}
}
_dealloc_hdf_attr(&src);
}
static void _dealloc_hdf (HDF **hdf)
{
HDF *myhdf = *hdf;
HDF *next = NULL;
if (myhdf == NULL) return;
if (myhdf->child != NULL)
_dealloc_hdf(&(myhdf->child));
/* This was easier recursively, but dangerous on long lists, so we
* walk it ourselves */
next = myhdf->next;
while (next != NULL)
{
myhdf->next = next->next;
next->next = NULL;
_dealloc_hdf(&next);
next = myhdf->next;
}
if (myhdf->name != NULL)
{
free (myhdf->name);
myhdf->name = NULL;
}
if (myhdf->value != NULL)
{
if (myhdf->alloc_value)
free (myhdf->value);
myhdf->value = NULL;
}
if (myhdf->attr != NULL)
{
_dealloc_hdf_attr(&(myhdf->attr));
}
if (myhdf->hash != NULL)
{
ne_hash_destroy(&myhdf->hash);
}
free(myhdf);
*hdf = NULL;
}
/* attributes are of the form [key1, key2, key3=value, key4="repr"] */
static NEOERR* parse_attr(char **str, HDF_ATTR **attr)
{
NEOERR *err = STATUS_OK;
char *s = *str;
char *k, *v;
int k_l, v_l;
STRING buf;
char c;
HDF_ATTR *ha, *hal = NULL;
*attr = NULL;
string_init(&buf);
while (*s && *s != ']')
{
k = s;
k_l = 0;
v = NULL;
v_l = 0;
while (*s && isalnum(*s)) s++;
k_l = s-k;
if (*s == '\0' || k_l == 0)
{
_dealloc_hdf_attr(attr);
return nerr_raise(NERR_PARSE, "Misformed attribute specification: %s", *str);
}
SKIPWS(s);
if (*s == '=')
{
s++;
SKIPWS(s);
if (*s == '"')
{
s++;
while (*s && *s != '"')
{
if (*s == '\\')
{
if (isdigit(*(s+1)))
{
s++;
c = *s - '0';
if (isdigit(*(s+1)))
{
s++;
c = (c * 8) + (*s - '0');
if (isdigit(*(s+1)))
{
s++;
c = (c * 8) + (*s - '0');
}
}
}
else
{
s++;
if (*s == 'n') c = '\n';
else if (*s == 't') c = '\t';
else if (*s == 'r') c = '\r';
else c = *s;
}
err = string_append_char(&buf, c);
}
else
{
err = string_append_char(&buf, *s);
}
if (err)
{
string_clear(&buf);
_dealloc_hdf_attr(attr);
return nerr_pass(err);
}
s++;
}
if (*s == '\0')
{
_dealloc_hdf_attr(attr);
string_clear(&buf);
return nerr_raise(NERR_PARSE, "Misformed attribute specification: %s", *str);
}
s++;
v = buf.buf;
v_l = buf.len;
}
else
{
v = s;
while (*s && *s != ' ' && *s != ',' && *s != ']') s++;
if (*s == '\0')
{
_dealloc_hdf_attr(attr);
return nerr_raise(NERR_PARSE, "Misformed attribute specification: %s", *str);
}
v_l = s-v;
}
}
else
{
v = "1";
}
ha = (HDF_ATTR*) calloc (1, sizeof(HDF_ATTR));
if (ha == NULL)
{
_dealloc_hdf_attr(attr);
string_clear(&buf);
return nerr_raise(NERR_NOMEM, "Unable to load attributes: %s", s);
}
if (*attr == NULL) *attr = ha;
ha->key = neos_strndup(k, k_l);
if (v)
ha->value = neos_strndup(v, v_l);
else
ha->value = strdup("");
if (ha->key == NULL || ha->value == NULL)
{
_dealloc_hdf_attr(attr);
string_clear(&buf);
return nerr_raise(NERR_NOMEM, "Unable to load attributes: %s", s);
}
if (hal != NULL) hal->next = ha;
hal = ha;
string_clear(&buf);
SKIPWS(s);
if (*s == ',')
{
s++;
SKIPWS(s);
}
}
if (*s == '\0')
{
_dealloc_hdf_attr(attr);
return nerr_raise(NERR_PARSE, "Misformed attribute specification: %s", *str);
}
*str = s+1;
return STATUS_OK;
}
