* See the file LICENSE for details.
* Sebastian Hammer, Adam Dickmeiss
*
- * $Id: d1_read.c,v 1.40 2002-05-03 13:48:27 adam Exp $
+ * $Id: d1_read.c,v 1.44 2002-07-03 10:04:04 adam Exp $
*/
#include <assert.h>
#include <yaz/log.h>
#include <yaz/data1.h>
+data1_node *data1_get_root_tag (data1_handle dh, data1_node *n)
+{
+ if (!n)
+ return 0;
+ n = n->child;
+ while (n && n->which != DATA1N_tag)
+ n = n->next;
+ return n;
+}
+
/*
* get the tag which is the immediate parent of this node (this may mean
* traversing intermediate things like variants and stuff.
return 0;
}
-data1_node *data1_mk_node (data1_handle dh, NMEM m, int type,
- data1_node *parent)
+data1_node *data1_mk_node (data1_handle dh, NMEM m)
{
- data1_node *r;
+ return data1_mk_node2 (dh, m, DATA1N_root, 0);
+}
+data1_node *data1_mk_node_type (data1_handle dh, NMEM m, int type)
+{
+ return data1_mk_node2 (dh, m, type, 0);
+}
+
+data1_node *data1_mk_node2 (data1_handle dh, NMEM m, int type,
+ data1_node *parent)
+{
+ data1_node *r;
+
r = (data1_node *)nmem_malloc(m, sizeof(*r));
r->next = r->child = r->last_child = 0;
r->destroy = 0;
if (!parent)
{
r->root = r;
- assert (type == DATA1N_root);
}
else
{
r->u.tag.node_selected = 0;
r->u.tag.make_variantlist = 0;
r->u.tag.get_bytes = -1;
-#if DATA1_USING_XATTR
r->u.tag.attributes = 0;
-#endif
break;
case DATA1N_root:
r->u.root.type = 0;
r->u.data.what = 0;
r->u.data.formatted_text = 0;
break;
+ case DATA1N_comment:
+ r->u.data.data = 0;
+ r->u.data.len = 0;
+ r->u.data.what = 0;
+ r->u.data.formatted_text = 1;
+ break;
case DATA1N_variant:
r->u.variant.type = 0;
r->u.variant.value = 0;
break;
+ case DATA1N_preprocess:
+ r->u.preprocess.target = 0;
+ r->u.preprocess.attributes = 0;
+ break;
default:
logf (LOG_WARN, "data_mk_node_type. bad type = %d\n", type);
}
(*t->destroy)(t);
}
-data1_node *data1_mk_root (data1_handle dh, NMEM nmem, const char *name)
+data1_node *data1_mk_root (data1_handle dh, NMEM nmem, const char *name)
{
data1_absyn *absyn = data1_get_absyn (dh, name);
data1_node *res;
name);
/* It's now OK for a record not to have an absyn */
}
- res = data1_mk_node (dh, nmem, DATA1N_root, 0);
+ res = data1_mk_node2 (dh, nmem, DATA1N_root, 0);
+ res->u.root.type = data1_insert_string (dh, res, nmem, name);
+ res->u.root.absyn = absyn;
+ return res;
+}
+
+void data1_set_root(data1_handle dh, data1_node *res,
+ NMEM nmem, const char *name)
+{
+ data1_absyn *absyn = data1_get_absyn (dh, name);
+
res->u.root.type = data1_insert_string (dh, res, nmem, name);
res->u.root.absyn = absyn;
+}
+
+data1_node *data1_mk_preprocess (data1_handle dh, NMEM nmem,
+ const char *target, const char **attr,
+ data1_node *at)
+{
+ data1_xattr **p;
+ data1_node *res = data1_mk_node2 (dh, nmem, DATA1N_preprocess, at);
+ res->u.preprocess.target = data1_insert_string (dh, res, nmem, target);
+
+ p = &res->u.preprocess.attributes;
+ while (attr && *attr)
+ {
+ *p = (data1_xattr*) nmem_malloc (nmem, sizeof(**p));
+ (*p)->name = nmem_strdup (nmem, *attr++);
+ (*p)->value = nmem_strdup (nmem, *attr++);
+ p = &(*p)->next;
+ }
+ *p = 0;
return res;
}
data1_node *data1_mk_tag_n (data1_handle dh, NMEM nmem,
- const char *tag, size_t len, data1_node *at)
+ const char *tag, size_t len, const char **attr,
+ data1_node *at)
{
data1_node *partag = get_parent_tag(dh, at);
- data1_node *res = data1_mk_node (dh, nmem, DATA1N_tag, at);
+ data1_node *res = data1_mk_node2 (dh, nmem, DATA1N_tag, at);
data1_element *e = NULL;
+ data1_xattr **p;
res->u.tag.tag = data1_insert_string_n (dh, res, nmem, tag, len);
res->u.tag.element =
data1_getelementbytagname (dh, at->root->u.root.absyn,
e, res->u.tag.tag);
+ p = &res->u.tag.attributes;
+ while (attr && *attr)
+ {
+ *p = (data1_xattr*) nmem_malloc (nmem, sizeof(**p));
+ (*p)->name = nmem_strdup (nmem, *attr++);
+ (*p)->value = nmem_strdup (nmem, *attr++);
+ p = &(*p)->next;
+ }
+ *p = 0;
return res;
}
+void data1_tag_add_attr (data1_handle dh, NMEM nmem,
+ data1_node *res, const char **attr)
+{
+ data1_xattr **p;
+
+ if (res->which != DATA1N_tag)
+ return;
+
+ p = &res->u.tag.attributes;
+ while (*p)
+ p = &(*p)->next;
+
+ while (attr && *attr)
+ {
+ *p = (data1_xattr*) nmem_malloc (nmem, sizeof(**p));
+ (*p)->name = nmem_strdup (nmem, *attr++);
+ (*p)->value = nmem_strdup (nmem, *attr++);
+ p = &(*p)->next;
+ }
+ *p = 0;
+}
+
data1_node *data1_mk_tag (data1_handle dh, NMEM nmem,
- const char *tag, data1_node *at)
+ const char *tag, const char **attr, data1_node *at)
{
- return data1_mk_tag_n (dh, nmem, tag, strlen(tag), at);
+ return data1_mk_tag_n (dh, nmem, tag, strlen(tag), attr, at);
}
data1_node *data1_search_tag (data1_handle dh, data1_node *n,
const char *tag)
{
+ if (*tag == '/')
+ {
+ n = data1_get_root_tag (dh, n);
+ if (n)
+ n = n->child;
+ tag++;
+ }
for (; n; n = n->next)
if (n->which == DATA1N_tag && n->u.tag.tag &&
!yaz_matchstr (tag, n->u.tag.tag))
{
data1_node *node = data1_search_tag (dh, at->child, tag);
if (!node)
- node = data1_mk_tag (dh, nmem, tag, at);
+ node = data1_mk_tag (dh, nmem, tag, 0 /* attr */, at);
+ else
+ node->child = node->last_child = 0;
return node;
}
-
data1_node *data1_mk_text_n (data1_handle dh, NMEM mem,
const char *buf, size_t len, data1_node *parent)
{
- data1_node *res = data1_mk_node (dh, mem, DATA1N_data, parent);
+ data1_node *res = data1_mk_node2 (dh, mem, DATA1N_data, parent);
res->u.data.what = DATA1I_text;
res->u.data.len = len;
return res;
}
+data1_node *data1_mk_text_nf (data1_handle dh, NMEM mem,
+ const char *buf, size_t len, data1_node *parent)
+{
+ data1_node *res = data1_mk_text_n (dh, mem, buf, len, parent);
+ res->u.data.formatted_text = 1;
+ return res;
+}
data1_node *data1_mk_text (data1_handle dh, NMEM mem,
const char *buf, data1_node *parent)
return data1_mk_text_n (dh, mem, buf, strlen(buf), parent);
}
+data1_node *data1_mk_comment_n (data1_handle dh, NMEM mem,
+ const char *buf, size_t len,
+ data1_node *parent)
+{
+ data1_node *res = data1_mk_node2 (dh, mem, DATA1N_comment, parent);
+ res->u.data.what = DATA1I_text;
+ res->u.data.len = len;
+
+ res->u.data.data = data1_insert_string_n (dh, res, mem, buf, len);
+ return res;
+}
+
+data1_node *data1_mk_comment (data1_handle dh, NMEM mem,
+ const char *buf, data1_node *parent)
+{
+ return data1_mk_comment_n (dh, mem, buf, strlen(buf), parent);
+}
+
char *data1_insert_string_n (data1_handle dh, data1_node *res,
NMEM m, const char *str, size_t len)
{
}
static data1_node *data1_add_insert_taggeddata(data1_handle dh,
- data1_node *root,
data1_node *at,
const char *tagname, NMEM m,
int local_allowed)
{
+ data1_node *root = at->root;
data1_node *partag = get_parent_tag (dh, at);
data1_element *e = NULL;
data1_node *datn = 0;
e = data1_getelementbytagname (dh, root->u.root.absyn, e, tagname);
if (local_allowed || e)
{
- tagn = data1_mk_node (dh, m, DATA1N_tag, at);
+ tagn = data1_mk_node2 (dh, m, DATA1N_tag, at);
tagn->u.tag.tag = data1_insert_string (dh, tagn, m, tagname);
tagn->u.tag.element = e;
- datn = data1_mk_node (dh, m, DATA1N_data, tagn);
+ datn = data1_mk_node2 (dh, m, DATA1N_data, tagn);
}
return datn;
}
-data1_node *data1_mk_tag_data(data1_handle dh, data1_node *root,
- data1_node *at,
+data1_node *data1_mk_tag_data(data1_handle dh, data1_node *at,
const char *tagname, NMEM m)
{
- return data1_add_insert_taggeddata (dh, root, at, tagname, m, 1);
+ return data1_add_insert_taggeddata (dh, at, tagname, m, 1);
}
* which should be root or tag itself). Returns pointer to the data node,
* which can then be modified.
*/
-data1_node *data1_mk_tag_data_wd(data1_handle dh, data1_node *root,
- data1_node *at,
+data1_node *data1_mk_tag_data_wd(data1_handle dh, data1_node *at,
const char *tagname, NMEM m)
{
- return data1_add_insert_taggeddata (dh, root, at, tagname, m, 0);
+ return data1_add_insert_taggeddata (dh, at, tagname, m, 0);
+}
+
+data1_node *data1_insert_taggeddata (data1_handle dh, data1_node *root,
+ data1_node *at, const char *tagname,
+ NMEM m)
+{
+ return data1_add_insert_taggeddata (dh, at, tagname, m, 0);
}
+data1_node *data1_add_taggeddata (data1_handle dh, data1_node *root,
+ data1_node *at, const char *tagname,
+ NMEM m)
+{
+ return data1_add_insert_taggeddata (dh, at, tagname, m, 1);
+}
data1_node *data1_mk_tag_data_int (data1_handle dh, data1_node *at,
const char *tag, int num,
{
data1_node *node_data;
- node_data = data1_mk_tag_data (dh, at->root, at, tag, nmem);
+ node_data = data1_mk_tag_data (dh, at, tag, nmem);
if (!node_data)
return 0;
node_data->u.data.what = DATA1I_num;
char str[128], *p = str;
Odr_oid *ii;
- node_data = data1_mk_tag_data (dh, at->root, at, tag, nmem);
+ node_data = data1_mk_tag_data (dh, at, tag, nmem);
if (!node_data)
return 0;
{
data1_node *node_data;
- node_data = data1_mk_tag_data (dh, at->root, at, tag, nmem);
+ node_data = data1_mk_tag_data (dh, at, tag, nmem);
if (!node_data)
return 0;
node_data->u.data.what = DATA1I_text;
node_data->u.data.len = strlen (str);
node_data->u.data.data = data1_insert_string (dh, node_data,
nmem, str);
+ node_data->child = node_data->last_child = 0;
return node_data;
}
}
-#if DATA1_USING_XATTR
data1_xattr *data1_read_xattr (data1_handle dh, NMEM m,
int (*get_byte)(void *fh), void *fh,
WRBUF wrbuf, int *ch)
*ch = c;
return p_first;
}
-#endif
/*
* Ugh. Sometimes functions just grow and grow on you. This one reads a
if (c == '<') /* beginning of tag */
{
-#if DATA1_USING_XATTR
data1_xattr *xattr;
-#endif
+
char tag[64];
char args[256];
int null_tag = 0;
c = (*get_byte)(fh);
}
tag[i] = '\0';
-#if DATA1_USING_XATTR
xattr = data1_read_xattr (dh, m, get_byte, fh, wrbuf, &c);
args[0] = '\0';
-#else
- while (d1_isspace(c))
- c = (*get_byte)(fh);
- for (i = 0; c && c != '>' && c != '/'; c = (*get_byte)(fh))
- if (i < (sizeof(args)-1))
- args[i++] = c;
- args[i] = '\0';
-#endif
if (c == '/')
{ /* <tag attrs/> or <tag/> */
null_tag = 1;
break;
}
}
- if (level == 0)
+ if (level <= 1)
return d1_stack[0];
continue;
}
- if (level == 0) /* root ? */
- {
- res = data1_mk_root (dh, m, tag);
- }
else if (!strcmp(tag, "var"))
{
char tclass[DATA1_MAX_SYMBOL], type[DATA1_MAX_SYMBOL];
*/
if (parent->which != DATA1N_variant)
{
- res = data1_mk_node (dh, m, DATA1N_variant, parent);
+ res = data1_mk_node2 (dh, m, DATA1N_variant, parent);
}
else
{
level = i;
break;
}
- res = data1_mk_node (dh, m, DATA1N_variant, parent);
+ res = data1_mk_node2 (dh, m, DATA1N_variant, parent);
res->u.variant.type = tp;
res->u.variant.value =
data1_insert_string (dh, res, m, args + val_offset);
}
}
- else /* tag.. acquire our element in the abstract syntax */
- res = data1_mk_tag (dh, m, tag, parent);
+ else
+ {
+
+ /* tag .. acquire our element in the abstract syntax */
+ if (level == 0)
+ {
+ parent = data1_mk_root (dh, m, tag);
+ d1_stack[level++] = parent;
+ }
+ res = data1_mk_tag (dh, m, tag, 0 /* attr */, parent);
+ res->u.tag.attributes = xattr;
+ }
d1_stack[level] = res;
d1_stack[level+1] = 0;
if (level < 250 && !null_tag)
c = (*get_byte)(fh);
continue;
}
- res = data1_mk_node (dh, m, DATA1N_data, parent);
+ res = data1_mk_node2 (dh, m, DATA1N_data, parent);
res->u.data.what = DATA1I_text;
res->u.data.formatted_text = 0;
d1_stack[level] = res;