X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=retrieval%2Fd1_read.c;h=e79ad726ec9a0fdaed95def944b511be3fbc8793;hb=0a39dcf0b6b38833a59e3deae198ef204cfee003;hp=21290c4fc314dbacfeafe4bc77f69333ba7d3fe9;hpb=848e461264a05c14f4ced38f2df25c2232779fdd;p=yaz-moved-to-github.git

diff --git a/retrieval/d1_read.c b/retrieval/d1_read.c
index 21290c4..e79ad72 100644
--- a/retrieval/d1_read.c
+++ b/retrieval/d1_read.c
@@ -3,17 +3,33 @@
  * See the file LICENSE for details.
  * Sebastian Hammer, Adam Dickmeiss
  *
- * $Id: d1_read.c,v 1.41 2002-05-07 11:02:56 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.
@@ -69,9 +85,7 @@ data1_node *data1_mk_node2 (data1_handle dh, NMEM m, int type,
 	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;
@@ -83,10 +97,20 @@ data1_node *data1_mk_node2 (data1_handle dh, NMEM m, int type,
 	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);
     }
@@ -107,7 +131,7 @@ void data1_free_tree (data1_handle dh, data1_node *t)
 	(*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;
@@ -123,12 +147,43 @@ data1_node *data1_mk_root (data1_handle dh, NMEM nmem,  const char *name)
     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_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);
     
@@ -137,18 +192,56 @@ data1_node *data1_mk_tag_n (data1_handle dh, NMEM nmem,
     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))
@@ -163,13 +256,12 @@ data1_node *data1_mk_tag_uni (data1_handle dh, NMEM nmem,
 {
     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)
 {
@@ -181,6 +273,13 @@ data1_node *data1_mk_text_n (data1_handle dh, NMEM mem,
     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)
@@ -188,6 +287,24 @@ data1_node *data1_mk_text (data1_handle dh, NMEM mem,
     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)
 {
@@ -341,7 +458,6 @@ data1_node *data1_mk_tag_data_text_uni (data1_handle dh, data1_node *at,
 }
 
 
-#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)
@@ -405,7 +521,6 @@ data1_xattr *data1_read_xattr (data1_handle dh, NMEM m,
     *ch = c;
     return p_first;
 }
-#endif
 
 /*
  * Ugh. Sometimes functions just grow and grow on you. This one reads a
@@ -436,9 +551,8 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m,
 	
 	if (c == '<') /* beginning of tag */
 	{
-#if DATA1_USING_XATTR
 	    data1_xattr *xattr;
-#endif
+
 	    char tag[64];
 	    char args[256];
 	    int null_tag = 0;
@@ -466,17 +580,8 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m,
 		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;
@@ -517,14 +622,10 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m,
 			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];
@@ -568,8 +669,18 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m,
 			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)
@@ -688,3 +799,99 @@ data1_node *data1_read_sgml (data1_handle dh, NMEM m, const char *buf)
     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
+}