X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=retrieval%2Fd1_read.c;h=66baf41cc3a20db3a2decf2dea20c57fcb0bd1b1;hb=aeec32da5e13c9f46062d07ac3c16582dbd479c8;hp=21290c4fc314dbacfeafe4bc77f69333ba7d3fe9;hpb=848e461264a05c14f4ced38f2df25c2232779fdd;p=yaz-moved-to-github.git diff --git a/retrieval/d1_read.c b/retrieval/d1_read.c index 21290c4..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.41 2002-05-07 11:02:56 adam Exp $ + * $Id: d1_read.c,v 1.44 2002-07-03 10:04:04 adam Exp $ */ #include @@ -14,6 +14,16 @@ #include #include +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 +79,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 +91,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 +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; @@ -123,12 +141,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 +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)) @@ -163,13 +250,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 +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) @@ -188,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) { @@ -341,7 +452,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 +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 @@ -436,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; @@ -466,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 == '/') { /* or */ null_tag = 1; @@ -517,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]; @@ -568,8 +663,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)