X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=retrieval%2Fd1_grs.c;h=873549ca7f18df43ad2f39b2d4822bfc74087239;hb=caa50534e057668bf2cded573d41c5b07034633b;hp=14503b4b5f88a94db769f81d752b7916360aeb4a;hpb=102fffd24eb36b4b8322b3f139166ce5f5a4b7d4;p=yaz-moved-to-github.git diff --git a/retrieval/d1_grs.c b/retrieval/d1_grs.c index 14503b4..873549c 100644 --- a/retrieval/d1_grs.c +++ b/retrieval/d1_grs.c @@ -1,67 +1,18 @@ /* - * Copyright (c) 1995-1998, 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.15 1999-03-31 11:18:25 adam - * Implemented odr_strdup. Added Reference ID to backend server API. - * - * Revision 1.14 1998/03/16 12:21:15 adam - * Fixed problem with tag names that weren't set to the right value - * when wildcards were used. - * - * 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.25 2002-08-23 14:27:18 adam Exp $ * */ #include #include -#include -#include - -#include +#include +#include +#include #define D1_VARIANTARRAY 20 /* fixed max length on sup'd variant-list. Lazy me */ @@ -124,8 +75,8 @@ static Z_Variant *make_variant(data1_node *n, int num, ODR o) 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; } } @@ -148,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; } @@ -163,6 +114,45 @@ static int traverse_triples(data1_node *n, int level, Z_ElementMetaData *m, return 0; } +/* + * Locate some data under this node. This routine should handle variants + * prettily. + */ +static char *get_data(data1_node *n, int *len) +{ + char *r; + data1_node *np = 0; + + while (n) + { + if (n->which == DATA1N_data) + { + int i; + *len = n->u.data.len; + + for (i = 0; i<*len; i++) + if (!d1_isspace(n->u.data.data[i])) + break; + while (*len && d1_isspace(n->u.data.data[*len - 1])) + (*len)--; + *len = *len - i; + if (*len > 0) + return n->u.data.data + i; + } + if (n->which == DATA1N_tag) + np = n->child; + n = n->next; + if (!n) + { + n = np; + np = 0; + } + } + r = ""; + *len = strlen(r); + return r; +} + static Z_ElementData *nodetoelementdata(data1_handle dh, data1_node *n, int select, int leaf, ODR o, int *len) @@ -174,43 +164,41 @@ 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; - data1_node *p; + char str[64], *cp; + int toget = n->u.data.len; - for (p = n->parent; p && p->which != DATA1N_tag; p = p->parent) - ; + cp = get_data (n, &toget); 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 (cp, toget); + *len += 4; + break; + case DATA1I_text: + res->which = Z_ElementData_string; + res->u.string = (char *)odr_malloc(o, toget+1); + if (toget) + memcpy(res->u.string, cp, toget); + res->u.string[toget] = '\0'; + *len += toget; + break; + case DATA1I_oid: + res->which = Z_ElementData_oid; + if (toget > 63) + toget = 63; + memcpy (str, cp, toget); + str[toget] = '\0'; + res->u.oid = odr_getoidbystr(o, str); + *len += oid_oidlen(res->u.oid) * sizeof(int); + break; + default: + yaz_log(LOG_WARN, "Can't handle datatype."); + return 0; } } else @@ -222,6 +210,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) @@ -229,14 +232,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 @@ -244,18 +260,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; } @@ -277,7 +296,7 @@ static Z_TaggedElement *nodetotaggedelement(data1_handle dh, data1_node *n, else if (tag) tagstr = tag->value.string; /* no take from well-known */ else - tagstr = "?"; /* no tag at all! */ + return 0; res->tagValue->which = Z_StringOrNumeric_string; res->tagValue->u.string = odr_strdup(o, tagstr); } @@ -320,19 +339,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; }