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