recctrl/recgrs.c

   1 /*
   2  * Copyright (C) 1994-1996, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: recgrs.c,v $
   7  * Revision 1.4  1997-04-30 08:56:08  quinn
   8  * null
   9  *
  10  * Revision 1.2  1996/10/11  16:06:43  quinn
  11  * Revision 1.3  1997/02/24 10:41:50  adam
  12  * Cleanup of code and commented out the "end element-end-record" code.
  13  *
  14  * Revision 1.2  1996/10/11 16:06:43  quinn
  15  * Fixed arguments to nodetogr
  16  *
  17  * Revision 1.1  1996/10/11  10:57:25  adam
  18  * New module recctrl. Used to manage records (extract/retrieval).
  19  *
  20  * Revision 1.29  1996/10/08 10:30:21  quinn
  21  * Fixed type mismatch
  22  *
  23  * Revision 1.28  1996/10/07  16:06:40  quinn
  24  * Added SOIF support
  25  *
  26  * Revision 1.27  1996/06/11  10:54:12  quinn
  27  * Relevance work
  28  *
  29  * Revision 1.26  1996/06/06  12:08:45  quinn
  30  * Added showRecord function
  31  *
  32  * Revision 1.25  1996/06/04  14:18:53  quinn
  33  * Charmap work
  34  *
  35  * Revision 1.24  1996/06/04  13:27:54  quinn
  36  * More work on charmapping
  37  *
  38  * Revision 1.23  1996/06/04  10:19:01  adam
  39  * Minor changes - removed include of ctype.h.
  40  *
  41  * Revision 1.22  1996/06/03  10:15:27  quinn
  42  * Various character-mapping.
  43  *
  44  * Revision 1.21  1996/05/31  13:27:24  quinn
  45  * Character-conversion in phrases, too.
  46  *
  47  * Revision 1.19  1996/05/16  15:31:14  quinn
  48  * a7
  49  *
  50  * Revision 1.18  1996/05/09  07:28:56  quinn
  51  * Work towards phrases and multiple registers
  52  *
  53  * Revision 1.17  1996/05/01  13:46:37  adam
  54  * First work on multiple records in one file.
  55  * New option, -offset, to the "unread" command in the filter module.
  56  *
  57  * Revision 1.16  1996/01/17  14:57:54  adam
  58  * Prototype changed for reader functions in extract/retrieve. File
  59  *  is identified by 'void *' instead of 'int.
  60  *
  61  * Revision 1.15  1996/01/08  19:15:47  adam
  62  * New input filter that works!
  63  *
  64  * Revision 1.14  1995/12/15  12:36:11  adam
  65  * Retrieval calls data1_read_regx when subType is specified.
  66  *
  67  * Revision 1.13  1995/12/15  12:24:43  quinn
  68  * *** empty log message ***
  69  *
  70  * Revision 1.12  1995/12/15  12:20:28  quinn
  71  * *** empty log message ***
  72  *
  73  * Revision 1.11  1995/12/15  12:07:57  quinn
  74  * Changed extraction strategy.
  75  *
  76  * Revision 1.10  1995/12/14  11:10:48  quinn
  77  * Explain work
  78  *
  79  * Revision 1.9  1995/12/13  17:14:05  quinn
  80  * *** empty log message ***
  81  *
  82  * Revision 1.8  1995/12/13  15:33:18  quinn
  83  * *** empty log message ***
  84  *
  85  * Revision 1.7  1995/12/13  13:45:39  quinn
  86  * Changed data1 to use nmem.
  87  *
  88  * Revision 1.6  1995/12/04  14:22:30  adam
  89  * Extra arg to recType_byName.
  90  * Started work on new regular expression parsed input to
  91  * structured records.
  92  *
  93  * Revision 1.5  1995/11/28  14:18:37  quinn
  94  * Set output_format.
  95  *
  96  * Revision 1.4  1995/11/21  13:14:49  quinn
  97  * Fixed end-of-data-field problem (maybe).
  98  *
  99  * Revision 1.3  1995/11/15  19:13:09  adam
 100  * Work on record management.
 101  *
 102  */
 103
 104 #include <stdio.h>
 105 #include <assert.h>
 106 #include <sys/types.h>
 107 #include <unistd.h>
 108
 109 #include <log.h>
 110 #include <oid.h>
 111
 112 #include <recctrl.h>
 113 #include <charmap.h>
 114 #include "grsread.h"
 115
 116 #define GRS_MAX_WORD 512
 117
 118 static int seqno = 0;
 119
 120 static data1_node *read_grs_type (struct grs_read_info *p, const char *type)
 121 {
 122     static struct {
 123         char *type;
 124         data1_node *(*func)(struct grs_read_info *p);
 125     } tab[] = {
 126         { "sgml",  grs_read_sgml },
 127         { "regx",  grs_read_regx },
 128         { NULL, NULL }
 129     };
 130     const char *cp = strchr (type, '.');
 131     int i;
 132
 133     if (cp == NULL || cp == type)
 134     {
 135         cp = strlen(type) + type;
 136         *p->type = 0;
 137     }
 138     else
 139         strcpy (p->type, cp+1);
 140     for (i=0; tab[i].type; i++)
 141     {
 142         if (!memcmp (type, tab[i].type, cp-type))
 143             return (tab[i].func)(p);
 144     }
 145     return NULL;
 146 }
 147
 148 static void grs_init(void)
 149 {
 150 }
 151
 152 static void dumpkeys_word(data1_node *n, struct recExtractCtrl *p,
 153     data1_att *att)
 154 {
 155     char *b = n->u.data.data;
 156     int remain;
 157     char **map = 0;
 158
 159     remain = n->u.data.len - (b - n->u.data.data);
 160     if (remain > 0)
 161         map = (*p->map_chrs_input)(&b, remain);
 162
 163     while (map)
 164     {
 165         RecWord wrd;
 166         char buf[GRS_MAX_WORD+1];
 167         int i, remain;
 168
 169         /* Skip spaces */
 170         while (map && *map && **map == *CHR_SPACE)
 171         {
 172             remain = n->u.data.len - (b - n->u.data.data);
 173             if (remain > 0)
 174                 map = (*p->map_chrs_input)(&b, remain);
 175             else
 176                 map = 0;
 177         }
 178         if (!map)
 179             break;
 180         i = 0;
 181         while (map && *map && **map != *CHR_SPACE)
 182         {
 183             char *cp = *map;
 184
 185             while (i < GRS_MAX_WORD && *cp)
 186                 buf[i++] = *(cp++);
 187             remain = n->u.data.len - (b - n->u.data.data);
 188             if (remain > 0)
 189                 map = (*p->map_chrs_input)(&b, remain);
 190             else
 191                 map = 0;
 192         }
 193         if (!i)
 194             return;
 195         buf[i] = '\0';
 196         (*p->init)(&wrd);      /* set defaults */
 197         wrd.which = Word_String;
 198         wrd.seqno = seqno++;
 199         wrd.u.string = buf;
 200         wrd.attrSet = att->parent->ordinal;
 201         wrd.attrUse = att->locals->local;
 202         (*p->add)(&wrd);
 203     }
 204 }
 205
 206 static void dumpkeys_phrase(data1_node *n, struct recExtractCtrl *p,
 207     data1_att *att)
 208 {
 209     char *b = n->u.data.data;
 210     char buf[GRS_MAX_WORD+1], **map = 0;
 211     RecWord wrd;
 212     int i = 0, remain;
 213
 214     remain = n->u.data.len - (b - n->u.data.data);
 215     if (remain > 0)
 216         map = (*p->map_chrs_input)(&b, remain);
 217
 218     while (remain > 0 && i < GRS_MAX_WORD)
 219     {
 220         while (map && *map && **map == *CHR_SPACE)
 221         {
 222             remain = n->u.data.len - (b - n->u.data.data);
 223             if (remain > 0)
 224                 map = (*p->map_chrs_input)(&b, remain);
 225             else
 226                 map = 0;
 227         }
 228         if (!map)
 229             break;
 230
 231         if (i && i < GRS_MAX_WORD)
 232             buf[i++] = *CHR_SPACE;
 233         while (map && *map && **map != *CHR_SPACE)
 234         {
 235             char *cp = *map;
 236
 237             if (i >= GRS_MAX_WORD)
 238                 break;
 239             while (i < GRS_MAX_WORD && *cp)
 240                 buf[i++] = *(cp++);
 241             remain = n->u.data.len - (b - n->u.data.data);
 242             if (remain > 0)
 243                 map = (*p->map_chrs_input)(&b, remain);
 244             else
 245                 map = 0;
 246         }
 247     }
 248     if (!i)
 249         return;
 250     buf[i] = '\0';
 251     (*p->init)(&wrd);
 252     wrd.which = Word_Phrase;
 253     wrd.seqno = seqno++;
 254     wrd.u.string = buf;
 255     wrd.attrSet = att->parent->ordinal;
 256     wrd.attrUse = att->locals->local;
 257     (*p->add)(&wrd);
 258 }
 259
 260 static int dumpkeys(data1_node *n, struct recExtractCtrl *p, int level)
 261 {
 262     for (; n; n = n->next)
 263     {
 264         if (p->flagShowRecords) /* display element description to user */
 265         {
 266             if (n->which == DATA1N_root)
 267             {
 268                 printf("%*s", level * 4, "");
 269                 printf("Record type: '%s'\n", n->u.root.absyn->name);
 270             }
 271             else if (n->which == DATA1N_tag)
 272             {
 273                 data1_element *e;
 274
 275                 printf("%*s", level * 4, "");
 276                 if (!(e = n->u.tag.element))
 277                     printf("Local tag: '%s'\n", n->u.tag.tag);
 278                 else
 279                 {
 280                     printf("Elm: '%s' ", e->name);
 281                     if (e->tag)
 282                     {
 283                         data1_tag *t = e->tag;
 284
 285                         printf("TagNam: '%s' ", t->names->name);
 286                         printf("(");
 287                         if (t->tagset)
 288                             printf("%s[%d],", t->tagset->name, t->tagset->type);
 289                         else
 290                             printf("?,");
 291                         if (t->which == DATA1T_numeric)
 292                             printf("%d)", t->value.numeric);
 293                         else
 294                             printf("'%s')", t->value.string);
 295                     }
 296                     printf("\n");
 297                 }
 298             }
 299         }
 300
 301         if (n->child)
 302             if (dumpkeys(n->child, p, level + 1) < 0)
 303                 return -1;
 304
 305         if (n->which == DATA1N_data)
 306         {
 307             data1_node *par = get_parent_tag(n);
 308             data1_termlist *tlist = 0;
 309
 310             if (p->flagShowRecords)
 311             {
 312                 printf("%*s", level * 4, "");
 313                 printf("Data: ");
 314                 if (n->u.data.len > 20)
 315                     printf("'%.20s...'\n", n->u.data.data);
 316                 else if (n->u.data.len > 0)
 317                     printf("'%.*s'\n", n->u.data.len, n->u.data.data);
 318                 else
 319                     printf("NULL\n");
 320             }
 321
 322             assert(par);
 323
 324             /*
 325              * cycle up towards the root until we find a tag with an att..
 326              * this has the effect of indexing locally defined tags with
 327              * the attribute of their ancestor in the record.
 328              */
 329
 330             while (!par->u.tag.element)
 331                 if (!par->parent || !(par = get_parent_tag(par->parent)))
 332                     break;
 333             if (!par)
 334                 tlist = 0;
 335             else if (par->u.tag.element->termlists)
 336                 tlist = par->u.tag.element->termlists;
 337             else
 338                 continue;
 339
 340             for (; tlist; tlist = tlist->next)
 341             {
 342                 if (p->flagShowRecords)
 343                 {
 344                     printf("%*sIdx: [", (level + 1) * 4, "");
 345                     switch (tlist->structure)
 346                     {
 347                         case DATA1S_word: printf("w"); break;
 348                         case DATA1S_phrase: printf("p"); break;
 349                         default: printf("?"); break;
 350                     }
 351                     printf("] ");
 352                     printf("%s:%s [%d]\n", tlist->att->parent->name,
 353                         tlist->att->name, tlist->att->value);
 354                 }
 355                 else switch (tlist->structure)
 356                 {
 357                     case DATA1S_word:
 358                         dumpkeys_word(n, p, tlist->att); break;
 359                     case DATA1S_phrase:
 360                         dumpkeys_phrase(n, p, tlist->att); break;
 361                     default:
 362                         logf(LOG_FATAL, "Bad structure type in dumpkeys");
 363                         abort();
 364                 }
 365             }
 366         }
 367         if (p->flagShowRecords && n->which == DATA1N_root)
 368         {
 369             printf("%*s-------------\n\n", level * 4, "");
 370         }
 371     }
 372     return 0;
 373 }
 374
 375 static int grs_extract(struct recExtractCtrl *p)
 376 {
 377     data1_node *n;
 378     NMEM mem = nmem_create();
 379     struct grs_read_info gri;
 380     seqno = 0;
 381
 382     gri.readf = p->readf;
 383     gri.seekf = p->seekf;
 384     gri.endf = p->endf;
 385     gri.fh = p->fh;
 386     gri.offset = p->offset;
 387     gri.mem = mem;
 388
 389     n = read_grs_type (&gri, p->subType);
 390     if (!n)
 391         return -1;
 392     if (dumpkeys(n, p, 0) < 0)
 393     {
 394         data1_free_tree(n);
 395         return -2;
 396     }
 397     data1_free_tree(n);
 398     nmem_destroy(mem);
 399     return 0;
 400 }
 401
 402 /*
 403  * Return: -1: Nothing done. 0: Ok. >0: Bib-1 diagnostic.
 404  */
 405 static int process_comp(data1_node *n, Z_RecordComposition *c)
 406 {
 407     data1_esetname *eset;
 408     Z_Espec1 *espec = 0;
 409     Z_ElementSpec *p;
 410
 411     switch (c->which)
 412     {
 413         case Z_RecordComp_simple:
 414             if (c->u.simple->which != Z_ElementSetNames_generic)
 415                 return 26; /* only generic form supported. Fix this later */
 416             if (!(eset = data1_getesetbyname(n->u.root.absyn,
 417                 c->u.simple->u.generic)))
 418             {
 419                 logf(LOG_LOG, "Unknown esetname '%s'", c->u.simple->u.generic);
 420                 return 25; /* invalid esetname */
 421             }
 422             logf(LOG_DEBUG, "Esetname '%s' in simple compspec",
 423                 c->u.simple->u.generic);
 424             espec = eset->spec;
 425             break;
 426         case Z_RecordComp_complex:
 427             if (c->u.complex->generic)
 428             {
 429                 /* insert check for schema */
 430                 if ((p = c->u.complex->generic->elementSpec))
 431                     switch (p->which)
 432                     {
 433                         case Z_ElementSpec_elementSetName:
 434                             if (!(eset = data1_getesetbyname(n->u.root.absyn,
 435                                 p->u.elementSetName)))
 436                             {
 437                                 logf(LOG_LOG, "Unknown esetname '%s'",
 438                                     p->u.elementSetName);
 439                                 return 25; /* invalid esetname */
 440                             }
 441                             logf(LOG_DEBUG, "Esetname '%s' in complex compspec",
 442                                 p->u.elementSetName);
 443                             espec = eset->spec;
 444                             break;
 445                         case Z_ElementSpec_externalSpec:
 446                             if (p->u.externalSpec->which == Z_External_espec1)
 447                             {
 448                                 logf(LOG_DEBUG, "Got Espec-1");
 449                                 espec = p->u.externalSpec-> u.espec1;
 450                             }
 451                             else
 452                             {
 453                                 logf(LOG_LOG, "Unknown external espec.");
 454                                 return 25; /* bad. what is proper diagnostic? */
 455                             }
 456                             break;
 457                     }
 458             }
 459             else
 460                 return 26; /* fix */
 461     }
 462     if (espec)
 463         return data1_doespec1(n, espec);
 464     else
 465         return -1;
 466 }
 467
 468 static int grs_retrieve(struct recRetrieveCtrl *p)
 469 {
 470     data1_node *node = 0, *onode = 0;
 471     data1_node *new;
 472     data1_maptab *map;
 473     int res, selected = 0;
 474     NMEM mem = nmem_create();
 475     struct grs_read_info gri;
 476
 477     gri.readf = p->readf;
 478     gri.seekf = p->seekf;
 479     gri.endf = NULL;
 480     gri.fh = p->fh;
 481     gri.offset = 0;
 482     gri.mem = mem;
 483
 484     node = read_grs_type (&gri, p->subType);
 485 /* node = data1_read_record(p->readf, p->fh, mem); */
 486     if (!node)
 487     {
 488         p->diagnostic = 2;
 489         return 0;
 490     }
 491     if (p->score >= 0 && (new = data1_insert_taggeddata(node, node, "rank",
 492         mem)))
 493     {
 494         new->u.data.what = DATA1I_num;
 495         new->u.data.data = new->u.data.lbuf;
 496         sprintf(new->u.data.data, "%d", p->score);
 497         new->u.data.len = strlen(new->u.data.data);
 498     }
 499     if ((new = data1_insert_taggeddata(node, node, "localControlNumber", mem)))
 500     {
 501         new->u.data.what = DATA1I_text;
 502         new->u.data.data = new->u.data.lbuf;
 503         sprintf(new->u.data.data, "%d", p->localno);
 504         new->u.data.len = strlen(new->u.data.data);
 505     }
 506     if (p->input_format == VAL_GRS1 && node->u.root.absyn &&
 507         node->u.root.absyn->reference != VAL_NONE)
 508     {
 509         oident oe;
 510         Odr_oid *oid;
 511
 512         oe.proto = PROTO_Z3950;
 513         oe.oclass = CLASS_SCHEMA;
 514         oe.value = node->u.root.absyn->reference;
 515
 516         if ((oid = oid_getoidbyent(&oe)))
 517         {
 518             char tmp[128];
 519             char *p = tmp;
 520             int *ii;
 521
 522             for (ii = oid; *ii >= 0; ii++)
 523             {
 524                 if (p != tmp)
 525                     *(p++) = '.';
 526                 sprintf(p, "%d", *ii);
 527                 p += strlen(p);
 528             }
 529             *(p++) = '\0';
 530
 531             if ((new = data1_insert_taggeddata(node, node, "schemaIdentifier",
 532                 mem)))
 533             {
 534                 new->u.data.what = DATA1I_oid;
 535                 new->u.data.data = nmem_malloc(mem, p - tmp);
 536                 memcpy(new->u.data.data, tmp, p - tmp);
 537                 new->u.data.len = p - tmp;
 538             }
 539         }
 540     }
 541
 542     /*
 543      * Does the requested format match a known schema-mapping? (this reflects
 544      * the overlap of schema and formatting which is inherent in the MARC
 545      * family)
 546      * NOTE: This should look at the schema-specification in the compspec
 547      * as well.
 548      */
 549     for (map = node->u.root.absyn->maptabs; map; map = map->next)
 550         if (map->target_absyn_ref == p->input_format)
 551         {
 552             onode = node;
 553             if (!(node = data1_map_record(onode, map, mem)))
 554             {
 555                 p->diagnostic = 14;
 556                 return 0;
 557             }
 558
 559             break;
 560         }
 561
 562     if (p->comp && (res = process_comp(node, p->comp)) > 0)
 563     {
 564         p->diagnostic = res;
 565         if (onode)
 566             data1_free_tree(onode);
 567         data1_free_tree(node);
 568         nmem_destroy(mem);
 569         return 0;
 570     }
 571     else if (p->comp && !res)
 572         selected = 1;
 573
 574     switch (p->output_format = (p->input_format != VAL_NONE ?
 575         p->input_format : VAL_SUTRS))
 576     {
 577         data1_marctab *marctab;
 578         int dummy;
 579
 580         case VAL_GRS1:
 581             if (!(p->rec_buf = data1_nodetogr(node, selected, p->odr, &dummy)))
 582                 p->diagnostic = 2; /* this should be better specified */
 583             else
 584                 p->rec_len = -1;
 585             break;
 586         case VAL_EXPLAIN:
 587             if (!(p->rec_buf = data1_nodetoexplain(node, selected, p->odr)))
 588                 p->diagnostic = 2; /* this should be better specified */
 589             else
 590                 p->rec_len = -1;
 591             break;
 592         case VAL_SUMMARY:
 593             if (!(p->rec_buf = data1_nodetosummary(node, selected, p->odr)))
 594                 p->diagnostic = 2;
 595             else
 596                 p->rec_len = -1;
 597             break;
 598         case VAL_SUTRS:
 599             if (!(p->rec_buf = data1_nodetobuf(node, selected,
 600                 (int*)&p->rec_len)))
 601             {
 602                 p->diagnostic = 2;
 603                 break;
 604             }
 605             break;
 606         case VAL_SOIF:
 607             if (!(p->rec_buf = data1_nodetosoif(node, selected,
 608                 (int*)&p->rec_len)))
 609             {
 610                 p->diagnostic = 2;
 611                 break;
 612             }
 613             break;
 614         default:
 615             for (marctab = node->u.root.absyn->marc; marctab;
 616                 marctab = marctab->next)
 617                 if (marctab->reference == p->input_format)
 618                     break;
 619             if (!marctab)
 620             {
 621                 p->diagnostic = 227;
 622                 break;
 623             }
 624             if (!(p->rec_buf = data1_nodetomarc(marctab, node, selected,
 625                 (int*)&p->rec_len)))
 626             {
 627                 p->diagnostic = 2;
 628                 break;
 629             }
 630     }
 631     if (node)
 632         data1_free_tree(node);
 633     if (onode)
 634         data1_free_tree(onode);
 635     nmem_destroy(mem);
 636     return 0;
 637 }
 638
 639 static struct recType grs_type =
 640 {
 641     "grs",
 642     grs_init,
 643     grs_extract,
 644     grs_retrieve
 645 };
 646
 647 RecType recTypeGrs = &grs_type;