X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=retrieval%2Fd1_grs.c;h=5432b0f5ad94d3cda292809b225a7233d9d1c360;hb=424b34cfd7042e0c854ba2ca1f2cc656b61f3e46;hp=d17ca3c5973abb7ff9bdef4ed68fde3c17559e31;hpb=044d170f0a963555486df54653cd2fdc5815928b;p=yaz-moved-to-github.git diff --git a/retrieval/d1_grs.c b/retrieval/d1_grs.c index d17ca3c..5432b0f 100644 --- a/retrieval/d1_grs.c +++ b/retrieval/d1_grs.c @@ -1,60 +1,18 @@ /* - * Copyright (c) 1995-1997, Index Data. + * Copyright (c) 1995-2002, Index Data. * See the file LICENSE for details. * Sebastian Hammer, Adam Dickmeiss * - * $Log: d1_grs.c,v $ - * Revision 1.13 1998-02-11 11:53:35 adam - * Changed code so that it compiles as C++. - * - * Revision 1.12 1997/11/24 11:33:56 adam - * Using function odr_nullval() instead of global ODR_NULLVAL when - * appropriate. - * - * Revision 1.11 1997/11/18 09:51:09 adam - * Removed element num_children from data1_node. Minor changes in - * data1 to Explain. - * - * Revision 1.10 1997/09/17 12:10:36 adam - * YAZ version 1.4. - * - * Revision 1.9 1997/05/14 06:54:03 adam - * C++ support. - * - * Revision 1.8 1996/12/05 13:17:49 quinn - * Fixed GRS-1 null-ref - * - * Revision 1.7 1996/10/11 11:57:23 quinn - * Smallish - * - * Revision 1.6 1996/07/06 19:58:34 quinn - * System headerfiles gathered in yconfig - * - * Revision 1.5 1996/06/03 09:46:42 quinn - * Added OID data type. - * - * Revision 1.4 1996/05/01 12:45:30 quinn - * Support use of local tag names in abs file. - * - * Revision 1.3 1995/11/13 09:27:35 quinn - * Fiddling with the variant stuff. - * - * Revision 1.2 1995/11/01 13:54:46 quinn - * Minor adjustments - * - * Revision 1.1 1995/11/01 11:56:07 quinn - * Added Retrieval (data management) functions en masse. - * + * $Id: d1_grs.c,v 1.24 2002-07-25 12:52:53 adam Exp $ * */ #include #include -#include -#include - -#include +#include +#include +#include #define D1_VARIANTARRAY 20 /* fixed max length on sup'd variant-list. Lazy me */ @@ -113,13 +71,12 @@ static Z_Variant *make_variant(data1_node *n, int num, ODR o) { case DATA1K_string: t->which = Z_Triple_internationalString; - t->value.internationalString = (char *)odr_malloc(o, - strlen(p->u.variant.value)+1); - strcpy(t->value.internationalString, p->u.variant.value); + t->value.internationalString = + odr_strdup(o, p->u.variant.value); break; default: - logf(LOG_WARN, "Unable to handle value for variant %s", - p->u.variant.type->name); + yaz_log(LOG_WARN, "Unable to handle value for variant %s", + p->u.variant.type->name); return 0; } } @@ -142,8 +99,8 @@ static int traverse_triples(data1_node *n, int level, Z_ElementMetaData *m, D1_VARIANTARRAY); else if (m->num_supportedVariants >= D1_VARIANTARRAY) { - logf(LOG_WARN, "Too many variants (D1_VARIANTARRAY==%d)", - D1_VARIANTARRAY); + yaz_log(LOG_WARN, "Too many variants (D1_VARIANTARRAY==%d)", + D1_VARIANTARRAY); return -1; } @@ -168,7 +125,7 @@ static Z_ElementData *nodetoelementdata(data1_handle dh, data1_node *n, res->which = Z_ElementData_elementNotThere; res->u.elementNotThere = odr_nullval(); } - else if (n->which == DATA1N_data && (leaf || n->next == NULL)) + else if (n->which == DATA1N_data && leaf) { char str[512]; int toget; @@ -179,32 +136,30 @@ static Z_ElementData *nodetoelementdata(data1_handle dh, data1_node *n, switch (n->u.data.what) { - case DATA1I_num: - res->which = Z_ElementData_numeric; - res->u.numeric = (int *)odr_malloc(o, sizeof(int)); - *res->u.numeric = atoi(n->u.data.data); - *len += 4; - break; - case DATA1I_text: - toget = n->u.data.len; - if (p->u.tag.get_bytes > 0 && p->u.tag.get_bytes < toget) - toget = p->u.tag.get_bytes; - res->which = Z_ElementData_string; - res->u.string = (char *)odr_malloc(o, toget+1); - memcpy(res->u.string, n->u.data.data, toget); - res->u.string[toget] = '\0'; - *len += toget; - break; - case DATA1I_oid: - res->which = Z_ElementData_oid; - strncpy(str, n->u.data.data, n->u.data.len); - str[n->u.data.len] = '\0'; - res->u.oid = odr_getoidbystr(o, str); - *len += n->u.data.len; - break; - default: - logf(LOG_WARN, "Can't handle datatype."); - return 0; + case DATA1I_num: + res->which = Z_ElementData_numeric; + res->u.numeric = (int *)odr_malloc(o, sizeof(int)); + *res->u.numeric = atoi(n->u.data.data); + *len += 4; + break; + case DATA1I_text: + toget = n->u.data.len; + res->which = Z_ElementData_string; + res->u.string = (char *)odr_malloc(o, toget+1); + memcpy(res->u.string, n->u.data.data, toget); + res->u.string[toget] = '\0'; + *len += toget; + break; + case DATA1I_oid: + res->which = Z_ElementData_oid; + strncpy(str, n->u.data.data, n->u.data.len); + str[n->u.data.len] = '\0'; + res->u.oid = odr_getoidbystr(o, str); + *len += n->u.data.len; + break; + default: + yaz_log(LOG_WARN, "Can't handle datatype."); + return 0; } } else @@ -216,6 +171,21 @@ static Z_ElementData *nodetoelementdata(data1_handle dh, data1_node *n, return res; } +static int is_empty_data (data1_node *n) +{ + if (n && n->which == DATA1N_data && n->u.data.what == DATA1I_text) + { + int i = n->u.data.len; + + while (i > 0 && n->u.data.data[i-1] == '\n') + i--; + if (i == 0) + return 1; + } + return 0; +} + + static Z_TaggedElement *nodetotaggedelement(data1_handle dh, data1_node *n, int select, ODR o, int *len) @@ -223,14 +193,27 @@ static Z_TaggedElement *nodetotaggedelement(data1_handle dh, data1_node *n, Z_TaggedElement *res = (Z_TaggedElement *)odr_malloc(o, sizeof(*res)); data1_tag *tag = 0; data1_node *data; - int leaf; + int leaf = 0; if (n->which == DATA1N_tag) { if (n->u.tag.element) tag = n->u.tag.element->tag; data = n->child; - leaf = 0; + + /* skip empty data children */ + while (is_empty_data(data)) + data = data->next; + if (!data) + data = n->child; + else + { /* got one. see if this is the only non-empty one */ + data1_node *sub = data->next; + while (sub && is_empty_data(sub)) + sub = sub->next; + if (!sub) + leaf = 1; /* all empty. 'data' is the only child */ + } } /* * If we're a data element at this point, we need to insert a @@ -238,18 +221,21 @@ static Z_TaggedElement *nodetotaggedelement(data1_handle dh, data1_node *n, */ else if (n->which == DATA1N_data || n->which == DATA1N_variant) { - if (!(tag = data1_gettagbyname (dh, n->root->u.root.absyn->tagset, + if (n->root->u.root.absyn && + !(tag = data1_gettagbyname (dh, n->root->u.root.absyn->tagset, "wellKnown"))) { - logf(LOG_WARN, "Unable to locate tag for 'wellKnown'"); + yaz_log(LOG_WARN, "Unable to locate tag for 'wellKnown'"); return 0; } data = n; leaf = 1; + if (is_empty_data(data)) + return 0; } else { - logf(LOG_WARN, "Bad data."); + yaz_log(LOG_WARN, "Bad data."); return 0; } @@ -266,14 +252,14 @@ static Z_TaggedElement *nodetotaggedelement(data1_handle dh, data1_node *n, { char *tagstr; - if (tag) /* well-known tag */ - tagstr = tag->value.string; - else /* tag local to this file */ - tagstr = n->u.tag.tag; - + if (n->which == DATA1N_tag) + tagstr = n->u.tag.tag; /* tag at node */ + else if (tag) + tagstr = tag->value.string; /* no take from well-known */ + else + return 0; res->tagValue->which = Z_StringOrNumeric_string; - res->tagValue->u.string = (char *)odr_malloc(o, strlen(tagstr)+1); - strcpy(res->tagValue->u.string, tagstr); + res->tagValue->u.string = odr_strdup(o, tagstr); } res->tagOccurrence = 0; res->appliedVariant = 0; @@ -314,19 +300,23 @@ Z_GenericRecord *data1_nodetogr(data1_handle dh, data1_node *n, Z_GenericRecord *res = (Z_GenericRecord *)odr_malloc(o, sizeof(*res)); data1_node *c; int num_children = 0; - + + if (n->which == DATA1N_root) + n = data1_get_root_tag (dh, n); + for (c = n->child; c; c = c->next) num_children++; - res->elements = (Z_TaggedElement **)odr_malloc(o, sizeof(Z_TaggedElement *) * num_children); + res->elements = (Z_TaggedElement **) + odr_malloc(o, sizeof(Z_TaggedElement *) * num_children); res->num_elements = 0; for (c = n->child; c; c = c->next) { if (c->which == DATA1N_tag && select && !c->u.tag.node_selected) continue; - if (!(res->elements[res->num_elements++] = - nodetotaggedelement (dh, c, select, o, len))) - return 0; + if ((res->elements[res->num_elements] = + nodetotaggedelement (dh, c, select, o, len))) + res->num_elements++; } return res; }