-/*
- * Copyright (C) 1994-1998, Index Data I/S
- * All rights reserved.
- * Sebastian Hammer, Adam Dickmeiss
- *
- * $Log: recgrs.c,v $
- * Revision 1.17 1998-02-10 12:03:06 adam
- * Implemented Sort.
- *
- * Revision 1.16 1998/01/29 13:38:17 adam
- * Fixed problem with mapping to record with unknown schema.
- *
- * Revision 1.15 1998/01/26 10:37:57 adam
- * Better diagnostics.
- *
- * Revision 1.14 1997/11/06 11:41:01 adam
- * Implemented "begin variant" for the sgml.regx filter.
- *
- * Revision 1.13 1997/10/31 12:35:44 adam
- * Added a few log statements.
- *
- * Revision 1.12 1997/10/29 12:02:22 adam
- * Using oid_ent_to_oid used instead of the non thread-safe oid_getoidbyent.
- *
- * Revision 1.11 1997/10/27 14:34:00 adam
- * Work on generic character mapping depending on "structure" field
- * in abstract syntax file.
- *
- * Revision 1.10 1997/09/18 08:59:21 adam
- * Extra generic handle for the character mapping routines.
- *
- * Revision 1.9 1997/09/17 12:19:21 adam
- * Zebra version corresponds to YAZ version 1.4.
- * Changed Zebra server so that it doesn't depend on global common_resource.
- *
- * Revision 1.8 1997/09/09 13:38:14 adam
- * Partial port to WIN95/NT.
- *
- * Revision 1.7 1997/09/05 15:30:10 adam
- * Changed prototype for chr_map_input - added const.
- * Added support for C++, headers uses extern "C" for public definitions.
- *
- * Revision 1.6 1997/09/04 13:54:40 adam
- * Added MARC filter - type grs.marc.<syntax> where syntax refers
- * to abstract syntax. New method tellf in retrieve/extract method.
- *
- * Revision 1.5 1997/07/15 16:29:03 adam
- * Initialized dummy variable to keep checker gcc happy.
- *
- * Revision 1.4 1997/04/30 08:56:08 quinn
- * null
- *
- * Revision 1.2 1996/10/11 16:06:43 quinn
- * Revision 1.3 1997/02/24 10:41:50 adam
- * Cleanup of code and commented out the "end element-end-record" code.
- *
- * Revision 1.2 1996/10/11 16:06:43 quinn
- * Fixed arguments to nodetogr
- *
- * Revision 1.1 1996/10/11 10:57:25 adam
- * New module recctrl. Used to manage records (extract/retrieval).
- *
- * Revision 1.29 1996/10/08 10:30:21 quinn
- * Fixed type mismatch
- *
- * Revision 1.28 1996/10/07 16:06:40 quinn
- * Added SOIF support
- *
- * Revision 1.27 1996/06/11 10:54:12 quinn
- * Relevance work
- *
- * Revision 1.26 1996/06/06 12:08:45 quinn
- * Added showRecord function
- *
- * Revision 1.25 1996/06/04 14:18:53 quinn
- * Charmap work
- *
- * Revision 1.24 1996/06/04 13:27:54 quinn
- * More work on charmapping
- *
- * Revision 1.23 1996/06/04 10:19:01 adam
- * Minor changes - removed include of ctype.h.
- *
- * Revision 1.22 1996/06/03 10:15:27 quinn
- * Various character-mapping.
- *
- * Revision 1.21 1996/05/31 13:27:24 quinn
- * Character-conversion in phrases, too.
- *
- * Revision 1.19 1996/05/16 15:31:14 quinn
- * a7
- *
- * Revision 1.18 1996/05/09 07:28:56 quinn
- * Work towards phrases and multiple registers
- *
- * Revision 1.17 1996/05/01 13:46:37 adam
- * First work on multiple records in one file.
- * New option, -offset, to the "unread" command in the filter module.
- *
- * Revision 1.16 1996/01/17 14:57:54 adam
- * Prototype changed for reader functions in extract/retrieve. File
- * is identified by 'void *' instead of 'int.
- *
- * Revision 1.15 1996/01/08 19:15:47 adam
- * New input filter that works!
- *
- * Revision 1.14 1995/12/15 12:36:11 adam
- * Retrieval calls data1_read_regx when subType is specified.
- *
- * Revision 1.13 1995/12/15 12:24:43 quinn
- * *** empty log message ***
- *
- * Revision 1.12 1995/12/15 12:20:28 quinn
- * *** empty log message ***
- *
- * Revision 1.11 1995/12/15 12:07:57 quinn
- * Changed extraction strategy.
- *
- * Revision 1.10 1995/12/14 11:10:48 quinn
- * Explain work
- *
- * Revision 1.9 1995/12/13 17:14:05 quinn
- * *** empty log message ***
- *
- * Revision 1.8 1995/12/13 15:33:18 quinn
- * *** empty log message ***
- *
- * Revision 1.7 1995/12/13 13:45:39 quinn
- * Changed data1 to use nmem.
- *
- * Revision 1.6 1995/12/04 14:22:30 adam
- * Extra arg to recType_byName.
- * Started work on new regular expression parsed input to
- * structured records.
- *
- * Revision 1.5 1995/11/28 14:18:37 quinn
- * Set output_format.
- *
- * Revision 1.4 1995/11/21 13:14:49 quinn
- * Fixed end-of-data-field problem (maybe).
- *
- * Revision 1.3 1995/11/15 19:13:09 adam
- * Work on record management.
- *
- */
+/* $Id: recgrs.c,v 1.59 2002-08-02 19:26:56 adam Exp $
+ Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
+ Index Data Aps
+
+This file is part of the Zebra server.
+
+Zebra is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with Zebra; see the file LICENSE.zebra. If not, write to the
+Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.
+*/
+
+
#include <stdio.h>
#include <assert.h>
#include <sys/types.h>
-#ifndef WINDOWS
+#ifndef WIN32
#include <unistd.h>
#endif
-#include <log.h>
-#include <oid.h>
+#include <yaz/log.h>
+#include <yaz/oid.h>
#include <recctrl.h>
#include "grsread.h"
#define GRS_MAX_WORD 512
-static int seqno = 0;
+struct grs_handler {
+ RecTypeGrs type;
+ void *clientData;
+ int initFlag;
+ struct grs_handler *next;
+};
+
+struct grs_handlers {
+ struct grs_handler *handlers;
+};
-static data1_node *read_grs_type (struct grs_read_info *p, const char *type)
+static int read_grs_type (struct grs_handlers *h,
+ struct grs_read_info *p, const char *type,
+ data1_node **root)
{
- static struct {
- char *type;
- data1_node *(*func)(struct grs_read_info *p);
- } tab[] = {
- { "sgml", grs_read_sgml },
- { "regx", grs_read_regx },
- { "marc", grs_read_marc },
- { NULL, NULL }
- };
+ struct grs_handler *gh = h->handlers;
const char *cp = strchr (type, '.');
- int i;
if (cp == NULL || cp == type)
{
}
else
strcpy (p->type, cp+1);
- for (i=0; tab[i].type; i++)
+ for (gh = h->handlers; gh; gh = gh->next)
{
- if (!memcmp (type, tab[i].type, cp-type))
- return (tab[i].func)(p);
+ if (!memcmp (type, gh->type->type, cp-type))
+ {
+ if (!gh->initFlag)
+ {
+ gh->initFlag = 1;
+ gh->clientData = (*gh->type->init)();
+ }
+ p->clientData = gh->clientData;
+ *root = (gh->type->read)(p);
+ gh->clientData = p->clientData;
+ return 0;
+ }
}
- return NULL;
+ return 1;
}
-static void grs_init(void)
+static void grs_add_handler (struct grs_handlers *h, RecTypeGrs t)
{
+ struct grs_handler *gh = (struct grs_handler *) xmalloc (sizeof(*gh));
+ gh->next = h->handlers;
+ h->handlers = gh;
+ gh->initFlag = 0;
+ gh->clientData = 0;
+ gh->type = t;
}
-static int dumpkeys(data1_node *n, struct recExtractCtrl *p, int level)
+static void *grs_init(RecType recType)
+{
+ struct grs_handlers *h = (struct grs_handlers *) xmalloc (sizeof(*h));
+ h->handlers = 0;
+
+ grs_add_handler (h, recTypeGrs_sgml);
+ grs_add_handler (h, recTypeGrs_regx);
+#if HAVE_TCL_H
+ grs_add_handler (h, recTypeGrs_tcl);
+#endif
+ grs_add_handler (h, recTypeGrs_marc);
+#if YAZ_HAVE_EXPAT
+ grs_add_handler (h, recTypeGrs_xml);
+#endif
+ return h;
+}
+
+static void grs_destroy(void *clientData)
+{
+ struct grs_handlers *h = (struct grs_handlers *) clientData;
+ struct grs_handler *gh = h->handlers, *gh_next;
+ while (gh)
+ {
+ gh_next = gh->next;
+ if (gh->initFlag)
+ (*gh->type->destroy)(gh->clientData);
+ xfree (gh);
+ gh = gh_next;
+ }
+ xfree (h);
+}
+
+/* use
+ 1 start element (tag)
+ 2 end element
+ 3 start attr (and attr-exact)
+ 4 end attr
+
+ 1016 cdata
+ 1015 attr data
+*/
+
+static void index_xpath (data1_node *n, struct recExtractCtrl *p,
+ int level, RecWord *wrd, int use)
+{
+ int i;
+ char tag_path_full[1024];
+ size_t flen = 0;
+ data1_node *nn;
+
+ switch (n->which)
+ {
+ case DATA1N_data:
+ wrd->reg_type = 'w';
+ wrd->string = n->u.data.data;
+ wrd->length = n->u.data.len;
+ wrd->attrSet = VAL_IDXPATH,
+ wrd->attrUse = use;
+ if (p->flagShowRecords)
+ {
+ printf("%*s data=", (level + 1) * 4, "");
+ for (i = 0; i<wrd->length && i < 8; i++)
+ fputc (wrd->string[i], stdout);
+ printf("\n");
+ }
+ else
+ {
+ (*p->tokenAdd)(wrd);
+ }
+ break;
+ case DATA1N_tag:
+ for (nn = n; nn; nn = nn->parent)
+ {
+ if (nn->which == DATA1N_tag)
+ {
+ size_t tlen = strlen(nn->u.tag.tag);
+ if (tlen + flen > (sizeof(tag_path_full)-2))
+ return;
+ memcpy (tag_path_full + flen, nn->u.tag.tag, tlen);
+ flen += tlen;
+ tag_path_full[flen++] = '/';
+ }
+ else if (nn->which == DATA1N_root)
+ break;
+ }
+ wrd->reg_type = '0';
+ wrd->string = tag_path_full;
+ wrd->length = flen;
+ wrd->attrSet = VAL_IDXPATH;
+ wrd->attrUse = use;
+ if (p->flagShowRecords)
+ {
+ printf("%*s tag=", (level + 1) * 4, "");
+ for (i = 0; i<wrd->length && i < 40; i++)
+ fputc (wrd->string[i], stdout);
+ if (i == 40)
+ printf (" ..");
+ printf("\n");
+ }
+ else
+ {
+ data1_xattr *xp;
+ (*p->tokenAdd)(wrd); /* index element pag (AKA tag path) */
+ if (use == 1)
+ {
+ for (xp = n->u.tag.attributes; xp; xp = xp->next)
+ {
+ char comb[512];
+ /* attribute (no value) */
+ wrd->reg_type = '0';
+ wrd->attrUse = 3;
+ wrd->string = xp->name;
+ wrd->length = strlen(xp->name);
+
+ wrd->seqno--;
+ (*p->tokenAdd)(wrd);
+
+ if (xp->value &&
+ strlen(xp->name) + strlen(xp->value) < sizeof(comb)-2)
+ {
+ /* attribute value exact */
+ strcpy (comb, xp->name);
+ strcat (comb, "=");
+ strcat (comb, xp->value);
+
+ wrd->attrUse = 3;
+ wrd->reg_type = '0';
+ wrd->string = comb;
+ wrd->length = strlen(comb);
+ wrd->seqno--;
+
+ (*p->tokenAdd)(wrd);
+ }
+ }
+ for (xp = n->u.tag.attributes; xp; xp = xp->next)
+ {
+ char attr_tag_path_full[1024];
+
+ sprintf (attr_tag_path_full, "@%s/%.*s",
+ xp->name, flen, tag_path_full);
+
+ wrd->reg_type = '0';
+ wrd->attrUse = 1;
+ wrd->string = attr_tag_path_full;
+ wrd->length = strlen(attr_tag_path_full);
+ (*p->tokenAdd)(wrd);
+
+ wrd->attrUse = 1015;
+ wrd->reg_type = 'w';
+ wrd->string = xp->value;
+ wrd->length = strlen(xp->value);
+
+ (*p->tokenAdd)(wrd);
+
+ wrd->reg_type = '0';
+ wrd->attrUse = 2;
+ wrd->string = attr_tag_path_full;
+ wrd->length = strlen(attr_tag_path_full);
+ (*p->tokenAdd)(wrd);
+ }
+ }
+ }
+ }
+}
+
+static void index_termlist (data1_node *par, data1_node *n,
+ struct recExtractCtrl *p, int level, RecWord *wrd)
+{
+ data1_termlist *tlist = 0;
+ data1_datatype dtype = DATA1K_string;
+ /*
+ * cycle up towards the root until we find a tag with an att..
+ * this has the effect of indexing locally defined tags with
+ * the attribute of their ancestor in the record.
+ */
+
+ while (!par->u.tag.element)
+ if (!par->parent || !(par=get_parent_tag(p->dh, par->parent)))
+ break;
+ if (!par || !(tlist = par->u.tag.element->termlists))
+ return;
+ if (par->u.tag.element->tag)
+ dtype = par->u.tag.element->tag->kind;
+
+ for (; tlist; tlist = tlist->next)
+ {
+ char xattr[512];
+ /* consider source */
+ wrd->string = 0;
+
+ if (!strcmp (tlist->source, "data") && n->which == DATA1N_data)
+ {
+ wrd->string = n->u.data.data;
+ wrd->length = n->u.data.len;
+ }
+ else if (!strcmp (tlist->source, "tag") && n->which == DATA1N_tag)
+ {
+ wrd->string = n->u.tag.tag;
+ wrd->length = strlen(n->u.tag.tag);
+ }
+ else if (sscanf (tlist->source, "attr(%511[^)])", xattr) == 1 &&
+ n->which == DATA1N_tag)
+ {
+ data1_xattr *p = n->u.tag.attributes;
+ while (p && strcmp (p->name, xattr))
+ p = p->next;
+ if (p)
+ {
+ wrd->string = p->value;
+ wrd->length = strlen(p->value);
+ }
+ }
+ if (wrd->string)
+ {
+ if (p->flagShowRecords)
+ {
+ int i;
+ printf("%*sIdx: [%s]", (level + 1) * 4, "",
+ tlist->structure);
+ printf("%s:%s [%d] %s",
+ tlist->att->parent->name,
+ tlist->att->name, tlist->att->value,
+ tlist->source);
+ printf (" data=\"");
+ for (i = 0; i<wrd->length && i < 8; i++)
+ fputc (wrd->string[i], stdout);
+ fputc ('"', stdout);
+ if (wrd->length > 8)
+ printf (" ...");
+ fputc ('\n', stdout);
+ }
+ else
+ {
+ wrd->reg_type = *tlist->structure;
+ wrd->attrSet = (int) (tlist->att->parent->reference);
+ wrd->attrUse = tlist->att->locals->local;
+ (*p->tokenAdd)(wrd);
+ }
+ }
+ }
+}
+
+static int dumpkeys(data1_node *n, struct recExtractCtrl *p, int level,
+ RecWord *wrd)
{
- RecWord wrd;
- (*p->init)(p, &wrd); /* set defaults */
for (; n; n = n->next)
{
if (p->flagShowRecords) /* display element description to user */
if (n->which == DATA1N_root)
{
printf("%*s", level * 4, "");
- printf("Record type: '%s'\n", n->u.root.absyn->name);
+ printf("Record type: '%s'\n", n->u.root.type);
}
else if (n->which == DATA1N_tag)
{
}
}
+ if (n->which == DATA1N_tag)
+ {
+ index_termlist (n, n, p, level, wrd);
+ /* index start tag */
+ if (!n->root->u.root.absyn)
+ index_xpath (n, p, level, wrd, 1);
+ }
+
if (n->child)
- if (dumpkeys(n->child, p, level + 1) < 0)
+ if (dumpkeys(n->child, p, level + 1, wrd) < 0)
return -1;
+
if (n->which == DATA1N_data)
{
data1_node *par = get_parent_tag(p->dh, n);
- data1_termlist *tlist = 0;
- data1_datatype dtype = DATA1K_string;
if (p->flagShowRecords)
{
printf("%*s", level * 4, "");
printf("Data: ");
- if (n->u.data.len > 20)
- printf("'%.20s...'\n", n->u.data.data);
+ if (n->u.data.len > 32)
+ printf("'%.24s ... %.6s'\n", n->u.data.data,
+ n->u.data.data + n->u.data.len-6);
else if (n->u.data.len > 0)
printf("'%.*s'\n", n->u.data.len, n->u.data.data);
else
printf("NULL\n");
}
- assert(par);
+ if (par)
+ index_termlist (par, n, p, level, wrd);
+ if (!n->root->u.root.absyn)
+ index_xpath (n, p, level, wrd, 1016);
- /*
- * cycle up towards the root until we find a tag with an att..
- * this has the effect of indexing locally defined tags with
- * the attribute of their ancestor in the record.
- */
+ }
- while (!par->u.tag.element)
- if (!par->parent || !(par=get_parent_tag(p->dh, par->parent)))
- break;
- if (!par || !(tlist = par->u.tag.element->termlists))
- continue;
- if (par->u.tag.element->tag)
- dtype = par->u.tag.element->tag->kind;
- for (; tlist; tlist = tlist->next)
- {
- if (p->flagShowRecords)
- {
- printf("%*sIdx: [%s]", (level + 1) * 4, "",
- tlist->structure);
- printf("%s:%s [%d]\n",
- tlist->att->parent->name,
- tlist->att->name, tlist->att->value);
- }
- else
- {
- wrd.reg_type = *tlist->structure;
- wrd.seqno = seqno;
- wrd.string = n->u.data.data;
- wrd.length = n->u.data.len;
- wrd.attrSet = tlist->att->parent->ordinal;
- wrd.attrUse = tlist->att->locals->local;
- (*p->add)(&wrd);
- seqno = wrd.seqno;
- }
- }
+ if (n->which == DATA1N_tag)
+ {
+ /* index end tag */
+ if (!n->root->u.root.absyn)
+ index_xpath (n, p, level, wrd, 2);
}
+
+
if (p->flagShowRecords && n->which == DATA1N_root)
{
printf("%*s-------------\n\n", level * 4, "");
return 0;
}
-static int grs_extract(struct recExtractCtrl *p)
+int grs_extract_tree(struct recExtractCtrl *p, data1_node *n)
+{
+ oident oe;
+ int oidtmp[OID_SIZE];
+ RecWord wrd;
+
+ oe.proto = PROTO_Z3950;
+ oe.oclass = CLASS_SCHEMA;
+ if (n->u.root.absyn)
+ {
+ oe.value = n->u.root.absyn->reference;
+
+ if ((oid_ent_to_oid (&oe, oidtmp)))
+ (*p->schemaAdd)(p, oidtmp);
+ }
+ (*p->init)(p, &wrd);
+
+ return dumpkeys(n, p, 0, &wrd);
+}
+
+static int grs_extract_sub(struct grs_handlers *h, struct recExtractCtrl *p,
+ NMEM mem)
{
data1_node *n;
- NMEM mem;
struct grs_read_info gri;
- seqno = 0;
+ oident oe;
+ int oidtmp[OID_SIZE];
+ RecWord wrd;
- mem = nmem_create ();
gri.readf = p->readf;
gri.seekf = p->seekf;
gri.tellf = p->tellf;
gri.mem = mem;
gri.dh = p->dh;
- n = read_grs_type (&gri, p->subType);
+ if (read_grs_type (h, &gri, p->subType, &n))
+ return RECCTRL_EXTRACT_ERROR;
if (!n)
- return -1;
- if (dumpkeys(n, p, 0) < 0)
+ return RECCTRL_EXTRACT_EOF;
+ oe.proto = PROTO_Z3950;
+ oe.oclass = CLASS_SCHEMA;
+#if 0
+ if (!n->u.root.absyn)
+ return RECCTRL_EXTRACT_ERROR;
+#endif
+ if (n->u.root.absyn)
+ {
+ oe.value = n->u.root.absyn->reference;
+ if ((oid_ent_to_oid (&oe, oidtmp)))
+ (*p->schemaAdd)(p, oidtmp);
+ }
+
+ /* ensure our data1 tree is UTF-8 */
+ data1_iconv (p->dh, mem, n, "UTF-8", data1_get_encoding(p->dh, n));
+
+#if 0
+ data1_pr_tree (p->dh, n, stdout);
+#endif
+
+ (*p->init)(p, &wrd);
+ if (dumpkeys(n, p, 0, &wrd) < 0)
{
data1_free_tree(p->dh, n);
- return -2;
+ return RECCTRL_EXTRACT_ERROR;
}
data1_free_tree(p->dh, n);
+ return RECCTRL_EXTRACT_OK;
+}
+
+static int grs_extract(void *clientData, struct recExtractCtrl *p)
+{
+ int ret;
+ NMEM mem = nmem_create ();
+ struct grs_handlers *h = (struct grs_handlers *) clientData;
+
+ ret = grs_extract_sub(h, p, mem);
nmem_destroy(mem);
- return 0;
+ return ret;
}
/*
switch (c->which)
{
- case Z_RecordComp_simple:
- if (c->u.simple->which != Z_ElementSetNames_generic)
- return 26; /* only generic form supported. Fix this later */
- if (!(eset = data1_getesetbyname(dh, n->u.root.absyn,
- c->u.simple->u.generic)))
- {
- logf(LOG_LOG, "Unknown esetname '%s'", c->u.simple->u.generic);
- return 25; /* invalid esetname */
- }
- logf(LOG_DEBUG, "Esetname '%s' in simple compspec",
- c->u.simple->u.generic);
- espec = eset->spec;
- break;
- case Z_RecordComp_complex:
- if (c->u.complex->generic)
+ case Z_RecordComp_simple:
+ if (c->u.simple->which != Z_ElementSetNames_generic)
+ return 26; /* only generic form supported. Fix this later */
+ if (!(eset = data1_getesetbyname(dh, n->u.root.absyn,
+ c->u.simple->u.generic)))
+ {
+ logf(LOG_LOG, "Unknown esetname '%s'", c->u.simple->u.generic);
+ return 25; /* invalid esetname */
+ }
+ logf(LOG_DEBUG, "Esetname '%s' in simple compspec",
+ c->u.simple->u.generic);
+ espec = eset->spec;
+ break;
+ case Z_RecordComp_complex:
+ if (c->u.complex->generic)
+ {
+ /* insert check for schema */
+ if ((p = c->u.complex->generic->elementSpec))
{
- /* insert check for schema */
- if ((p = c->u.complex->generic->elementSpec))
- switch (p->which)
+ switch (p->which)
+ {
+ case Z_ElementSpec_elementSetName:
+ if (!(eset =
+ data1_getesetbyname(dh, n->u.root.absyn,
+ p->u.elementSetName)))
{
- case Z_ElementSpec_elementSetName:
- if (!(eset =
- data1_getesetbyname(dh,
- n->u.root.absyn,
- p->u.elementSetName)))
- {
- logf(LOG_LOG, "Unknown esetname '%s'",
- p->u.elementSetName);
- return 25; /* invalid esetname */
- }
- logf(LOG_DEBUG, "Esetname '%s' in complex compspec",
- p->u.elementSetName);
- espec = eset->spec;
- break;
- case Z_ElementSpec_externalSpec:
- if (p->u.externalSpec->which == Z_External_espec1)
- {
- logf(LOG_DEBUG, "Got Espec-1");
- espec = p->u.externalSpec-> u.espec1;
- }
- else
- {
- logf(LOG_LOG, "Unknown external espec.");
- return 25; /* bad. what is proper diagnostic? */
- }
- break;
+ logf(LOG_LOG, "Unknown esetname '%s'",
+ p->u.elementSetName);
+ return 25; /* invalid esetname */
}
+ logf(LOG_DEBUG, "Esetname '%s' in complex compspec",
+ p->u.elementSetName);
+ espec = eset->spec;
+ break;
+ case Z_ElementSpec_externalSpec:
+ if (p->u.externalSpec->which == Z_External_espec1)
+ {
+ logf(LOG_DEBUG, "Got Espec-1");
+ espec = p->u.externalSpec-> u.espec1;
+ }
+ else
+ {
+ logf(LOG_LOG, "Unknown external espec.");
+ return 25; /* bad. what is proper diagnostic? */
+ }
+ break;
+ }
}
- else
- return 26; /* fix */
+ }
+ else
+ return 26; /* fix */
}
if (espec)
{
- logf (LOG_LOG, "Element: Espec-1 match");
+ logf (LOG_DEBUG, "Element: Espec-1 match");
return data1_doespec1(dh, n, espec);
}
else
}
}
-static int grs_retrieve(struct recRetrieveCtrl *p)
+static void add_idzebra_info (struct recRetrieveCtrl *p, data1_node *top,
+ NMEM mem)
{
- data1_node *node = 0, *onode = 0;
- data1_node *new;
+ const char *idzebra_ns[7];
+
+ idzebra_ns[0] = "xmlns:idzebra";
+ idzebra_ns[1] = "http://www.indexdata.dk/zebra/";
+ idzebra_ns[2] = 0;
+
+ data1_tag_add_attr (p->dh, mem, top, idzebra_ns);
+
+ data1_mk_tag_data_int (p->dh, top, "idzebra:size", p->recordSize,
+ mem);
+ if (p->score != -1)
+ data1_mk_tag_data_int (p->dh, top, "idzebra:score",
+ p->score, mem);
+
+ data1_mk_tag_data_int (p->dh, top, "idzebra:localnumber", p->localno,
+ mem);
+ if (p->fname)
+ data1_mk_tag_data_text(p->dh, top, "idzebra:filename",
+ p->fname, mem);
+}
+
+static int grs_retrieve(void *clientData, struct recRetrieveCtrl *p)
+{
+ data1_node *node = 0, *onode = 0, *top;
+ data1_node *dnew;
data1_maptab *map;
int res, selected = 0;
NMEM mem;
struct grs_read_info gri;
+ char *tagname;
+ struct grs_handlers *h = (struct grs_handlers *) clientData;
+ int requested_schema = VAL_NONE;
+ data1_marctab *marctab;
+ int dummy;
mem = nmem_create();
gri.readf = p->readf;
gri.dh = p->dh;
logf (LOG_DEBUG, "grs_retrieve");
- node = read_grs_type (&gri, p->subType);
+ if (read_grs_type (h, &gri, p->subType, &node))
+ {
+ p->diagnostic = 14;
+ nmem_destroy (mem);
+ return 0;
+ }
if (!node)
{
p->diagnostic = 14;
nmem_destroy (mem);
return 0;
}
- logf (LOG_DEBUG, "grs_retrieve: score");
- if (p->score >= 0 && (new =
- data1_insert_taggeddata(p->dh, node,
- node, "rank",
- mem)))
+ /* ensure our data1 tree is UTF-8 */
+ data1_iconv (p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
+
+#if 0
+ data1_pr_tree (p->dh, node, stdout);
+#endif
+ top = data1_get_root_tag (p->dh, node);
+
+ logf (LOG_DEBUG, "grs_retrieve: size");
+ if ((dnew = data1_mk_tag_data_wd(p->dh, top, "size", mem)))
{
- new->u.data.what = DATA1I_num;
- new->u.data.data = new->lbuf;
- sprintf(new->u.data.data, "%d", p->score);
- new->u.data.len = strlen(new->u.data.data);
+ dnew->u.data.what = DATA1I_text;
+ dnew->u.data.data = dnew->lbuf;
+ sprintf(dnew->u.data.data, "%d", p->recordSize);
+ dnew->u.data.len = strlen(dnew->u.data.data);
}
- logf (LOG_DEBUG, "grs_retrieve: localControlNumber");
- if ((new = data1_insert_taggeddata(p->dh, node, node,
- "localControlNumber", mem)))
+
+ tagname = res_get_def(p->res, "tagrank", "rank");
+ if (strcmp(tagname, "0") && p->score >= 0 &&
+ (dnew = data1_mk_tag_data_wd(p->dh, top, tagname, mem)))
{
- new->u.data.what = DATA1I_text;
- new->u.data.data = new->lbuf;
- sprintf(new->u.data.data, "%d", p->localno);
- new->u.data.len = strlen(new->u.data.data);
+ logf (LOG_DEBUG, "grs_retrieve: %s", tagname);
+ dnew->u.data.what = DATA1I_num;
+ dnew->u.data.data = dnew->lbuf;
+ sprintf(dnew->u.data.data, "%d", p->score);
+ dnew->u.data.len = strlen(dnew->u.data.data);
+ }
+
+ tagname = res_get_def(p->res, "tagsysno", "localControlNumber");
+ if (strcmp(tagname, "0") && p->localno > 0 &&
+ (dnew = data1_mk_tag_data_wd(p->dh, top, tagname, mem)))
+ {
+ logf (LOG_DEBUG, "grs_retrieve: %s", tagname);
+ dnew->u.data.what = DATA1I_text;
+ dnew->u.data.data = dnew->lbuf;
+
+ sprintf(dnew->u.data.data, "%d", p->localno);
+ dnew->u.data.len = strlen(dnew->u.data.data);
+ }
+#if 0
+ data1_pr_tree (p->dh, node, stdout);
+#endif
+ if (p->comp && p->comp->which == Z_RecordComp_complex &&
+ p->comp->u.complex->generic &&
+ p->comp->u.complex->generic->schema)
+ {
+ oident *oe = oid_getentbyoid (p->comp->u.complex->generic->schema);
+ if (oe)
+ requested_schema = oe->value;
+ }
+
+ /* If schema has been specified, map if possible, then check that
+ * we got the right one
+ */
+ if (requested_schema != VAL_NONE)
+ {
+ logf (LOG_DEBUG, "grs_retrieve: schema mapping");
+ for (map = node->u.root.absyn->maptabs; map; map = map->next)
+ {
+ if (map->target_absyn_ref == requested_schema)
+ {
+ onode = node;
+ if (!(node = data1_map_record(p->dh, onode, map, mem)))
+ {
+ p->diagnostic = 14;
+ nmem_destroy (mem);
+ return 0;
+ }
+ break;
+ }
+ }
+ if (node->u.root.absyn &&
+ requested_schema != node->u.root.absyn->reference)
+ {
+ p->diagnostic = 238;
+ nmem_destroy (mem);
+ return 0;
+ }
}
- logf (LOG_DEBUG, "grs_retrieve: schemaIdentifier");
- if (p->input_format == VAL_GRS1 && node->u.root.absyn &&
- node->u.root.absyn->reference != VAL_NONE)
+ /*
+ * Does the requested format match a known syntax-mapping? (this reflects
+ * the overlap of schema and formatting which is inherent in the MARC
+ * family)
+ */
+ yaz_log (LOG_DEBUG, "grs_retrieve: syntax mapping");
+ if (node->u.root.absyn)
+ for (map = node->u.root.absyn->maptabs; map; map = map->next)
+ {
+ if (map->target_absyn_ref == p->input_format)
+ {
+ onode = node;
+ if (!(node = data1_map_record(p->dh, onode, map, mem)))
+ {
+ p->diagnostic = 14;
+ nmem_destroy (mem);
+ return 0;
+ }
+ break;
+ }
+ }
+ yaz_log (LOG_DEBUG, "grs_retrieve: schemaIdentifier");
+ if (node->u.root.absyn &&
+ node->u.root.absyn->reference != VAL_NONE &&
+ p->input_format == VAL_GRS1)
{
oident oe;
Odr_oid *oid;
int oidtmp[OID_SIZE];
-
+
oe.proto = PROTO_Z3950;
oe.oclass = CLASS_SCHEMA;
oe.value = node->u.root.absyn->reference;
-
+
if ((oid = oid_ent_to_oid (&oe, oidtmp)))
{
char tmp[128];
data1_handle dh = p->dh;
char *p = tmp;
int *ii;
-
+
for (ii = oid; *ii >= 0; ii++)
{
if (p != tmp)
- *(p++) = '.';
+ *(p++) = '.';
sprintf(p, "%d", *ii);
p += strlen(p);
}
*(p++) = '\0';
-
- if ((new = data1_insert_taggeddata(dh, node, node,
- "schemaIdentifier", mem)))
+
+ if ((dnew = data1_mk_tag_data_wd(dh, node,
+ "schemaIdentifier", mem)))
{
- new->u.data.what = DATA1I_oid;
- new->u.data.data = nmem_malloc(mem, p - tmp);
- memcpy(new->u.data.data, tmp, p - tmp);
- new->u.data.len = p - tmp;
+ dnew->u.data.what = DATA1I_oid;
+ dnew->u.data.data = (char *) nmem_malloc(mem, p - tmp);
+ memcpy(dnew->u.data.data, tmp, p - tmp);
+ dnew->u.data.len = p - tmp;
}
}
}
- logf (LOG_DEBUG, "grs_retrieve: schema mapping");
- /*
- * Does the requested format match a known schema-mapping? (this reflects
- * the overlap of schema and formatting which is inherent in the MARC
- * family)
- * NOTE: This should look at the schema-specification in the compspec
- * as well.
- */
- for (map = node->u.root.absyn->maptabs; map; map = map->next)
- if (map->target_absyn_ref == p->input_format)
- {
- onode = node;
- if (!(node = data1_map_record(p->dh, onode, map, mem)))
- {
- p->diagnostic = 14;
- nmem_destroy (mem);
- return 0;
- }
- break;
- }
-
logf (LOG_DEBUG, "grs_retrieve: element spec");
if (p->comp && (res = process_comp(p->dh, node, p->comp)) > 0)
{
else if (p->comp && !res)
selected = 1;
+#if 0
+ data1_pr_tree (p->dh, node, stdout);
+#endif
logf (LOG_DEBUG, "grs_retrieve: transfer syntax mapping");
switch (p->output_format = (p->input_format != VAL_NONE ?
- p->input_format : VAL_SUTRS))
+ p->input_format : VAL_SUTRS))
{
- data1_marctab *marctab;
- int dummy;
-
- case VAL_GRS1:
- dummy = 0;
- if (!(p->rec_buf = data1_nodetogr(p->dh, node, selected,
- p->odr, &dummy)))
- p->diagnostic = 238; /* not available in requested syntax */
- else
- p->rec_len = -1;
- break;
- case VAL_EXPLAIN:
- if (!(p->rec_buf = data1_nodetoexplain(p->dh, node, selected,
- p->odr)))
- p->diagnostic = 238;
- else
- p->rec_len = -1;
- break;
- case VAL_SUMMARY:
- if (!(p->rec_buf = data1_nodetosummary(p->dh, node, selected,
- p->odr)))
- p->diagnostic = 238;
- else
- p->rec_len = -1;
- break;
- case VAL_SUTRS:
- if (!(p->rec_buf = data1_nodetobuf(p->dh, node, selected,
- (int*)&p->rec_len)))
- p->diagnostic = 238;
- break;
- case VAL_SOIF:
- if (!(p->rec_buf = data1_nodetosoif(p->dh, node, selected,
- (int*)&p->rec_len)))
- p->diagnostic = 238;
+ case VAL_TEXT_XML:
+ add_idzebra_info (p, top, mem);
+
+ if (p->encoding)
+ data1_iconv (p->dh, mem, node, p->encoding, "UTF-8");
+
+ if (!(p->rec_buf = data1_nodetoidsgml(p->dh, node, selected,
+ &p->rec_len)))
+ p->diagnostic = 238;
+ else
+ {
+ char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
+ memcpy (new_buf, p->rec_buf, p->rec_len);
+ p->rec_buf = new_buf;
+ }
+ break;
+ case VAL_GRS1:
+ dummy = 0;
+ if (!(p->rec_buf = data1_nodetogr(p->dh, node, selected,
+ p->odr, &dummy)))
+ p->diagnostic = 238; /* not available in requested syntax */
+ else
+ p->rec_len = (size_t) (-1);
+ break;
+ case VAL_EXPLAIN:
+ if (!(p->rec_buf = data1_nodetoexplain(p->dh, node, selected,
+ p->odr)))
+ p->diagnostic = 238;
+ else
+ p->rec_len = (size_t) (-1);
+ break;
+ case VAL_SUMMARY:
+ if (!(p->rec_buf = data1_nodetosummary(p->dh, node, selected,
+ p->odr)))
+ p->diagnostic = 238;
+ else
+ p->rec_len = (size_t) (-1);
+ break;
+ case VAL_SUTRS:
+ if (p->encoding)
+ data1_iconv (p->dh, mem, node, p->encoding, "UTF-8");
+ if (!(p->rec_buf = data1_nodetobuf(p->dh, node, selected,
+ &p->rec_len)))
+ p->diagnostic = 238;
+ else
+ {
+ char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
+ memcpy (new_buf, p->rec_buf, p->rec_len);
+ p->rec_buf = new_buf;
+ }
+ break;
+ case VAL_SOIF:
+ if (!(p->rec_buf = data1_nodetosoif(p->dh, node, selected,
+ &p->rec_len)))
+ p->diagnostic = 238;
+ else
+ {
+ char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
+ memcpy (new_buf, p->rec_buf, p->rec_len);
+ p->rec_buf = new_buf;
+ }
+ break;
+ default:
+ if (!node->u.root.absyn)
+ {
+ p->diagnostic = 238;
break;
- default:
- if (!node->u.root.absyn)
- {
- p->diagnostic = 238;
- break;
- }
- for (marctab = node->u.root.absyn->marc; marctab;
- marctab = marctab->next)
- if (marctab->reference == p->input_format)
- break;
- if (!marctab)
- {
- p->diagnostic = 238;
- break;
- }
- if (!(p->rec_buf = data1_nodetomarc(p->dh, marctab, node,
- selected,
- (int*)&p->rec_len)))
- {
- p->diagnostic = 238;
+ }
+ for (marctab = node->u.root.absyn->marc; marctab;
+ marctab = marctab->next)
+ if (marctab->reference == p->input_format)
break;
- }
+ if (!marctab)
+ {
+ p->diagnostic = 238;
+ break;
+ }
+ if (p->encoding)
+ data1_iconv (p->dh, mem, node, p->encoding, "UTF-8");
+ if (!(p->rec_buf = data1_nodetomarc(p->dh, marctab, node,
+ selected, &p->rec_len)))
+ p->diagnostic = 238;
+ else
+ {
+ char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
+ memcpy (new_buf, p->rec_buf, p->rec_len);
+ p->rec_buf = new_buf;
+ }
}
if (node)
data1_free_tree(p->dh, node);
{
"grs",
grs_init,
+ grs_destroy,
grs_extract,
grs_retrieve
};
projects / idzebra-moved-to-github.git / blobdiff