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