X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=retrieval%2Fd1_read.c;h=d2c886328a0325d0d3311f68a5e2c29bb48a2ca2;hb=40de6aa3aafbf959d7fc3a1002e8a43874c77d7c;hp=743a65ca52b4d744bf646b4f17c8bfff41b31261;hpb=ffe5c37f0c9f55a685ac3559f1cad44baae399f4;p=yaz-moved-to-github.git

diff --git a/retrieval/d1_read.c b/retrieval/d1_read.c
index 743a65c..d2c8863 100644
--- a/retrieval/d1_read.c
+++ b/retrieval/d1_read.c
@@ -3,7 +3,7 @@
  * 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.43 2002-05-21 07:43:16 adam Exp $
  */
 
 #include <assert.h>
@@ -26,11 +26,21 @@ data1_node *get_parent_tag (data1_handle dh, data1_node *n)
     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;
@@ -38,7 +48,6 @@ data1_node *data1_mk_node (data1_handle dh, NMEM m, int type,
     if (!parent)
     {
         r->root = r;
-        assert (type == DATA1N_root);
     }
     else
     {
@@ -60,9 +69,7 @@ data1_node *data1_mk_node (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;
@@ -108,18 +115,20 @@ data1_node *data1_mk_root (data1_handle dh, NMEM nmem,  const char *name)
                 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;
 }
 
 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);
     
@@ -128,13 +137,22 @@ 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;
 }
 
 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,
@@ -154,7 +172,9 @@ 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;
 }
 
@@ -162,7 +182,7 @@ data1_node *data1_mk_tag_uni (data1_handle dh, NMEM nmem,
 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;
     
@@ -170,13 +190,30 @@ data1_node *data1_mk_text_n (data1_handle dh, NMEM mem,
     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)
 {
@@ -197,11 +234,11 @@ char *data1_insert_string (data1_handle dh, data1_node *res,
 }
 
 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;
@@ -212,19 +249,18 @@ static data1_node *data1_add_insert_taggeddata(data1_handle dh,
     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);
 }
 
 
@@ -233,13 +269,25 @@ data1_node *data1_mk_tag_data(data1_handle dh, data1_node *root,
  * 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,
@@ -247,7 +295,7 @@ data1_node *data1_mk_tag_data_int (data1_handle dh, data1_node *at,
 {
     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;
@@ -265,7 +313,7 @@ data1_node *data1_mk_tag_data_oid (data1_handle dh, data1_node *at,
     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;
     
@@ -289,7 +337,7 @@ data1_node *data1_mk_tag_data_text (data1_handle dh, data1_node *at,
 {
     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;
@@ -313,12 +361,12 @@ data1_node *data1_mk_tag_data_text_uni (data1_handle dh, data1_node *at,
 	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)
@@ -382,7 +430,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
@@ -413,9 +460,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;
@@ -443,17 +489,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;
@@ -524,7 +561,7 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m,
 		 */
 		if (parent->which != DATA1N_variant)
 		{
-		    res = data1_mk_node (dh, m, DATA1N_variant, parent);
+		    res = data1_mk_node2 (dh, m, DATA1N_variant, parent);
 		}
 		else
 		{
@@ -539,14 +576,18 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m,
 			    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 */
+                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)
@@ -563,7 +604,7 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m,
 		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;