* See the file LICENSE for details.
* Sebastian Hammer, Adam Dickmeiss
*
- * $Id: d1_read.c,v 1.43 2002-05-21 07:43:16 adam Exp $
+ * $Id: d1_read.c,v 1.45 2002-07-05 16:04:28 adam Exp $
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
+#include <errno.h>
+
+#if HAVE_ICONV_H
+#include <iconv.h>
+#endif
+
#include <yaz/xmalloc.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.
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;
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, const char **attr,
data1_node *at)
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, const char **attr, data1_node *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))
return node;
}
-
data1_node *data1_mk_text_n (data1_handle dh, NMEM mem,
const char *buf, size_t len, data1_node *parent)
{
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)
{
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];
}
else
{
- /* tag.. acquire our element in the abstract syntax */
+
+ /* 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;
}
return data1_read_node (dh, &bp, m);
}
+
+#if HAVE_ICONV_H
+
+static int conv_item (NMEM m, iconv_t t,
+ WRBUF wrbuf, char *inbuf, size_t inlen)
+{
+ wrbuf_rewind (wrbuf);
+ if (wrbuf->size < 10)
+ wrbuf_grow (wrbuf, 10);
+ for (;;)
+ {
+ char *outbuf = wrbuf->buf + wrbuf->pos;
+ size_t outlen = wrbuf->size - wrbuf->pos;
+ if (iconv (t, &inbuf, &inlen, &outbuf, &outlen) ==
+ (size_t)(-1) && errno != E2BIG)
+ {
+ /* bad data. stop and skip conversion entirely */
+ return -1;
+ }
+ else if (inlen == 0)
+ { /* finished converting */
+ wrbuf->pos = wrbuf->size - outlen;
+ break;
+ }
+ else
+ {
+ /* buffer too small: make sure we expand buffer */
+ wrbuf->pos = wrbuf->size - outlen;
+ wrbuf_grow(wrbuf, 20);
+ }
+ }
+ return 0;
+}
+
+static void data1_iconv_s (data1_handle dh, NMEM m, data1_node *n,
+ iconv_t t, WRBUF wrbuf)
+{
+ for (; n; n = n->next)
+ {
+ switch (n->which)
+ {
+ case DATA1N_data:
+ case DATA1N_comment:
+ if (conv_item (m, t, wrbuf, n->u.data.data, n->u.data.len) == 0)
+ {
+ n->u.data.data =
+ data1_insert_string_n (dh, n, m, wrbuf->buf,
+ wrbuf->pos);
+ n->u.data.len = wrbuf->pos;
+ }
+ break;
+ case DATA1N_tag:
+ if (conv_item (m, t, wrbuf, n->u.tag.tag, strlen(n->u.tag.tag))
+ == 0)
+ {
+ n->u.tag.tag =
+ data1_insert_string_n (dh, n, m,
+ wrbuf->buf, wrbuf->pos);
+ }
+ if (n->u.tag.attributes)
+ {
+ data1_xattr *p;
+ for (p = n->u.tag.attributes; p; p = p->next)
+ {
+ if (conv_item(m, t, wrbuf, p->value, strlen(p->value))
+ == 0)
+ {
+ wrbuf_puts (wrbuf, "");
+ p->value = nmem_strdup (m, wrbuf->buf);
+ }
+ }
+ }
+ break;
+ }
+ data1_iconv_s (dh, m, n->child, t, wrbuf);
+ }
+}
+#endif
+
+int data1_iconv (data1_handle dh, NMEM m, data1_node *n,
+ const char *tocode,
+ const char *fromcode)
+{
+#if HAVE_ICONV_H
+ WRBUF wrbuf = wrbuf_alloc();
+ iconv_t t = iconv_open (tocode, fromcode);
+ if (t == (iconv_t) (-1))
+ return -1;
+ data1_iconv_s (dh, m, n, t, wrbuf);
+ iconv_close (t);
+ wrbuf_free (wrbuf, 1);
+ return 0;
+#else
+ return -2;
+#endif
+}
projects / yaz-moved-to-github.git / blobdiff