NEOERR* hdf_set_int_value (HDF *hdf, const char *name, int value)
{
char buf[256];
snprintf (buf, sizeof(buf), "%d", value);
return nerr_pass(_set_value (hdf, name, buf, 1, 1, 0, NULL, NULL));
}
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_set_copy (HDF *hdf, const char *dest, const char *src)
{
HDF *node;
if ((_walk_hdf(hdf, src, &node) == 0) && (node->value != NULL))
{
return nerr_pass(_set_value (hdf, dest, node->value, 0, 0, 0, NULL, NULL));
}
return nerr_raise (NERR_NOT_FOUND, "Unable to find %s", src);
}
NEOERR* hdf_get_node (HDF *hdf, const char *name, HDF **ret)
{
_walk_hdf(hdf, name, ret);
if (*ret == NULL)
{
return nerr_pass(_set_value (hdf, name, NULL, 0, 1, 0, NULL, ret));
}
return STATUS_OK;
}
CMPIStatus KBase_FromArgs(
KBase* self,
const CMPIArgs* ca,
CMPIBoolean in,
CMPIBoolean out)
{
CMPIStatus st = KSTATUS_INIT;
CMPICount count;
CMPICount i;
KValue* kv;
if (!self || self->magic != KMAGIC)
KReturn(ERR_FAILED);
/* For each arg */
count = CMGetArgCount(ca, &st);
if (!KOkay(st))
return st;
for (i = 0; i < count; i++)
{
CMPIData cd;
CMPIString* name = NULL;
KTag tag;
/* Get i-th property */
cd = CMGetArgAt(ca, i, &name, &st);
if (!KOkay(st))
return st;
if (!name)
KReturn(ERR_FAILED);
/* Find the given property */
if ((kv = _find_property(self, KChars(name), &tag)))
{
if (in && !(tag & KTAG_IN))
continue;
if (out && !(tag & KTAG_OUT))
continue;
_set_value(kv, tag, &cd);
}
}
KReturn(OK);
}
NEOERR* hdf_copy (HDF *dest, const char *name, HDF *src)
{
NEOERR *err;
HDF *node;
if (_walk_hdf(dest, name, &node) == -1)
{
err = _set_value (dest, name, NULL, 0, 0, 0, NULL, &node);
if (err) return nerr_pass (err);
}
return nerr_pass (_copy_nodes (node, src));
}
BWString BWDB::get_query_value(const BWString &q)
{
_clear_value();
if (sqlite3_prepare_v2(_dbh, q.c_str(), -1, &stmt, NULL) != SQLITE_OK)
{
_finalize();
return _value;
}
if (sqlite3_step(stmt) == SQLITE_ROW)
{
char *rc = (char *) sqlite3_column_text(stmt, 0);
if (rc) _set_value(rc);
}
_finalize();
return _value;
}
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));
}
/* ----------------------------------------------------------------
* 功 能：将TLV格式数据打包成字符串
* 输入参数：pTLV TLV格式数据
* 输出参数：szBuf 输出字符串
* 返 回 值：>=0 打包字符串长度 -1 失败
* 作 者：fengwei
* 日 期：2012-9-24
* 调用说明：PackTLV(pTLV, szBuf)
* 修改日志：修改日期 修改者 修改内容简述
* 2012-11-14 ryan.chan 调整格式、
* ----------------------------------------------------------------
*/
int PackTLV(T_TLVStru *pTLV, char* szBuf)
{
int i;
int iIndex, iLen;
T_TLVData *pData;
iIndex = 0;
for (i=0;i<MAX_TLV_NUM;i++)
{
pData = pTLV->tTLVData + i;
if (pData->iFlag == DATA_NOTNULL)
{
iLen = _set_tag(pData->szTag, pTLV->iTagType, szBuf+iIndex);
if (iLen <= 0)
{
WriteLog(ERROR, "pack tlv Tag error");
return FAIL;
}
iIndex += iLen;
iLen = _set_len(pData->iLen, pTLV->iLenType, szBuf+iIndex);
if (iLen <= 0)
{
WriteLog(ERROR, "pack tlv len error");
return FAIL;
}
iIndex += iLen;
iLen = _set_value(pData->szValue, pData->iLen,
pTLV->iValueType, szBuf+iIndex);
if (iLen < 0)
{
WriteLog(ERROR, "pack tlv value error");
return FAIL;
}
iIndex += iLen;
}
}
return iIndex;
}
BWString BWDB::get_query_value(const BWString &sQuery, const std::vector<BWString> &vParams)
{
_clear_value();
const char *q = sQuery.c_str();
if (sqlite3_prepare_v2(_dbh, q, -1, &stmt, NULL) != SQLITE_OK)
{
_finalize();
_get_value();
}
for (unsigned int i = 0; i < vParams.size(); ++i)
{
sqlite3_bind_text(stmt, i + 1, vParams[i].c_str(), -1, SQLITE_TRANSIENT);
}
if (sqlite3_step(stmt) == SQLITE_ROW)
{
char *rc = (char *) sqlite3_column_text(stmt, 0);
if (rc) _set_value(rc);
}
_finalize();
return _get_value();
}
bool BWDB::do_query(const BWString &sQuery, const std::vector<BWString> ¶ms)
{
const char *q = sQuery.c_str();
if (sqlite3_prepare_v2(_dbh, q, -1, &stmt, NULL) != SQLITE_OK)
{
_finalize();
return false;
}
for (unsigned int i = 0; i < params.size(); ++i)
{
sqlite3_bind_text(stmt, i + 1, params[i].c_str(), -1, SQLITE_TRANSIENT);
}
if (sqlite3_step(stmt) == SQLITE_ROW)
{
_set_value((const char *) sqlite3_column_text(stmt, 0));
_finalize();
return true;
} else
{
_finalize();
return false;
}
}
CMPIStatus KBase_FromInstance(KBase* self, const CMPIInstance* ci)
{
CMPIObjectPath* cop;
CMPIString* cn;
CMPIString* ns;
CMPIStatus st = KSTATUS_INIT;
CMPICount count;
CMPICount i;
KValue* kv;
if (!self || self->magic != KMAGIC)
KReturn(ERR_FAILED);
/* Get object path */
if (!(cop = CMGetObjectPath(ci, &st)))
return st;
/* Set namespace */
if (!(ns = CMGetNameSpace(cop, &st)))
return st;
self->ns = ns;
/* Get classname */
if (!(cn = CMGetClassName(cop, &st)))
return st;
/* For each property */
count = CMGetPropertyCount(ci, &st);
if (!KOkay(st))
return st;
for (i = 0; i < count; i++)
{
CMPIData cd;
CMPIString* pn = NULL;
KTag tag;
/* Get i-th property */
cd = CMGetPropertyAt(ci, i, &pn, &st);
if (!KOkay(st))
return st;
if (!pn)
KReturn(ERR_FAILED);
/* Find the given property */
if ((kv = _find_property(self, KChars(pn), &tag)))
{
_set_value(kv, tag, &cd);
}
}
KReturn(OK);
}
NEOERR* hdf_set_buf (HDF *hdf, const char *name, char *value)
{
return nerr_pass(_set_value (hdf, name, value, 0, 1, 0, NULL, NULL));
}
NEOERR* hdf_set_symlink (HDF *hdf, const char *src, const char *dest)
{
return nerr_pass(_set_value (hdf, src, dest, 1, 1, 1, NULL, NULL));
}
NEOERR* hdf_set_value_attr (HDF *hdf, const char *name, const char *value,
HDF_ATTR *attr)
{
return nerr_pass(_set_value (hdf, name, value, 1, 1, 0, attr, NULL));
}
static NEOERR* _set_value (HDF *hdf, const char *name, const char *value,
int dupl, int wf, int lnk, HDF_ATTR *attr,
HDF **set_node)
{
NEOERR *err;
HDF *hn, *hp, *hs;
HDF hash_key;
int x = 0;
const char *s = name;
const char *n = name;
int count = 0;
if (set_node != NULL) *set_node = NULL;
if (hdf == NULL)
{
return nerr_raise(NERR_ASSERT, "Unable to set %s on NULL hdf", name);
}
/* HACK: allow setting of this node by passing an empty name */
if (name == NULL || name[0] == '\0')
{
/* handle setting attr first */
if (hdf->attr == NULL)
{
hdf->attr = attr;
}
else
{
_merge_attr(hdf->attr, attr);
}
/* set link flag */
if (lnk) hdf->link = 1;
else hdf->link = 0;
/* if we're setting ourselves to ourselves... */
if (hdf->value == value)
{
if (set_node != NULL) *set_node = hdf;
return STATUS_OK;
}
if (hdf->alloc_value)
{
free(hdf->value);
hdf->value = NULL;
}
if (value == NULL)
{
hdf->alloc_value = 0;
hdf->value = NULL;
}
else if (dupl)
{
hdf->alloc_value = 1;
hdf->value = strdup(value);
if (hdf->value == NULL)
return nerr_raise (NERR_NOMEM, "Unable to duplicate value %s for %s",
value, name);
}
else
{
hdf->alloc_value = wf;
hdf->value = (char *)value;
}
if (set_node != NULL) *set_node = hdf;
return STATUS_OK;
}
n = name;
s = strchr (n, '.');
x = (s != NULL) ? s - n : strlen(n);
if (x == 0)
{
return nerr_raise(NERR_ASSERT, "Unable to set Empty component %s", name);
}
if (hdf->link)
{
char *new_name = (char *) malloc(strlen(hdf->value) + 1 + strlen(name) + 1);
if (new_name == NULL)
{
return nerr_raise(NERR_NOMEM, "Unable to allocate memory");
}
strcpy(new_name, hdf->value);
strcat(new_name, ".");
strcat(new_name, name);
err = _set_value (hdf->top, new_name, value, dupl, wf, lnk, attr, set_node);
free(new_name);
return nerr_pass(err);
}
else
{
hn = hdf;
}
while (1)
{
/* examine cache to see if we have a match */
count = 0;
hp = hn->last_hp;
hs = hn->last_hs;
if ((hs == NULL && hp == hn->child) || (hs && hs->next == hp))
{
if (hp && hp->name && (x == hp->name_len) && !strncmp (hp->name, n, x))
{
goto skip_search;
}
}
hp = hn->child;
hs = NULL;
/* Look for a matching node at this level */
if (hn->hash != NULL)
{
hash_key.name = (char *)n;
hash_key.name_len = x;
hp = ne_hash_lookup(hn->hash, &hash_key);
hs = hn->last_child;
}
else
{
while (hp != NULL)
{
if (hp->name && (x == hp->name_len) && !strncmp(hp->name, n, x))
{
break;
}
hs = hp;
hp = hp->next;
count++;
}
}
/* save in cache any value we found */
if (hp) {
hn->last_hp = hp;
hn->last_hs = hs;
}
skip_search:
if (hp == NULL)
{
/* If there was no matching node at this level, we need to
* allocate an intersitial node (or the actual node if we're
* at the last part of the HDF name) */
if (s != NULL)
{
/* intersitial */
err = _alloc_hdf (&hp, n, x, NULL, 0, 0, hdf->top);
}
else
{
err = _alloc_hdf (&hp, n, x, value, dupl, wf, hdf->top);
if (lnk) hp->link = 1;
else hp->link = 0;
hp->attr = attr;
}
if (err != STATUS_OK)
return nerr_pass (err);
if (hn->child == NULL)
hn->child = hp;
else
hs->next = hp;
hn->last_child = hp;
/* This is the point at which we convert to a hash table
* at this level, if we're over the count */
if (count > FORCE_HASH_AT && hn->hash == NULL)
{
err = _hdf_hash_level(hn);
if (err) return nerr_pass(err);
}
else if (hn->hash != NULL)
{
err = ne_hash_insert(hn->hash, hp, hp);
if (err) return nerr_pass(err);
}
}
else if (s == NULL)
{
/* If there is a matching node and we're at the end of the HDF
* name, then we update the value of the node */
/* handle setting attr first */
if (hp->attr == NULL)
{
hp->attr = attr;
}
else
{
_merge_attr(hp->attr, attr);
}
if (hp->value != value)
{
if (hp->alloc_value)
{
free(hp->value);
hp->value = NULL;
}
if (value == NULL)
{
hp->alloc_value = 0;
hp->value = NULL;
}
else if (dupl)
{
hp->alloc_value = 1;
hp->value = strdup(value);
if (hp->value == NULL)
return nerr_raise (NERR_NOMEM, "Unable to duplicate value %s for %s",
value, name);
}
else
{
hp->alloc_value = wf;
hp->value = (char *)value;
}
}
if (lnk) hp->link = 1;
else hp->link = 0;
}
else if (hp->link)
{
char *new_name = (char *) malloc(strlen(hp->value) + strlen(s) + 1);
if (new_name == NULL)
{
return nerr_raise(NERR_NOMEM, "Unable to allocate memory");
}
strcpy(new_name, hp->value);
strcat(new_name, s);
err = _set_value (hdf->top, new_name, value, dupl, wf, lnk, attr, set_node);
free(new_name);
return nerr_pass(err);
}
/* At this point, we're done if there is not more HDF name space to
* traverse */
if (s == NULL)
break;
/* Otherwise, we need to find the next part of the namespace */
n = s + 1;
s = strchr (n, '.');
x = (s != NULL) ? s - n : strlen(n);
if (x == 0)
{
return nerr_raise(NERR_ASSERT, "Unable to set Empty component %s", name);
}
hn = hp;
}
if (set_node != NULL) *set_node = hp;
return STATUS_OK;
}
static NEOERR* _hdf_read_string (HDF *hdf, const char **str, STRING *line,
const char *path, int *lineno,
int include_handle, int expect_end_brace) {
NEOERR *err;
HDF *lower;
char *s;
char *name, *value;
HDF_ATTR *attr = NULL;
while (**str != '\0')
{
/* Reset string length, but don't free the reserved buffer */
line->len = 0;
err = _copy_line_advance(str, line);
if (err) return nerr_pass(err);
attr = NULL;
(*lineno)++;
s = line->buf;
SKIPWS(s);
if ((!strncmp(s, "#include ", 9) || !strncmp(s, "-include ", 9)) && include_handle != INCLUDE_IGNORE)
{
int required = !strncmp(s, "#include ", 9);
if (include_handle == INCLUDE_ERROR)
{
return nerr_raise (NERR_PARSE,
"[%d]: #include not supported in string parse",
*lineno);
}
else if (include_handle < INCLUDE_MAX_DEPTH)
{
int l;
s += 9;
name = neos_strip(s);
l = strlen(name);
if (name[0] == '"' && name[l-1] == '"')
{
name[l-1] = '\0';
name++;
}
char fullpath[PATH_MAX];
if (name[0] != '/') {
memset(fullpath, 0, PATH_MAX);
char *p = strrchr(path, '/');
if (p == NULL) {
char pwd[PATH_MAX];
memset(pwd, 0, PATH_MAX);
getcwd(pwd, PATH_MAX);
snprintf(fullpath, PATH_MAX, "%s/%s", pwd, name);
} else {
int dir_len = p - path + 1;
snprintf(fullpath, PATH_MAX, "%s", path);
snprintf(fullpath + dir_len, PATH_MAX - dir_len, "%s", name);
}
name = fullpath;
}
err = hdf_read_file_internal(hdf, name, include_handle + 1);
if (err != STATUS_OK && required)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else {
return nerr_raise (NERR_MAX_RECURSION,
"[%d]: Too many recursion levels.",
*lineno
);
}
}
else if (s[0] == '#')
{
/* comment: pass */
}
else if (s[0] == '}') /* up */
{
s = neos_strip(s);
if (strcmp(s, "}"))
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Trailing garbage on line following }: %s", path, *lineno,
line->buf);
return err;
}
return STATUS_OK;
}
else if (s[0])
{
/* Valid hdf name is [0-9a-zA-Z_.]+ */
int splice = *s == '@';
if (splice) s++;
name = s;
while (*s && (isalnum(*s) || *s == '_' || *s == '.' || *s == '*')) s++;
SKIPWS(s);
char num[16];
static int counter = 0;
if (*name == '*') {
snprintf(num, sizeof(num), "%d", counter++);
name = num;
}
if (s[0] == '[') /* attributes */
{
*s = '\0';
name = neos_strip(name);
s++;
err = parse_attr(&s, &attr);
if (err)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
SKIPWS(s);
}
if (splice) {
name = neos_strip(name);
HDF *h = hdf_get_obj(hdf->top, name);
if (h) {
HDF *c = hdf_obj_child(h);
while (c) {
err = hdf_copy (hdf, hdf_obj_name(c), c);
if (err != STATUS_OK) break;
c = hdf_obj_next(c);
}
}
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
} else if (s[0] == '=') /* assignment */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':' && s[1] == '=') /* copy */
{
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
HDF *h = hdf_get_obj(hdf->top, value);
if (!h)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Failed to copy a node that is not loaded "
"yet: %s", path, *lineno, value);
return err;
}
err = hdf_copy(hdf, name, h);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '!' && s[1] == '=') /* exec */
{
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
FILE *f = popen(value, "r");
if (f == NULL)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Failed to exec specified command: %s",
path, *lineno, line->buf);
return err;
}
char *content = _read_file(f);
fclose(f);
int len = strlen(content);
if (len > 0 && content[len - 1] == '\n') {
content[len - 1] = '\0'; // remove \n artifact
}
err = _set_value (hdf, name, content, 1, 1, 0, attr, NULL);
free(content);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':') /* link */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 1, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '{') /* deeper */
{
*s = '\0';
name = neos_strip(name);
lower = hdf_get_obj (hdf, name);
if (lower == NULL)
{
err = _set_value (hdf, name, NULL, 1, 1, 0, attr, &lower);
}
else
{
err = _set_value (lower, NULL, lower->value, 1, 1, 0, attr, NULL);
}
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
err = _hdf_read_string (lower, str, line, path, lineno, include_handle,
1);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '<' && s[1] == '<') /* multi-line assignment */
{
char *m;
int msize = 0;
int mmax = 128;
int l;
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
l = strlen(value);
if (l == 0)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] No multi-assignment terminator given: %s", path, *lineno,
line->buf);
return err;
}
m = (char *) malloc (mmax * sizeof(char));
if (m == NULL)
{
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s",
path, *lineno, name);
}
while (_copy_line (str, m+msize, mmax-msize) != 0)
{
(*lineno)++;
if (!strncmp(value, m+msize, l) && isspace(m[msize+l]))
{
m[msize] = '\0';
break;
}
msize += strlen(m+msize);
if (msize + l + 10 > mmax)
{
void *new_ptr;
mmax += 128;
new_ptr = realloc (m, mmax * sizeof(char));
if (new_ptr == NULL)
{
free(m);
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s: size=%d",
path, *lineno, name, mmax);
}
m = (char *) new_ptr;
}
}
err = _set_value (hdf, name, m, 0, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
free (m);
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else
{
err = nerr_raise(NERR_PARSE, "[%s:%d] Unable to parse line %s", path,
*lineno, line->buf);
return err;
}
}
}
if (expect_end_brace) {
err = nerr_raise(NERR_PARSE, "[%s:%d] Missing matching }", path, *lineno);
return err;
}
return STATUS_OK;
}
void set_value( const T& v ) {
result = v;
_set_value(&*result);
}
void set_value( T&& v ) {
result = fc::move(v);
_set_value(&*result);
}
static NEOERR* _hdf_read_string (HDF *hdf, const char **str, STRING *line,
const char *path, int *lineno,
int include_handle)
{
NEOERR *err;
HDF *lower;
char *s;
char *name, *value;
HDF_ATTR *attr = NULL;
while (**str != '\0')
{
/* Reset string length, but don't free the reserved buffer */
line->len = 0;
err = _copy_line_advance(str, line);
if (err) return nerr_pass(err);
attr = NULL;
(*lineno)++;
s = line->buf;
SKIPWS(s);
if (!strncmp(s, "#include ", 9) && include_handle != INCLUDE_IGNORE)
{
if (include_handle == INCLUDE_ERROR)
{
return nerr_raise (NERR_PARSE,
"[%d]: #include not supported in string parse",
*lineno);
}
else if (include_handle < INCLUDE_MAX_DEPTH)
{
int l;
s += 9;
name = neos_strip(s);
l = strlen(name);
if (name[0] == '"' && name[l-1] == '"')
{
name[l-1] = '\0';
name++;
}
err = hdf_read_file_internal(hdf, name, include_handle + 1);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else
{
return nerr_raise (NERR_MAX_RECURSION,
"[%d]: Too many recursion levels.",
*lineno
);
}
}
else if (s[0] == '#')
{
/* comment: pass */
}
else if (s[0] == '}') /* up */
{
s = neos_strip(s);
if (strcmp(s, "}"))
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Trailing garbage on line following }: %s", path, *lineno,
line->buf);
return err;
}
return STATUS_OK;
}
else if (s[0])
{
/* Valid hdf name is [0-9a-zA-Z_.]+ */
name = s;
while (*s && (isalnum(*s) || *s == '_' || *s == '.' || *(unsigned char*)s > 127)) s++;
SKIPWS(s);
if (s[0] == '[') /* attributes */
{
*s = '\0';
name = neos_strip(name);
s++;
err = parse_attr(&s, &attr);
if (err)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
SKIPWS(s);
}
if (s[0] == '=') /* assignment */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':' && s[1] == '=') /* copy */
{
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
value = hdf_get_value(hdf->top, value, "");
err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':') /* link */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 1, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '{') /* deeper */
{
*s = '\0';
name = neos_strip(name);
lower = hdf_get_obj (hdf, name);
if (lower == NULL)
{
err = _set_value (hdf, name, NULL, 1, 1, 0, attr, &lower);
}
else
{
err = _set_value (lower, NULL, lower->value, 1, 1, 0, attr, NULL);
}
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
err = _hdf_read_string (lower, str, line, path, lineno, include_handle);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '<' && s[1] == '<') /* multi-line assignment */
{
char *m;
int msize = 0;
int mmax = 128;
int l;
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
l = strlen(value);
if (l == 0)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] No multi-assignment terminator given: %s", path, *lineno,
line->buf);
return err;
}
m = (char *) malloc (mmax * sizeof(char));
if (m == NULL)
{
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s",
path, *lineno, name);
}
while (_copy_line (str, m+msize, mmax-msize) != 0)
{
(*lineno)++;
if (!strncmp(value, m+msize, l) && isspace(m[msize+l]))
{
m[msize] = '\0';
break;
}
msize += strlen(m+msize);
if (msize + l + 10 > mmax)
{
void *new_ptr;
mmax += 128;
new_ptr = realloc (m, mmax * sizeof(char));
if (new_ptr == NULL)
{
free(m);
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s: size=%d",
path, *lineno, name, mmax);
}
m = (char *) new_ptr;
}
}
err = _set_value (hdf, name, m, 0, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
free (m);
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else
{
err = nerr_raise(NERR_PARSE, "[%s:%d] Unable to parse line %s", path,
*lineno, line->buf);
return err;
}
}
}
return STATUS_OK;
}