recctrl/recgrs.c

   1 /*
   2  * Copyright (C) 1994-2002, Index Data
   3  * All rights reserved.
   4  *
   5  * $Id: recgrs.c,v 1.57 2002-08-01 09:37:44 adam Exp $
   6  */
   7
   8 #include <stdio.h>
   9 #include <assert.h>
  10 #include <sys/types.h>
  11 #ifndef WIN32
  12 #include <unistd.h>
  13 #endif
  14
  15 #include <yaz/log.h>
  16 #include <yaz/oid.h>
  17
  18 #include <recctrl.h>
  19 #include "grsread.h"
  20
  21 #define GRS_MAX_WORD 512
  22
  23 struct grs_handler {
  24     RecTypeGrs type;
  25     void *clientData;
  26     int initFlag;
  27     struct grs_handler *next;
  28 };
  29
  30 struct grs_handlers {
  31     struct grs_handler *handlers;
  32 };
  33
  34 static int read_grs_type (struct grs_handlers *h,
  35                           struct grs_read_info *p, const char *type,
  36                           data1_node **root)
  37 {
  38     struct grs_handler *gh = h->handlers;
  39     const char *cp = strchr (type, '.');
  40
  41     if (cp == NULL || cp == type)
  42     {
  43         cp = strlen(type) + type;
  44         *p->type = 0;
  45     }
  46     else
  47         strcpy (p->type, cp+1);
  48     for (gh = h->handlers; gh; gh = gh->next)
  49     {
  50         if (!memcmp (type, gh->type->type, cp-type))
  51         {
  52             if (!gh->initFlag)
  53             {
  54                 gh->initFlag = 1;
  55                 gh->clientData = (*gh->type->init)();
  56             }
  57             p->clientData = gh->clientData;
  58             *root = (gh->type->read)(p);
  59             gh->clientData = p->clientData;
  60             return 0;
  61         }
  62     }
  63     return 1;
  64 }
  65
  66 static void grs_add_handler (struct grs_handlers *h, RecTypeGrs t)
  67 {
  68     struct grs_handler *gh = (struct grs_handler *) xmalloc (sizeof(*gh));
  69     gh->next = h->handlers;
  70     h->handlers = gh;
  71     gh->initFlag = 0;
  72     gh->clientData = 0;
  73     gh->type = t;
  74 }
  75
  76 static void *grs_init(RecType recType)
  77 {
  78     struct grs_handlers *h = (struct grs_handlers *) xmalloc (sizeof(*h));
  79     h->handlers = 0;
  80
  81     grs_add_handler (h, recTypeGrs_sgml);
  82     grs_add_handler (h, recTypeGrs_regx);
  83 #if HAVE_TCL_H
  84     grs_add_handler (h, recTypeGrs_tcl);
  85 #endif
  86     grs_add_handler (h, recTypeGrs_marc);
  87 #if YAZ_HAVE_EXPAT
  88     grs_add_handler (h, recTypeGrs_xml);
  89 #endif
  90     return h;
  91 }
  92
  93 static void grs_destroy(void *clientData)
  94 {
  95     struct grs_handlers *h = (struct grs_handlers *) clientData;
  96     struct grs_handler *gh = h->handlers, *gh_next;
  97     while (gh)
  98     {
  99         gh_next = gh->next;
 100         if (gh->initFlag)
 101             (*gh->type->destroy)(gh->clientData);
 102         xfree (gh);
 103         gh = gh_next;
 104     }
 105     xfree (h);
 106 }
 107
 108 /* use
 109      1   start element (tag)
 110      2   end element
 111      3   start attr (and attr-exact)
 112      4   end attr
 113
 114   1016   cdata
 115   1015   attr data
 116 */
 117
 118 static void index_xpath (data1_node *n, struct recExtractCtrl *p,
 119                          int level, RecWord *wrd, int use)
 120 {
 121     int i;
 122     char tag_path_full[1024];
 123     size_t flen = 0;
 124     data1_node *nn;
 125
 126     switch (n->which)
 127     {
 128     case DATA1N_data:
 129         wrd->reg_type = 'w';
 130         wrd->string = n->u.data.data;
 131         wrd->length = n->u.data.len;
 132         wrd->attrSet = VAL_IDXPATH,
 133         wrd->attrUse = use;
 134         if (p->flagShowRecords)
 135         {
 136             printf("%*s data=", (level + 1) * 4, "");
 137             for (i = 0; i<wrd->length && i < 8; i++)
 138                 fputc (wrd->string[i], stdout);
 139             printf("\n");
 140         }
 141         else
 142         {
 143             (*p->tokenAdd)(wrd);
 144         }
 145         break;
 146     case DATA1N_tag:
 147         for (nn = n; nn; nn = nn->parent)
 148         {
 149             if (nn->which == DATA1N_tag)
 150             {
 151                 size_t tlen = strlen(nn->u.tag.tag);
 152                 if (tlen + flen > (sizeof(tag_path_full)-2))
 153                     return;
 154                 memcpy (tag_path_full + flen, nn->u.tag.tag, tlen);
 155                 flen += tlen;
 156                 tag_path_full[flen++] = '/';
 157             }
 158             else if (nn->which == DATA1N_root)
 159                 break;
 160         }
 161         wrd->reg_type = '0';
 162         wrd->string = tag_path_full;
 163         wrd->length = flen;
 164         wrd->attrSet = VAL_IDXPATH;
 165         wrd->attrUse = use;
 166         if (p->flagShowRecords)
 167         {
 168             printf("%*s tag=", (level + 1) * 4, "");
 169             for (i = 0; i<wrd->length && i < 40; i++)
 170                 fputc (wrd->string[i], stdout);
 171             if (i == 40)
 172                 printf (" ..");
 173             printf("\n");
 174         }
 175         else
 176         {
 177             data1_xattr *xp;
 178             (*p->tokenAdd)(wrd);
 179
 180 #if 0
 181             for (xp = n->u.tag.attributes; xp; xp = xp->next)
 182             {
 183                 if (use == 1)
 184                 {   /* attribute  (no value) */
 185                     wrd->reg_type = '0';
 186                     wrd->attrUse = 3;
 187                     wrd->string = xp->name;
 188                     wrd->length = strlen(xp->name);
 189
 190                     wrd->seqno--;
 191                     (*p->tokenAdd)(wrd);
 192                 }
 193             }
 194 #else
 195             for (xp = n->u.tag.attributes; xp; xp = xp->next)
 196             {
 197                 char comb[512];
 198
 199                 if (use == 1)
 200                 {   /* attribute start */
 201                     wrd->reg_type = '0';
 202                     wrd->attrUse = 3;
 203                     wrd->string = xp->name;
 204                     wrd->length = strlen(xp->name);
 205
 206                     wrd->seqno--;
 207                     (*p->tokenAdd)(wrd);
 208                 }
 209
 210                 if (use == 1 && xp->value &&
 211                     strlen(xp->name) + strlen(xp->value) < sizeof(comb)-2)
 212                 {
 213                     /* attribute value exact */
 214                     strcpy (comb, xp->name);
 215                     strcat (comb, "=");
 216                     strcat (comb, xp->value);
 217
 218                     wrd->attrUse = 3;
 219                     wrd->reg_type = '0';
 220                     wrd->string = comb;
 221                     wrd->length = strlen(comb);
 222                     wrd->seqno--;
 223
 224                     (*p->tokenAdd)(wrd);
 225
 226                     /* attribute value phrase */
 227
 228                     wrd->attrUse = 1015;
 229                     wrd->reg_type = 'w';
 230                     wrd->string = xp->value;
 231                     wrd->length = strlen(xp->value);
 232
 233                     (*p->tokenAdd)(wrd);
 234                 }
 235                 if (use == 2)
 236                 {
 237                     wrd->reg_type = '0';
 238                     wrd->attrUse = 4;
 239                     wrd->string = xp->name;
 240                     wrd->length = strlen(xp->name);
 241
 242                     (*p->tokenAdd)(wrd);
 243                 }
 244             }
 245 #endif
 246         }
 247         break;
 248     }
 249 }
 250
 251 static void index_termlist (data1_node *par, data1_node *n,
 252                             struct recExtractCtrl *p, int level, RecWord *wrd)
 253 {
 254     data1_termlist *tlist = 0;
 255     data1_datatype dtype = DATA1K_string;
 256     /*
 257      * cycle up towards the root until we find a tag with an att..
 258      * this has the effect of indexing locally defined tags with
 259      * the attribute of their ancestor in the record.
 260      */
 261
 262     while (!par->u.tag.element)
 263         if (!par->parent || !(par=get_parent_tag(p->dh, par->parent)))
 264             break;
 265     if (!par || !(tlist = par->u.tag.element->termlists))
 266         return;
 267     if (par->u.tag.element->tag)
 268         dtype = par->u.tag.element->tag->kind;
 269
 270     for (; tlist; tlist = tlist->next)
 271     {
 272         char xattr[512];
 273         /* consider source */
 274         wrd->string = 0;
 275
 276         if (!strcmp (tlist->source, "data") && n->which == DATA1N_data)
 277         {
 278             wrd->string = n->u.data.data;
 279             wrd->length = n->u.data.len;
 280         }
 281         else if (!strcmp (tlist->source, "tag") && n->which == DATA1N_tag)
 282         {
 283             wrd->string = n->u.tag.tag;
 284             wrd->length = strlen(n->u.tag.tag);
 285         }
 286         else if (sscanf (tlist->source, "attr(%511[^)])", xattr) == 1 &&
 287             n->which == DATA1N_tag)
 288         {
 289             data1_xattr *p = n->u.tag.attributes;
 290             while (p && strcmp (p->name, xattr))
 291                 p = p->next;
 292             if (p)
 293             {
 294                 wrd->string = p->value;
 295                 wrd->length = strlen(p->value);
 296             }
 297         }
 298         if (wrd->string)
 299         {
 300             if (p->flagShowRecords)
 301             {
 302                 int i;
 303                 printf("%*sIdx: [%s]", (level + 1) * 4, "",
 304                        tlist->structure);
 305                 printf("%s:%s [%d] %s",
 306                        tlist->att->parent->name,
 307                        tlist->att->name, tlist->att->value,
 308                        tlist->source);
 309                 printf (" data=\"");
 310                 for (i = 0; i<wrd->length && i < 8; i++)
 311                     fputc (wrd->string[i], stdout);
 312                 fputc ('"', stdout);
 313                 if (wrd->length > 8)
 314                     printf (" ...");
 315                 fputc ('\n', stdout);
 316             }
 317             else
 318             {
 319                 wrd->reg_type = *tlist->structure;
 320                 wrd->attrSet = (int) (tlist->att->parent->reference);
 321                 wrd->attrUse = tlist->att->locals->local;
 322                 (*p->tokenAdd)(wrd);
 323             }
 324         }
 325     }
 326 }
 327
 328 static int dumpkeys(data1_node *n, struct recExtractCtrl *p, int level,
 329                     RecWord *wrd)
 330 {
 331     for (; n; n = n->next)
 332     {
 333         if (p->flagShowRecords) /* display element description to user */
 334         {
 335             if (n->which == DATA1N_root)
 336             {
 337                 printf("%*s", level * 4, "");
 338                 printf("Record type: '%s'\n", n->u.root.type);
 339             }
 340             else if (n->which == DATA1N_tag)
 341             {
 342                 data1_element *e;
 343
 344                 printf("%*s", level * 4, "");
 345                 if (!(e = n->u.tag.element))
 346                     printf("Local tag: '%s'\n", n->u.tag.tag);
 347                 else
 348                 {
 349                     printf("Elm: '%s' ", e->name);
 350                     if (e->tag)
 351                     {
 352                         data1_tag *t = e->tag;
 353
 354                         printf("TagNam: '%s' ", t->names->name);
 355                         printf("(");
 356                         if (t->tagset)
 357                             printf("%s[%d],", t->tagset->name, t->tagset->type);
 358                         else
 359                             printf("?,");
 360                         if (t->which == DATA1T_numeric)
 361                             printf("%d)", t->value.numeric);
 362                         else
 363                             printf("'%s')", t->value.string);
 364                     }
 365                     printf("\n");
 366                 }
 367             }
 368         }
 369
 370         if (n->which == DATA1N_tag)
 371         {
 372             index_termlist (n, n, p, level, wrd);
 373             /* index start tag */
 374             if (!n->root->u.root.absyn)
 375                 index_xpath (n, p, level, wrd, 1);
 376         }
 377
 378         if (n->child)
 379             if (dumpkeys(n->child, p, level + 1, wrd) < 0)
 380                 return -1;
 381
 382
 383         if (n->which == DATA1N_data)
 384         {
 385             data1_node *par = get_parent_tag(p->dh, n);
 386
 387             if (p->flagShowRecords)
 388             {
 389                 printf("%*s", level * 4, "");
 390                 printf("Data: ");
 391                 if (n->u.data.len > 32)
 392                     printf("'%.24s ... %.6s'\n", n->u.data.data,
 393                            n->u.data.data + n->u.data.len-6);
 394                 else if (n->u.data.len > 0)
 395                     printf("'%.*s'\n", n->u.data.len, n->u.data.data);
 396                 else
 397                     printf("NULL\n");
 398             }
 399
 400             if (par)
 401                 index_termlist (par, n, p, level, wrd);
 402             if (!n->root->u.root.absyn)
 403                 index_xpath (n, p, level, wrd, 1016);
 404
 405         }
 406
 407         if (n->which == DATA1N_tag)
 408         {
 409             /* index end tag */
 410             if (!n->root->u.root.absyn)
 411                 index_xpath (n, p, level, wrd, 2);
 412         }
 413
 414
 415         if (p->flagShowRecords && n->which == DATA1N_root)
 416         {
 417             printf("%*s-------------\n\n", level * 4, "");
 418         }
 419     }
 420     return 0;
 421 }
 422
 423 int grs_extract_tree(struct recExtractCtrl *p, data1_node *n)
 424 {
 425     oident oe;
 426     int oidtmp[OID_SIZE];
 427     RecWord wrd;
 428
 429     oe.proto = PROTO_Z3950;
 430     oe.oclass = CLASS_SCHEMA;
 431     if (n->u.root.absyn)
 432     {
 433         oe.value = n->u.root.absyn->reference;
 434
 435         if ((oid_ent_to_oid (&oe, oidtmp)))
 436             (*p->schemaAdd)(p, oidtmp);
 437     }
 438     (*p->init)(p, &wrd);
 439
 440     return dumpkeys(n, p, 0, &wrd);
 441 }
 442
 443 static int grs_extract_sub(struct grs_handlers *h, struct recExtractCtrl *p,
 444                            NMEM mem)
 445 {
 446     data1_node *n;
 447     struct grs_read_info gri;
 448     oident oe;
 449     int oidtmp[OID_SIZE];
 450     RecWord wrd;
 451
 452     gri.readf = p->readf;
 453     gri.seekf = p->seekf;
 454     gri.tellf = p->tellf;
 455     gri.endf = p->endf;
 456     gri.fh = p->fh;
 457     gri.offset = p->offset;
 458     gri.mem = mem;
 459     gri.dh = p->dh;
 460
 461     if (read_grs_type (h, &gri, p->subType, &n))
 462         return RECCTRL_EXTRACT_ERROR;
 463     if (!n)
 464         return RECCTRL_EXTRACT_EOF;
 465     oe.proto = PROTO_Z3950;
 466     oe.oclass = CLASS_SCHEMA;
 467 #if 0
 468     if (!n->u.root.absyn)
 469         return RECCTRL_EXTRACT_ERROR;
 470 #endif
 471     if (n->u.root.absyn)
 472     {
 473         oe.value = n->u.root.absyn->reference;
 474         if ((oid_ent_to_oid (&oe, oidtmp)))
 475             (*p->schemaAdd)(p, oidtmp);
 476     }
 477
 478     /* ensure our data1 tree is UTF-8 */
 479     data1_iconv (p->dh, mem, n, "UTF-8", data1_get_encoding(p->dh, n));
 480
 481 #if 0
 482     data1_pr_tree (p->dh, n, stdout);
 483 #endif
 484
 485     (*p->init)(p, &wrd);
 486     if (dumpkeys(n, p, 0, &wrd) < 0)
 487     {
 488         data1_free_tree(p->dh, n);
 489         return RECCTRL_EXTRACT_ERROR;
 490     }
 491     data1_free_tree(p->dh, n);
 492     return RECCTRL_EXTRACT_OK;
 493 }
 494
 495 static int grs_extract(void *clientData, struct recExtractCtrl *p)
 496 {
 497     int ret;
 498     NMEM mem = nmem_create ();
 499     struct grs_handlers *h = (struct grs_handlers *) clientData;
 500
 501     ret = grs_extract_sub(h, p, mem);
 502     nmem_destroy(mem);
 503     return ret;
 504 }
 505
 506 /*
 507  * Return: -1: Nothing done. 0: Ok. >0: Bib-1 diagnostic.
 508  */
 509 static int process_comp(data1_handle dh, data1_node *n, Z_RecordComposition *c)
 510 {
 511     data1_esetname *eset;
 512     Z_Espec1 *espec = 0;
 513     Z_ElementSpec *p;
 514
 515     switch (c->which)
 516     {
 517     case Z_RecordComp_simple:
 518         if (c->u.simple->which != Z_ElementSetNames_generic)
 519             return 26; /* only generic form supported. Fix this later */
 520         if (!(eset = data1_getesetbyname(dh, n->u.root.absyn,
 521                                          c->u.simple->u.generic)))
 522         {
 523             logf(LOG_LOG, "Unknown esetname '%s'", c->u.simple->u.generic);
 524             return 25; /* invalid esetname */
 525         }
 526         logf(LOG_DEBUG, "Esetname '%s' in simple compspec",
 527              c->u.simple->u.generic);
 528         espec = eset->spec;
 529         break;
 530     case Z_RecordComp_complex:
 531         if (c->u.complex->generic)
 532         {
 533             /* insert check for schema */
 534             if ((p = c->u.complex->generic->elementSpec))
 535             {
 536                 switch (p->which)
 537                 {
 538                 case Z_ElementSpec_elementSetName:
 539                     if (!(eset =
 540                           data1_getesetbyname(dh, n->u.root.absyn,
 541                                               p->u.elementSetName)))
 542                     {
 543                         logf(LOG_LOG, "Unknown esetname '%s'",
 544                              p->u.elementSetName);
 545                         return 25; /* invalid esetname */
 546                     }
 547                     logf(LOG_DEBUG, "Esetname '%s' in complex compspec",
 548                          p->u.elementSetName);
 549                     espec = eset->spec;
 550                     break;
 551                 case Z_ElementSpec_externalSpec:
 552                     if (p->u.externalSpec->which == Z_External_espec1)
 553                     {
 554                         logf(LOG_DEBUG, "Got Espec-1");
 555                         espec = p->u.externalSpec-> u.espec1;
 556                     }
 557                     else
 558                     {
 559                         logf(LOG_LOG, "Unknown external espec.");
 560                         return 25; /* bad. what is proper diagnostic? */
 561                     }
 562                     break;
 563                 }
 564             }
 565         }
 566         else
 567             return 26; /* fix */
 568     }
 569     if (espec)
 570     {
 571         logf (LOG_DEBUG, "Element: Espec-1 match");
 572         return data1_doespec1(dh, n, espec);
 573     }
 574     else
 575     {
 576         logf (LOG_DEBUG, "Element: all match");
 577         return -1;
 578     }
 579 }
 580
 581 static void add_idzebra_info (struct recRetrieveCtrl *p, data1_node *top,
 582                               NMEM mem)
 583 {
 584     const char *idzebra_ns[7];
 585
 586     idzebra_ns[0] = "xmlns:idzebra";
 587     idzebra_ns[1] = "http://www.indexdata.dk/zebra/";
 588     idzebra_ns[2] = 0;
 589
 590     data1_tag_add_attr (p->dh, mem, top, idzebra_ns);
 591
 592     data1_mk_tag_data_int (p->dh, top, "idzebra:size", p->recordSize,
 593                            mem);
 594     if (p->score != -1)
 595         data1_mk_tag_data_int (p->dh, top, "idzebra:score",
 596                                p->score, mem);
 597
 598     data1_mk_tag_data_int (p->dh, top, "idzebra:localnumber", p->localno,
 599                            mem);
 600     if (p->fname)
 601         data1_mk_tag_data_text(p->dh, top, "idzebra:filename",
 602                                p->fname, mem);
 603 }
 604
 605 static int grs_retrieve(void *clientData, struct recRetrieveCtrl *p)
 606 {
 607     data1_node *node = 0, *onode = 0, *top;
 608     data1_node *dnew;
 609     data1_maptab *map;
 610     int res, selected = 0;
 611     NMEM mem;
 612     struct grs_read_info gri;
 613     char *tagname;
 614     struct grs_handlers *h = (struct grs_handlers *) clientData;
 615     int requested_schema = VAL_NONE;
 616     data1_marctab *marctab;
 617     int dummy;
 618
 619     mem = nmem_create();
 620     gri.readf = p->readf;
 621     gri.seekf = p->seekf;
 622     gri.tellf = p->tellf;
 623     gri.endf = NULL;
 624     gri.fh = p->fh;
 625     gri.offset = 0;
 626     gri.mem = mem;
 627     gri.dh = p->dh;
 628
 629     logf (LOG_DEBUG, "grs_retrieve");
 630     if (read_grs_type (h, &gri, p->subType, &node))
 631     {
 632         p->diagnostic = 14;
 633         nmem_destroy (mem);
 634         return 0;
 635     }
 636     if (!node)
 637     {
 638         p->diagnostic = 14;
 639         nmem_destroy (mem);
 640         return 0;
 641     }
 642     /* ensure our data1 tree is UTF-8 */
 643     data1_iconv (p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
 644
 645 #if 0
 646     data1_pr_tree (p->dh, node, stdout);
 647 #endif
 648     top = data1_get_root_tag (p->dh, node);
 649
 650     logf (LOG_DEBUG, "grs_retrieve: size");
 651     if ((dnew = data1_mk_tag_data_wd(p->dh, top, "size", mem)))
 652     {
 653         dnew->u.data.what = DATA1I_text;
 654         dnew->u.data.data = dnew->lbuf;
 655         sprintf(dnew->u.data.data, "%d", p->recordSize);
 656         dnew->u.data.len = strlen(dnew->u.data.data);
 657     }
 658
 659     tagname = res_get_def(p->res, "tagrank", "rank");
 660     if (strcmp(tagname, "0") && p->score >= 0 &&
 661         (dnew = data1_mk_tag_data_wd(p->dh, top, tagname, mem)))
 662     {
 663         logf (LOG_DEBUG, "grs_retrieve: %s", tagname);
 664         dnew->u.data.what = DATA1I_num;
 665         dnew->u.data.data = dnew->lbuf;
 666         sprintf(dnew->u.data.data, "%d", p->score);
 667         dnew->u.data.len = strlen(dnew->u.data.data);
 668     }
 669
 670     tagname = res_get_def(p->res, "tagsysno", "localControlNumber");
 671     if (strcmp(tagname, "0") && p->localno > 0 &&
 672          (dnew = data1_mk_tag_data_wd(p->dh, top, tagname, mem)))
 673     {
 674         logf (LOG_DEBUG, "grs_retrieve: %s", tagname);
 675         dnew->u.data.what = DATA1I_text;
 676         dnew->u.data.data = dnew->lbuf;
 677
 678         sprintf(dnew->u.data.data, "%d", p->localno);
 679         dnew->u.data.len = strlen(dnew->u.data.data);
 680     }
 681 #if 0
 682     data1_pr_tree (p->dh, node, stdout);
 683 #endif
 684     if (p->comp && p->comp->which == Z_RecordComp_complex &&
 685         p->comp->u.complex->generic &&
 686         p->comp->u.complex->generic->schema)
 687     {
 688         oident *oe = oid_getentbyoid (p->comp->u.complex->generic->schema);
 689         if (oe)
 690             requested_schema = oe->value;
 691     }
 692
 693     /* If schema has been specified, map if possible, then check that
 694      * we got the right one
 695      */
 696     if (requested_schema != VAL_NONE)
 697     {
 698         logf (LOG_DEBUG, "grs_retrieve: schema mapping");
 699         for (map = node->u.root.absyn->maptabs; map; map = map->next)
 700         {
 701             if (map->target_absyn_ref == requested_schema)
 702             {
 703                 onode = node;
 704                 if (!(node = data1_map_record(p->dh, onode, map, mem)))
 705                 {
 706                     p->diagnostic = 14;
 707                     nmem_destroy (mem);
 708                     return 0;
 709                 }
 710                 break;
 711             }
 712         }
 713         if (node->u.root.absyn &&
 714             requested_schema != node->u.root.absyn->reference)
 715         {
 716             p->diagnostic = 238;
 717             nmem_destroy (mem);
 718             return 0;
 719         }
 720     }
 721     /*
 722      * Does the requested format match a known syntax-mapping? (this reflects
 723      * the overlap of schema and formatting which is inherent in the MARC
 724      * family)
 725      */
 726     yaz_log (LOG_DEBUG, "grs_retrieve: syntax mapping");
 727     if (node->u.root.absyn)
 728         for (map = node->u.root.absyn->maptabs; map; map = map->next)
 729         {
 730             if (map->target_absyn_ref == p->input_format)
 731             {
 732                 onode = node;
 733                 if (!(node = data1_map_record(p->dh, onode, map, mem)))
 734                 {
 735                     p->diagnostic = 14;
 736                     nmem_destroy (mem);
 737                     return 0;
 738                 }
 739                 break;
 740             }
 741         }
 742     yaz_log (LOG_DEBUG, "grs_retrieve: schemaIdentifier");
 743     if (node->u.root.absyn &&
 744         node->u.root.absyn->reference != VAL_NONE &&
 745         p->input_format == VAL_GRS1)
 746     {
 747         oident oe;
 748         Odr_oid *oid;
 749         int oidtmp[OID_SIZE];
 750
 751         oe.proto = PROTO_Z3950;
 752         oe.oclass = CLASS_SCHEMA;
 753         oe.value = node->u.root.absyn->reference;
 754
 755         if ((oid = oid_ent_to_oid (&oe, oidtmp)))
 756         {
 757             char tmp[128];
 758             data1_handle dh = p->dh;
 759             char *p = tmp;
 760             int *ii;
 761
 762             for (ii = oid; *ii >= 0; ii++)
 763             {
 764                 if (p != tmp)
 765                         *(p++) = '.';
 766                 sprintf(p, "%d", *ii);
 767                 p += strlen(p);
 768             }
 769             *(p++) = '\0';
 770
 771             if ((dnew = data1_mk_tag_data_wd(dh, node,
 772                                              "schemaIdentifier", mem)))
 773             {
 774                 dnew->u.data.what = DATA1I_oid;
 775                 dnew->u.data.data = (char *) nmem_malloc(mem, p - tmp);
 776                 memcpy(dnew->u.data.data, tmp, p - tmp);
 777                 dnew->u.data.len = p - tmp;
 778             }
 779         }
 780     }
 781
 782     logf (LOG_DEBUG, "grs_retrieve: element spec");
 783     if (p->comp && (res = process_comp(p->dh, node, p->comp)) > 0)
 784     {
 785         p->diagnostic = res;
 786         if (onode)
 787             data1_free_tree(p->dh, onode);
 788         data1_free_tree(p->dh, node);
 789         nmem_destroy(mem);
 790         return 0;
 791     }
 792     else if (p->comp && !res)
 793         selected = 1;
 794
 795 #if 0
 796     data1_pr_tree (p->dh, node, stdout);
 797 #endif
 798     logf (LOG_DEBUG, "grs_retrieve: transfer syntax mapping");
 799     switch (p->output_format = (p->input_format != VAL_NONE ?
 800                                 p->input_format : VAL_SUTRS))
 801     {
 802     case VAL_TEXT_XML:
 803         add_idzebra_info (p, top, mem);
 804
 805         if (p->encoding)
 806             data1_iconv (p->dh, mem, node, p->encoding, "UTF-8");
 807
 808         if (!(p->rec_buf = data1_nodetoidsgml(p->dh, node, selected,
 809                                               &p->rec_len)))
 810             p->diagnostic = 238;
 811         else
 812         {
 813             char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
 814             memcpy (new_buf, p->rec_buf, p->rec_len);
 815             p->rec_buf = new_buf;
 816         }
 817         break;
 818     case VAL_GRS1:
 819         dummy = 0;
 820         if (!(p->rec_buf = data1_nodetogr(p->dh, node, selected,
 821                                           p->odr, &dummy)))
 822             p->diagnostic = 238; /* not available in requested syntax */
 823         else
 824             p->rec_len = (size_t) (-1);
 825         break;
 826     case VAL_EXPLAIN:
 827         if (!(p->rec_buf = data1_nodetoexplain(p->dh, node, selected,
 828                                                p->odr)))
 829             p->diagnostic = 238;
 830         else
 831             p->rec_len = (size_t) (-1);
 832         break;
 833     case VAL_SUMMARY:
 834         if (!(p->rec_buf = data1_nodetosummary(p->dh, node, selected,
 835                                                p->odr)))
 836             p->diagnostic = 238;
 837         else
 838             p->rec_len = (size_t) (-1);
 839         break;
 840     case VAL_SUTRS:
 841         if (p->encoding)
 842             data1_iconv (p->dh, mem, node, p->encoding, "UTF-8");
 843         if (!(p->rec_buf = data1_nodetobuf(p->dh, node, selected,
 844                                            &p->rec_len)))
 845             p->diagnostic = 238;
 846         else
 847         {
 848             char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
 849             memcpy (new_buf, p->rec_buf, p->rec_len);
 850             p->rec_buf = new_buf;
 851         }
 852         break;
 853     case VAL_SOIF:
 854         if (!(p->rec_buf = data1_nodetosoif(p->dh, node, selected,
 855                                             &p->rec_len)))
 856             p->diagnostic = 238;
 857         else
 858         {
 859             char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
 860             memcpy (new_buf, p->rec_buf, p->rec_len);
 861             p->rec_buf = new_buf;
 862         }
 863         break;
 864     default:
 865         if (!node->u.root.absyn)
 866         {
 867             p->diagnostic = 238;
 868             break;
 869         }
 870         for (marctab = node->u.root.absyn->marc; marctab;
 871              marctab = marctab->next)
 872             if (marctab->reference == p->input_format)
 873                 break;
 874         if (!marctab)
 875         {
 876             p->diagnostic = 238;
 877             break;
 878         }
 879         if (p->encoding)
 880             data1_iconv (p->dh, mem, node, p->encoding, "UTF-8");
 881         if (!(p->rec_buf = data1_nodetomarc(p->dh, marctab, node,
 882                                         selected, &p->rec_len)))
 883             p->diagnostic = 238;
 884         else
 885         {
 886             char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
 887             memcpy (new_buf, p->rec_buf, p->rec_len);
 888                 p->rec_buf = new_buf;
 889         }
 890     }
 891     if (node)
 892         data1_free_tree(p->dh, node);
 893     if (onode)
 894         data1_free_tree(p->dh, onode);
 895     nmem_destroy(mem);
 896     return 0;
 897 }
 898
 899 static struct recType grs_type =
 900 {
 901     "grs",
 902     grs_init,
 903     grs_destroy,
 904     grs_extract,
 905     grs_retrieve
 906 };
 907
 908 RecType recTypeGrs = &grs_type;