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

diff --git a/retrieval/d1_read.c b/retrieval/d1_read.c
index 743a65c..66baf41 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.44 2002-07-03 10:04:04 adam Exp $
  */
 
 #include <assert.h>
@@ -14,6 +14,16 @@
 #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.
@@ -26,11 +36,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 +58,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 +79,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;
@@ -74,10 +91,20 @@ data1_node *data1_mk_node (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);
     }
@@ -98,7 +125,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;
@@ -108,18 +135,49 @@ 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;
+}
+
+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);
     
@@ -128,18 +186,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))
@@ -154,15 +250,16 @@ 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)
 {
-    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,6 +267,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)
@@ -177,6 +281,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)
 {
@@ -197,11 +319,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 +334,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 +354,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 +380,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 +398,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 +422,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 +446,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 +515,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 +545,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 +574,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;
@@ -494,14 +616,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];
@@ -524,7 +642,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 +657,24 @@ 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 */
+                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)
@@ -563,7 +691,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;