* Sebastian Hammer, Adam Dickmeiss
*
* $Log: recgrs.c,v $
- * Revision 1.9 1997-09-17 12:19:21 adam
+ * 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.
*
{
}
-static void dumpkeys_word(data1_node *n, struct recExtractCtrl *p,
- data1_att *att)
+static void dumpkeys_incomplete_field(data1_node *n, struct recExtractCtrl *p,
+ data1_att *att, int reg_type)
{
const char *b = n->u.data.data;
int remain;
remain = n->u.data.len - (b - n->u.data.data);
if (remain > 0)
- map = (*p->map_chrs_input)(&b, remain);
+ map = zebra_maps_input(p->zebra_maps, reg_type, &b, remain);
while (map)
{
{
remain = n->u.data.len - (b - n->u.data.data);
if (remain > 0)
- map = (*p->map_chrs_input)(&b, remain);
+ map = zebra_maps_input(p->zebra_maps, reg_type, &b, remain);
else
map = 0;
}
buf[i++] = *(cp++);
remain = n->u.data.len - (b - n->u.data.data);
if (remain > 0)
- map = (*p->map_chrs_input)(&b, remain);
+ map = zebra_maps_input(p->zebra_maps, reg_type, &b, remain);
else
map = 0;
}
return;
buf[i] = '\0';
(*p->init)(&wrd); /* set defaults */
- wrd.which = Word_String;
+ wrd.reg_type = reg_type;
wrd.seqno = seqno++;
- wrd.u.string = buf;
+ wrd.string = buf;
wrd.attrSet = att->parent->ordinal;
wrd.attrUse = att->locals->local;
(*p->add)(&wrd);
}
}
-static void dumpkeys_phrase(data1_node *n, struct recExtractCtrl *p,
- data1_att *att)
+static void dumpkeys_complete_field(data1_node *n, struct recExtractCtrl *p,
+ data1_att *att, int reg_type)
{
const char *b = n->u.data.data;
char buf[GRS_MAX_WORD+1];
remain = n->u.data.len - (b - n->u.data.data);
if (remain > 0)
- map = (*p->map_chrs_input)(&b, remain);
+ map = zebra_maps_input (p->zebra_maps, reg_type, &b, remain);
while (remain > 0 && i < GRS_MAX_WORD)
{
{
remain = n->u.data.len - (b - n->u.data.data);
if (remain > 0)
- map = (*p->map_chrs_input)(&b, remain);
+ map = zebra_maps_input(p->zebra_maps, reg_type, &b, remain);
else
map = 0;
}
buf[i++] = *(cp++);
remain = n->u.data.len - (b - n->u.data.data);
if (remain > 0)
- map = (*p->map_chrs_input)(&b, remain);
+ map = zebra_maps_input (p->zebra_maps, reg_type, &b, remain);
else
map = 0;
}
return;
buf[i] = '\0';
(*p->init)(&wrd);
- wrd.which = Word_Phrase;
+
+ wrd.reg_type = reg_type;
wrd.seqno = seqno++;
- wrd.u.string = buf;
+ wrd.string = buf;
wrd.attrSet = att->parent->ordinal;
wrd.attrUse = att->locals->local;
(*p->add)(&wrd);
{
data1_node *par = get_parent_tag(p->dh, n);
data1_termlist *tlist = 0;
+ data1_datatype dtype = DATA1K_string;
if (p->flagShowRecords)
{
*/
while (!par->u.tag.element)
- if (!par->parent || !(par = get_parent_tag(p->dh, par->parent)))
+ if (!par->parent || !(par=get_parent_tag(p->dh, par->parent)))
break;
- if (!par)
- tlist = 0;
- else if (par->u.tag.element->termlists)
- tlist = par->u.tag.element->termlists;
- else
+ 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: [", (level + 1) * 4, "");
- switch (tlist->structure)
- {
- case DATA1S_word: printf("w"); break;
- case DATA1S_phrase: printf("p"); break;
- default: printf("?"); break;
- }
- printf("] ");
- printf("%s:%s [%d]\n", tlist->att->parent->name,
- tlist->att->name, tlist->att->value);
- }
- else switch (tlist->structure)
- {
- case DATA1S_word:
- dumpkeys_word(n, p, tlist->att); break;
- case DATA1S_phrase:
- dumpkeys_phrase(n, p, tlist->att); break;
- default:
- logf(LOG_FATAL, "Bad structure type in dumpkeys");
- abort();
+ printf("%*sIdx: [%s]", (level + 1) * 4, "",
+ tlist->structure);
+ printf("%s:%s [%d]\n",
+ tlist->att->parent->name,
+ tlist->att->name, tlist->att->value);
}
+ else
+ if (zebra_maps_is_complete (p->zebra_maps,
+ *tlist->structure))
+ dumpkeys_complete_field(n, p, tlist->att,
+ *tlist->structure);
+ else
+ dumpkeys_incomplete_field(n, p, tlist->att,
+ *tlist->structure);
}
}
if (p->flagShowRecords && n->which == DATA1N_root)
static int grs_extract(struct recExtractCtrl *p)
{
data1_node *n;
- NMEM mem = nmem_create();
+ NMEM mem;
struct grs_read_info gri;
seqno = 0;
+ mem = nmem_create ();
gri.readf = p->readf;
gri.seekf = p->seekf;
gri.tellf = p->tellf;
data1_node *new;
data1_maptab *map;
int res, selected = 0;
- NMEM mem = nmem_create();
+ NMEM mem;
struct grs_read_info gri;
+ mem = nmem_create();
gri.readf = p->readf;
gri.seekf = p->seekf;
gri.tellf = p->tellf;
gri.mem = mem;
gri.dh = p->dh;
+ logf (LOG_DEBUG, "grs_retrieve");
node = read_grs_type (&gri, p->subType);
if (!node)
{
p->diagnostic = 2;
+ 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)))
{
new->u.data.what = DATA1I_num;
- new->u.data.data = new->u.data.lbuf;
+ new->u.data.data = new->lbuf;
sprintf(new->u.data.data, "%d", p->score);
new->u.data.len = strlen(new->u.data.data);
}
+ logf (LOG_DEBUG, "grs_retrieve: localControlNumber");
if ((new = data1_insert_taggeddata(p->dh, node, node,
"localControlNumber", mem)))
{
new->u.data.what = DATA1I_text;
- new->u.data.data = new->u.data.lbuf;
+ 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: schemaIdentifier");
if (p->input_format == VAL_GRS1 && node->u.root.absyn &&
node->u.root.absyn->reference != VAL_NONE)
{
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_getoidbyent(&oe)))
+ if ((oid = oid_ent_to_oid (&oe, oidtmp)))
{
char tmp[128];
data1_handle dh = p->dh;
}
}
+ 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
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)
{
p->diagnostic = res;
else if (p->comp && !res)
selected = 1;
+ logf (LOG_DEBUG, "grs_retrieve: transfer syntax mapping");
switch (p->output_format = (p->input_format != VAL_NONE ?
p->input_format : VAL_SUTRS))
{
projects / idzebra-moved-to-github.git / blobdiff