X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=retrieval%2Fd1_read.c;h=130c51853d7dfcf2acef1e66f045b50a3f11ff45;hb=caa50534e057668bf2cded573d41c5b07034633b;hp=743a65ca52b4d744bf646b4f17c8bfff41b31261;hpb=ffe5c37f0c9f55a685ac3559f1cad44baae399f4;p=yaz-moved-to-github.git diff --git a/retrieval/d1_read.c b/retrieval/d1_read.c index 743a65c..130c518 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.51 2002-08-28 07:54:11 adam Exp $ */ #include @@ -11,26 +11,60 @@ #include #include +#include #include #include +data1_node *data1_get_root_tag (data1_handle dh, data1_node *n) +{ + if (!n) + return 0; + if (data1_is_xmlmode(dh)) + { + 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. */ data1_node *get_parent_tag (data1_handle dh, data1_node *n) { - for (; n && n->which != DATA1N_root; n = n->parent) - if (n->which == DATA1N_tag) - return n; + if (data1_is_xmlmode(dh)) + { + for (; n && n->which != DATA1N_root; n = n->parent) + if (n->which == DATA1N_tag && n->parent && + n->parent->which != DATA1N_root) + return n; + } + else + { + for (; n && n->which != DATA1N_root; n = n->parent) + if (n->which == DATA1N_tag) + return 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 +72,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 +93,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 +105,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 +139,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,38 +149,115 @@ 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_element *e = NULL; + data1_node *res = data1_mk_node2 (dh, nmem, DATA1N_tag, at); + data1_xattr **p; + data1_element *e = 0; res->u.tag.tag = data1_insert_string_n (dh, res, nmem, tag, len); - if (partag) - e = partag->u.tag.element; - res->u.tag.element = - data1_getelementbytagname (dh, at->root->u.root.absyn, - e, res->u.tag.tag); + if (!partag) /* top tag? */ + e = data1_getelementbytagname (dh, at->root->u.root.absyn, + 0 /* index as local */, + res->u.tag.tag); + else + { + /* only set element for known tags */ + e = partag->u.tag.element; + if (e) + e = data1_getelementbytagname (dh, at->root->u.root.absyn, + e, res->u.tag.tag); + } + res->u.tag.element = e; + 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 +272,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 +289,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 +303,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,34 +341,38 @@ 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; data1_node *tagn = 0; - if (partag) + if (!partag) + e = data1_getelementbytagname (dh, root->u.root.absyn, 0, tagname); + else + { e = partag->u.tag.element; - e = data1_getelementbytagname (dh, root->u.root.absyn, e, tagname); + if (e) + 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 +381,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 +407,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 +425,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 +449,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,15 +473,53 @@ 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; } } +static int ampr (int (*get_byte)(void *fh), void *fh, int *amp) +{ + int c = (*get_byte)(fh); + *amp = 0; + if (c == '&') + { + char ent[20]; + int i = 0; + + while (1) + { + c = (*get_byte)(fh); + if (c == ';') + { + ent[i] = 0; + + c = ' '; + if (!strcmp (ent, "quot")) + c = '"'; + if (!strcmp (ent, "apos")) + c = '\''; + if (!strcmp (ent, "gt")) + c = '>'; + if (!strcmp (ent, "lt")) + c = '<'; + if (!strcmp (ent, "amp")) + c = '&'; + *amp = 1; + break; + } + else if (c == 0 || d1_isspace(c)) + break; + if (i < 19) + ent[i++] = c; + } + } + return c; +} -#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) + WRBUF wrbuf, int *ch, int *amp) { data1_xattr *p_first = 0; data1_xattr **pp = &p_first; @@ -330,9 +528,9 @@ data1_xattr *data1_read_xattr (data1_handle dh, NMEM m, { data1_xattr *p; int len; - while (c && d1_isspace(c)) - c = (*get_byte)(fh); - if (!c || c == '>' || c == '/') + while (*amp || (c && d1_isspace(c))) + c = ampr (get_byte, fh, amp); + if (*amp == 0 && (c == 0 || c == '>' || c == '/')) break; *pp = p = (data1_xattr *) nmem_malloc (m, sizeof(*p)); p->next = 0; @@ -343,7 +541,7 @@ data1_xattr *data1_read_xattr (data1_handle dh, NMEM m, while (c && c != '=' && c != '>' && c != '/' && !d1_isspace(c)) { wrbuf_putc (wrbuf, c); - c = (*get_byte)(fh); + c = ampr (get_byte, fh, amp); } wrbuf_putc (wrbuf, '\0'); len = wrbuf_len(wrbuf); @@ -351,26 +549,38 @@ data1_xattr *data1_read_xattr (data1_handle dh, NMEM m, strcpy (p->name, wrbuf_buf(wrbuf)); if (c == '=') { - c = (*get_byte)(fh); - if (c == '"') + c = ampr (get_byte, fh, amp); + if (*amp == 0 && c == '"') + { + c = ampr (get_byte, fh, amp); + wrbuf_rewind(wrbuf); + while (*amp || (c && c != '"')) + { + wrbuf_putc (wrbuf, c); + c = ampr (get_byte, fh, amp); + } + if (c) + c = ampr (get_byte, fh, amp); + } + else if (*amp == 0 && c == '\'') { - c = (*get_byte)(fh); + c = ampr (get_byte, fh, amp); wrbuf_rewind(wrbuf); - while (c && c != '"') + while (*amp || (c && c != '\'')) { wrbuf_putc (wrbuf, c); - c = (*get_byte)(fh); + c = ampr (get_byte, fh, amp); } if (c) - c = (*get_byte)(fh); + c = ampr (get_byte, fh, amp); } else { wrbuf_rewind(wrbuf); - while (c && c != '>' && c != '/') + while (*amp || (c && c != '>' && c != '/')) { wrbuf_putc (wrbuf, c); - c = (*get_byte)(fh); + c = ampr (get_byte, fh, amp); } } wrbuf_putc (wrbuf, '\0'); @@ -382,7 +592,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 @@ -393,79 +602,62 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m, { data1_node *d1_stack[256]; data1_node *res; - int c; + int c, amp; int level = 0; int line = 1; d1_stack[level] = 0; - c = (*get_byte)(fh); - while (1) + c = ampr (get_byte, fh, &); + while (c != '\0') { data1_node *parent = level ? d1_stack[level-1] : 0; - while (c != '\0' && d1_isspace(c)) - { - if (c == '\n') - line++; - c = (*get_byte)(fh); - } - if (c == '\0') - break; - - if (c == '<') /* beginning of tag */ + + if (amp == 0 && c == '<') /* beginning of tag */ { -#if DATA1_USING_XATTR data1_xattr *xattr; -#endif + char tag[64]; char args[256]; int null_tag = 0; int end_tag = 0; size_t i = 0; - c = (*get_byte)(fh); - if (c == '/') + c = ampr (get_byte, fh, &); + if (amp == 0 && c == '/') { end_tag = 1; - c = (*get_byte)(fh); + c = ampr (get_byte, fh, &); } - else if (c == '!') /* tags/comments that we don't deal with yet */ + else if (amp == 0 && c == '!') + /* tags/comments that we don't deal with yet */ { - while (c && c != '>') - c = (*get_byte)(fh); + while (amp || (c && c != '>')) + c = ampr (get_byte, fh, &); if (c) - c = (*get_byte)(fh); + c = ampr (get_byte, fh, &); continue; } - while (c && c != '>' && c != '/' && !d1_isspace(c)) + while (amp || (c && c != '>' && c != '/' && !d1_isspace(c))) { if (i < (sizeof(tag)-1)) tag[i++] = c; - c = (*get_byte)(fh); + c = ampr (get_byte, fh, &); } tag[i] = '\0'; -#if DATA1_USING_XATTR - xattr = data1_read_xattr (dh, m, get_byte, fh, wrbuf, &c); + 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 == '/') + if (amp == 0 && c == '/') { /* or */ null_tag = 1; - c = (*get_byte)(fh); + c = ampr (get_byte, fh, &); } - if (c != '>') + if (amp || c != '>') { yaz_log(LOG_WARN, "d1: %d: Malformed tag", line); return 0; } else - c = (*get_byte)(fh); + c = ampr (get_byte, fh, &); /* End tag? */ if (end_tag) @@ -494,14 +686,18 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m, break; } } - if (level == 0) - return d1_stack[0]; + if (data1_is_xmlmode(dh)) + { + if (level <= 1) + return d1_stack[0]; + } + else + { + if (level <= 0) + 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 +720,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 +735,34 @@ 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); + res = d1_stack[level] = parent; + + if (data1_is_xmlmode(dh)) + { + level++; + res = data1_mk_tag (dh, m, tag, 0 /* attr */, parent); + res->u.tag.attributes = xattr; + } + } + else + { + 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) @@ -554,26 +770,24 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m, } else /* != '<'... this is a body of text */ { - const char *src; - char *dst; - int len, prev_char = 0; + int len; if (level == 0) { - c = (*get_byte)(fh); + c = ampr (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; wrbuf_rewind(wrbuf); - while (c && c != '<') + while (amp || (c && c != '<')) { wrbuf_putc (wrbuf, c); - c = (*get_byte)(fh); + c = ampr (get_byte, fh, &); } len = wrbuf_len(wrbuf); @@ -582,26 +796,12 @@ data1_node *data1_read_nodex (data1_handle dh, NMEM m, res->u.data.data = (char*) nmem_malloc (m, len); else res->u.data.data = res->lbuf; - - /* read "data" and transfer while removing white space */ - dst = res->u.data.data; - for (src = wrbuf_buf(wrbuf); --len >= 0; src++) - { - if (*src == '\n') - line++; - if (d1_isspace (*src)) - prev_char = ' '; - else - { - if (prev_char) - { - *dst++ = prev_char; - prev_char = 0; - } - *dst++ = *src; - } - } - res->u.data.len = dst - res->u.data.data; + + if (len) + memcpy (res->u.data.data, wrbuf_buf(wrbuf), len); + else + res->u.data.data = 0; + res->u.data.len = len; } } return 0; @@ -665,3 +865,124 @@ data1_node *data1_read_sgml (data1_handle dh, NMEM m, const char *buf) return data1_read_node (dh, &bp, m); } + +static int conv_item (NMEM m, yaz_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 (yaz_iconv (t, &inbuf, &inlen, &outbuf, &outlen) == + (size_t)(-1) && yaz_iconv_error(t) != YAZ_ICONV_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, + yaz_iconv_t t, WRBUF wrbuf, const char *tocode) +{ + 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 (p->value && + conv_item(m, t, wrbuf, p->value, strlen(p->value)) + == 0) + { + wrbuf_puts (wrbuf, ""); + p->value = nmem_strdup (m, wrbuf->buf); + } + } + } + break; + case DATA1N_preprocess: + if (strcmp(n->u.preprocess.target, "xml") == 0) + { + data1_xattr *p = n->u.preprocess.attributes; + for (; p; p = p->next) + if (strcmp (p->name, "encoding") == 0) + p->value = nmem_strdup (m, tocode); + } + break; + } + data1_iconv_s (dh, m, n->child, t, wrbuf, tocode); + } +} + +const char *data1_get_encoding (data1_handle dh, data1_node *n) +{ + /* see if we have an xml header that specifies encoding */ + if (n && n->child && n->child->which == DATA1N_preprocess && + strcmp (n->child->u.preprocess.target, "xml") == 0) + { + data1_xattr *xp = n->child->u.preprocess.attributes; + for (; xp; xp = xp->next) + if (!strcmp (xp->name, "encoding") == 0) + return xp->value; + } + /* no encoding in header, so see if "encoding" was specified for abs */ + if (n && n->which == DATA1N_root && + n->u.root.absyn && n->u.root.absyn->encoding) + return n->u.root.absyn->encoding; + /* none of above, return a hard coded default */ + return "ISO-8859-1"; +} + +int data1_iconv (data1_handle dh, NMEM m, data1_node *n, + const char *tocode, + const char *fromcode) +{ + if (strcmp (tocode, fromcode)) + { + WRBUF wrbuf = wrbuf_alloc(); + yaz_iconv_t t = yaz_iconv_open (tocode, fromcode); + if (!t) + return -1; + data1_iconv_s (dh, m, n, t, wrbuf, tocode); + yaz_iconv_close (t); + wrbuf_free (wrbuf, 1); + } + return 0; +}