index/recgrs.c

   1 /* $Id: recgrs.c,v 1.5 2006-08-22 13:39:27 adam Exp $
   2    Copyright (C) 1995-2006
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20
  21 */
  22
  23 #include <stdio.h>
  24 #include <assert.h>
  25 #include <sys/types.h>
  26 #include <ctype.h>
  27
  28 #include <yaz/log.h>
  29 #include <yaz/oid.h>
  30
  31 #include <d1_absyn.h>
  32 #include <idzebra/recgrs.h>
  33
  34 #define GRS_MAX_WORD 512
  35
  36 struct source_parser {
  37     int len;
  38     const char *tok;
  39     const char *src;
  40     int lookahead;
  41     NMEM nmem;
  42 };
  43
  44 static int sp_lex(struct source_parser *sp)
  45 {
  46     while (*sp->src == ' ')
  47         (sp->src)++;
  48     sp->tok = sp->src;
  49     sp->len = 0;
  50     while (*sp->src && !strchr("<>();,-: ", *sp->src))
  51     {
  52         sp->src++;
  53         sp->len++;
  54     }
  55     if (sp->len)
  56         sp->lookahead = 't';
  57     else
  58     {
  59         sp->lookahead = *sp->src;
  60         if (*sp->src)
  61             sp->src++;
  62     }
  63     return sp->lookahead;
  64 }
  65
  66 static int sp_expr(struct source_parser *sp, data1_node *n, RecWord *wrd);
  67
  68 static int sp_range(struct source_parser *sp, data1_node *n, RecWord *wrd)
  69 {
  70     int start, len;
  71     RecWord tmp_w;
  72
  73     /* ( */
  74     sp_lex(sp);
  75     if (sp->lookahead != '(')
  76         return 0;
  77     sp_lex(sp); /* skip ( */
  78
  79     /* 1st arg: string */
  80     if (!sp_expr(sp, n, wrd))
  81         return 0;
  82
  83     if (sp->lookahead != ',')
  84         return 0;
  85     sp_lex(sp); /* skip , */
  86
  87     /* 2nd arg: start */
  88     if (!sp_expr(sp, n, &tmp_w))
  89         return 0;
  90     start = atoi_n(tmp_w.term_buf, tmp_w.term_len);
  91
  92     if (sp->lookahead == ',')
  93     {
  94         sp_lex(sp); /* skip , */
  95
  96         /* 3rd arg: length */
  97         if (!sp_expr(sp, n, &tmp_w))
  98             return 0;
  99         len = atoi_n(tmp_w.term_buf, tmp_w.term_len);
 100     }
 101     else
 102         len = wrd->term_len;
 103
 104     /* ) */
 105     if (sp->lookahead != ')')
 106         return 0;
 107     sp_lex(sp);
 108
 109     if (wrd->term_buf && wrd->term_len)
 110     {
 111         wrd->term_buf += start;
 112         wrd->term_len -= start;
 113         if (wrd->term_len > len)
 114             wrd->term_len = len;
 115     }
 116     return 1;
 117 }
 118
 119 static int sp_first(struct source_parser *sp, data1_node *n, RecWord *wrd)
 120 {
 121     char num_str[20];
 122     int min_pos = -1;
 123     sp_lex(sp);
 124     if (sp->lookahead != '(')
 125         return 0;
 126     sp_lex(sp); /* skip ( */
 127     if (!sp_expr(sp, n, wrd))
 128         return 0;
 129     while (sp->lookahead == ',')
 130     {
 131         RecWord search_w;
 132         int i;
 133         sp_lex(sp); /* skip , */
 134
 135         if (!sp_expr(sp, n, &search_w))
 136             return 0;
 137         for (i = 0; i<wrd->term_len; i++)
 138         {
 139             int j;
 140             for (j = 0; j<search_w.term_len && i+j < wrd->term_len; j++)
 141                 if (wrd->term_buf[i+j] != search_w.term_buf[j])
 142                     break;
 143             if (j == search_w.term_len) /* match ? */
 144             {
 145                 if (min_pos == -1 || i < min_pos)
 146                     min_pos = i;
 147                 break;
 148             }
 149         }
 150     }
 151     if (sp->lookahead != ')')
 152         return 0;
 153     sp_lex(sp);
 154     if (min_pos == -1)
 155         min_pos = 0;  /* the default if not found */
 156     sprintf(num_str, "%d", min_pos);
 157     wrd->term_buf = nmem_strdup(sp->nmem, num_str);
 158     wrd->term_len = strlen(wrd->term_buf);
 159     return 1;
 160 }
 161
 162 static int sp_expr(struct source_parser *sp, data1_node *n, RecWord *wrd)
 163 {
 164     if (sp->lookahead != 't')
 165         return 0;
 166     if (sp->len == 4 && !memcmp(sp->tok, "data", sp->len))
 167     {
 168         if (n->which == DATA1N_data)
 169         {
 170             wrd->term_buf = n->u.data.data;
 171             wrd->term_len = n->u.data.len;
 172         }
 173         sp_lex(sp);
 174     }
 175     else if (sp->len == 3 && !memcmp(sp->tok, "tag", sp->len))
 176     {
 177         if (n->which == DATA1N_tag)
 178         {
 179             wrd->term_buf = n->u.tag.tag;
 180             wrd->term_len = strlen(n->u.tag.tag);
 181         }
 182         sp_lex(sp);
 183     }
 184     else if (sp->len == 4 && !memcmp(sp->tok, "attr", sp->len))
 185     {
 186         RecWord tmp_w;
 187         sp_lex(sp);
 188         if (sp->lookahead != '(')
 189             return 0;
 190         sp_lex(sp);
 191
 192         if (!sp_expr(sp, n, &tmp_w))
 193             return 0;
 194
 195         wrd->term_buf = "";
 196         wrd->term_len = 0;
 197         if (n->which == DATA1N_tag)
 198         {
 199             data1_xattr *p = n->u.tag.attributes;
 200             while (p && strlen(p->name) != tmp_w.term_len &&
 201                    memcmp (p->name, tmp_w.term_buf, tmp_w.term_len))
 202                 p = p->next;
 203             if (p)
 204             {
 205                 wrd->term_buf = p->value;
 206                 wrd->term_len = strlen(p->value);
 207             }
 208         }
 209         if (sp->lookahead != ')')
 210             return 0;
 211         sp_lex(sp);
 212     }
 213     else if (sp->len == 5 && !memcmp(sp->tok, "first", sp->len))
 214     {
 215         return sp_first(sp, n, wrd);
 216     }
 217     else if (sp->len == 5 && !memcmp(sp->tok, "range", sp->len))
 218     {
 219         return sp_range(sp, n, wrd);
 220     }
 221     else if (sp->len > 0 && isdigit(*(unsigned char *)sp->tok))
 222     {
 223         char *b;
 224         wrd->term_len = sp->len;
 225         b = nmem_malloc(sp->nmem, sp->len);
 226         memcpy(b, sp->tok, sp->len);
 227         wrd->term_buf = b;
 228         sp_lex(sp);
 229     }
 230     else if (sp->len > 2 && sp->tok[0] == '\'' && sp->tok[sp->len-1] == '\'')
 231     {
 232         char *b;
 233         wrd->term_len = sp->len - 2;
 234         b = nmem_malloc(sp->nmem, wrd->term_len);
 235         memcpy(b, sp->tok+1, wrd->term_len);
 236         wrd->term_buf = b;
 237         sp_lex(sp);
 238     }
 239     else
 240     {
 241         wrd->term_buf = "";
 242         wrd->term_len = 0;
 243         sp_lex(sp);
 244     }
 245     return 1;
 246 }
 247
 248 static struct source_parser *source_parser_create()
 249 {
 250     struct source_parser *sp = xmalloc(sizeof(*sp));
 251
 252     sp->nmem = nmem_create();
 253     return sp;
 254 }
 255
 256 static void source_parser_destroy(struct source_parser *sp)
 257 {
 258     if (!sp)
 259         return;
 260     nmem_destroy(sp->nmem);
 261     xfree(sp);
 262 }
 263
 264 static int sp_parse(struct source_parser *sp,
 265                     data1_node *n, RecWord *wrd, const char *src)
 266 {
 267     sp->len = 0;
 268     sp->tok = 0;
 269     sp->src = src;
 270     sp->lookahead = 0;
 271     nmem_reset(sp->nmem);
 272
 273     sp_lex(sp);
 274     return sp_expr(sp, n, wrd);
 275 }
 276
 277 int d1_check_xpath_predicate(data1_node *n, struct xpath_predicate *p)
 278 {
 279     int res = 1;
 280     char *attname;
 281     data1_xattr *attr;
 282
 283     if (!p) {
 284         return 1;
 285     } else {
 286         if (p->which == XPATH_PREDICATE_RELATION) {
 287             if (p->u.relation.name[0]) {
 288                 if (*p->u.relation.name != '@') {
 289                     yaz_log(YLOG_WARN,
 290                          "  Only attributes (@) are supported in xelm xpath predicates");
 291                     yaz_log(YLOG_WARN, "predicate %s ignored", p->u.relation.name);
 292                     return 1;
 293                 }
 294                 attname = p->u.relation.name + 1;
 295                 res = 0;
 296                 /* looking for the attribute with a specified name */
 297                 for (attr = n->u.tag.attributes; attr; attr = attr->next) {
 298                     yaz_log(YLOG_DEBUG,"  - attribute %s <-> %s", attname, attr->name );
 299
 300                     if (!strcmp(attr->name, attname)) {
 301                         if (p->u.relation.op[0]) {
 302                             if (*p->u.relation.op != '=') {
 303                                 yaz_log(YLOG_WARN,
 304                                      "Only '=' relation is supported (%s)",p->u.relation.op);
 305                                 yaz_log(YLOG_WARN, "predicate %s ignored", p->u.relation.name);
 306                                 res = 1; break;
 307                             } else {
 308                                 yaz_log(YLOG_DEBUG,"    - value %s <-> %s",
 309                                      p->u.relation.value, attr->value );
 310                                 if (!strcmp(attr->value, p->u.relation.value)) {
 311                                     res = 1; break;
 312                                 }
 313                             }
 314                         } else {
 315                             /* attribute exists, no value specified */
 316                             res = 1; break;
 317                         }
 318                     }
 319                 }
 320                 yaz_log(YLOG_DEBUG, "return %d", res);
 321                 return res;
 322             } else {
 323                 return 1;
 324             }
 325         }
 326         else if (p->which == XPATH_PREDICATE_BOOLEAN) {
 327             if (!strcmp(p->u.boolean.op,"and")) {
 328                 return d1_check_xpath_predicate(n, p->u.boolean.left)
 329                     && d1_check_xpath_predicate(n, p->u.boolean.right);
 330             }
 331             else if (!strcmp(p->u.boolean.op,"or")) {
 332                 return (d1_check_xpath_predicate(n, p->u.boolean.left)
 333                         || d1_check_xpath_predicate(n, p->u.boolean.right));
 334             } else {
 335                 yaz_log(YLOG_WARN, "Unknown boolean relation %s, ignored",p->u.boolean.op);
 336                 return 1;
 337             }
 338         }
 339     }
 340     return 0;
 341 }
 342
 343
 344 static int dfa_match_first(struct DFA_state **dfaar, const char *text)
 345 {
 346     struct DFA_state *s = dfaar[0]; /* start state */
 347     struct DFA_tran *t;
 348     int i;
 349     const char *p = text;
 350     unsigned char c;
 351
 352     for (c = *p++, t = s->trans, i = s->tran_no; --i >= 0; t++)
 353     {
 354         if (c >= t->ch[0] && c <= t->ch[1])
 355         {
 356             while (i >= 0)
 357             {
 358                 /* move to next state and return if we get a match */
 359                 s = dfaar[t->to];
 360                 if (s->rule_no)
 361                     return 1;
 362                 /* next char */
 363                 if (!c)
 364                     return 0;
 365                 c = *p++;
 366                 for (t = s->trans, i = s->tran_no; --i >= 0; t++)
 367                     if (c >= t->ch[0] && c <= t->ch[1])
 368                         break;
 369             }
 370         }
 371     }
 372     return 0;
 373 }
 374
 375 /* *ostrich*
 376
 377 New function, looking for xpath "element" definitions in abs, by
 378 tagpath, using a kind of ugly regxp search.The DFA was built while
 379 parsing abs, so here we just go trough them and try to match
 380 against the given tagpath. The first matching entry is returned.
 381
 382 pop, 2002-12-13
 383
 384 Added support for enhanced xelm. Now [] predicates are considered
 385 as well, when selecting indexing rules... (why the hell it's called
 386 termlist???)
 387
 388 pop, 2003-01-17
 389
 390 */
 391
 392 data1_termlist *xpath_termlist_by_tagpath(char *tagpath, data1_node *n)
 393 {
 394     data1_absyn *abs = n->root->u.root.absyn;
 395     data1_xpelement *xpe = abs->xp_elements;
 396     data1_node *nn;
 397 #ifdef ENHANCED_XELM
 398     struct xpath_location_step *xp;
 399 #endif
 400     char *pexpr = xmalloc(strlen(tagpath)+5);
 401     int ok = 0;
 402
 403     sprintf (pexpr, "/%s\n", tagpath);
 404     for (; xpe; xpe = xpe->next)
 405     {
 406         int i;
 407         ok = dfa_match_first(xpe->dfa->states, pexpr);
 408
 409         if (ok) {
 410 #ifdef ENHANCED_XELM
 411             /* we have to check the perdicates up to the root node */
 412             xp = xpe->xpath;
 413
 414             /* find the first tag up in the node structure */
 415             for (nn = n; nn && nn->which != DATA1N_tag; nn = nn->parent)
 416                 ;
 417
 418             /* go from inside out in the node structure, while going
 419                backwards trough xpath location steps ... */
 420             for (i = xpe->xpath_len - 1; i>0; i--)
 421             {
 422                 yaz_log(YLOG_DEBUG, "Checking step %d: %s on tag %s",
 423                         i, xp[i].part, nn->u.tag.tag);
 424
 425                 if (!d1_check_xpath_predicate(nn, xp[i].predicate))
 426                 {
 427                     yaz_log(YLOG_DEBUG, "  Predicates didn't match");
 428                     ok = 0;
 429                     break;
 430                 }
 431
 432                 if (nn->which == DATA1N_tag)
 433                     nn = nn->parent;
 434             }
 435 #endif
 436             if (ok)
 437                 break;
 438         }
 439     }
 440
 441     xfree(pexpr);
 442
 443     if (ok) {
 444         yaz_log(YLOG_DEBUG, "Got it");
 445         return xpe->termlists;
 446     } else {
 447         return NULL;
 448     }
 449 }
 450
 451 /* use
 452      1   start element (tag)
 453      2   end element
 454      3   start attr (and attr-exact)
 455      4   end attr
 456
 457   1016   cdata
 458   1015   attr data
 459
 460   *ostrich*
 461
 462   Now, if there is a matching xelm described in abs, for the
 463   indexed element or the attribute,  then the data is handled according
 464   to those definitions...
 465
 466   modified by pop, 2002-12-13
 467 */
 468
 469 /* add xpath index for an attribute */
 470 static void index_xpath_attr (char *tag_path, char *name, char *value,
 471                               char *structure, struct recExtractCtrl *p,
 472                               RecWord *wrd)
 473 {
 474     wrd->index_name = ZEBRA_XPATH_ELM_BEGIN;
 475     wrd->index_type = '0';
 476     wrd->term_buf = tag_path;
 477     wrd->term_len = strlen(tag_path);
 478     (*p->tokenAdd)(wrd);
 479
 480     if (value) {
 481         wrd->index_name = ZEBRA_XPATH_ATTR_CDATA;
 482         wrd->index_type = 'w';
 483         wrd->term_buf = value;
 484         wrd->term_len = strlen(value);
 485         (*p->tokenAdd)(wrd);
 486     }
 487     wrd->index_name = ZEBRA_XPATH_ELM_END;
 488     wrd->index_type = '0';
 489     wrd->term_buf = tag_path;
 490     wrd->term_len = strlen(tag_path);
 491     (*p->tokenAdd)(wrd);
 492 }
 493
 494
 495 static void mk_tag_path_full(char *tag_path_full, size_t max, data1_node *n)
 496 {
 497     size_t flen = 0;
 498     data1_node *nn;
 499
 500     /* we have to fetch the whole path to the data tag */
 501     for (nn = n; nn; nn = nn->parent)
 502     {
 503         if (nn->which == DATA1N_tag)
 504         {
 505             size_t tlen = strlen(nn->u.tag.tag);
 506             if (tlen + flen > (max - 2))
 507                 break;
 508             memcpy (tag_path_full + flen, nn->u.tag.tag, tlen);
 509             flen += tlen;
 510             tag_path_full[flen++] = '/';
 511         }
 512         else
 513             if (nn->which == DATA1N_root)
 514                 break;
 515     }
 516     tag_path_full[flen] = 0;
 517 }
 518
 519
 520 static void index_xpath(struct source_parser *sp, data1_node *n,
 521                         struct recExtractCtrl *p,
 522                         int level, RecWord *wrd,
 523                         char *xpath_index,
 524                         int xpath_is_start
 525     )
 526 {
 527     int i;
 528     char tag_path_full[1024];
 529     int termlist_only = 1;
 530     data1_termlist *tl;
 531     int xpdone = 0;
 532     if ((!n->root->u.root.absyn) ||
 533         (n->root->u.root.absyn->xpath_indexing == DATA1_XPATH_INDEXING_ENABLE)) {
 534         termlist_only = 0;
 535     }
 536
 537     switch (n->which)
 538     {
 539     case DATA1N_data:
 540         wrd->term_buf = n->u.data.data;
 541         wrd->term_len = n->u.data.len;
 542         xpdone = 0;
 543
 544         mk_tag_path_full(tag_path_full, sizeof(tag_path_full), n);
 545
 546         /* If we have a matching termlist... */
 547         if (n->root->u.root.absyn &&
 548             (tl = xpath_termlist_by_tagpath(tag_path_full, n)))
 549         {
 550             for (; tl; tl = tl->next)
 551             {
 552                 /* need to copy recword because it may be changed */
 553                 RecWord wrd_tl;
 554                 wrd->index_type = *tl->structure;
 555                 memcpy (&wrd_tl, wrd, sizeof(*wrd));
 556                 if (tl->source)
 557                     sp_parse(sp, n, &wrd_tl, tl->source);
 558                 if (!tl->index_name)
 559                 {
 560                     /* this is the ! case, so structure is for the xpath index */
 561                     wrd_tl.index_name = xpath_index;
 562                     if (p->flagShowRecords)
 563                     {
 564                         int i;
 565                         printf("%*sXPath index", (level + 1) * 4, "");
 566                         printf (" XData:\"");
 567                         for (i = 0; i<wrd_tl.term_len && i < 40; i++)
 568                             fputc (wrd_tl.term_buf[i], stdout);
 569                         fputc ('"', stdout);
 570                         if (wrd_tl.term_len > 40)
 571                             printf (" ...");
 572                         fputc ('\n', stdout);
 573                     }
 574                     else
 575                         (*p->tokenAdd)(&wrd_tl);
 576                     xpdone = 1;
 577                 } else {
 578                     /* this is just the old fashioned attribute based index */
 579                     wrd_tl.index_name = tl->index_name;
 580                     if (p->flagShowRecords)
 581                     {
 582                         int i;
 583                         printf("%*sIdx: [%s]", (level + 1) * 4, "",
 584                                tl->structure);
 585                         printf("%s %s", tl->index_name, tl->source);
 586                         printf (" XData:\"");
 587                         for (i = 0; i<wrd_tl.term_len && i < 40; i++)
 588                             fputc (wrd_tl.term_buf[i], stdout);
 589                         fputc ('"', stdout);
 590                         if (wrd_tl.term_len > 40)
 591                             printf (" ...");
 592                         fputc ('\n', stdout);
 593                     }
 594                     else
 595                         (*p->tokenAdd)(&wrd_tl);
 596                 }
 597             }
 598         }
 599         /* xpath indexing is done, if there was no termlist given,
 600            or no ! in the termlist, and default indexing is enabled... */
 601         if (!p->flagShowRecords && !xpdone && !termlist_only)
 602         {
 603             wrd->index_name = xpath_index;
 604             wrd->index_type = 'w';
 605             (*p->tokenAdd)(wrd);
 606         }
 607         break;
 608     case DATA1N_tag:
 609         mk_tag_path_full(tag_path_full, sizeof(tag_path_full), n);
 610
 611         wrd->index_type = '0';
 612         wrd->term_buf = tag_path_full;
 613         wrd->term_len = strlen(tag_path_full);
 614         wrd->index_name = xpath_index;
 615         if (p->flagShowRecords)
 616         {
 617             printf("%*s tag=", (level + 1) * 4, "");
 618             for (i = 0; i<wrd->term_len && i < 40; i++)
 619                 fputc (wrd->term_buf[i], stdout);
 620             if (i == 40)
 621                 printf (" ..");
 622             printf("\n");
 623         }
 624         else
 625         {
 626             data1_xattr *xp;
 627             data1_termlist *tl;
 628             int do_xpindex;
 629
 630             /* Add tag start/end xpath index, only when there is a ! in
 631                the apropriate xelm directive, or default xpath indexing
 632                is enabled
 633             */
 634             if (!(do_xpindex = 1 - termlist_only))
 635             {
 636                 if ((tl = xpath_termlist_by_tagpath(tag_path_full, n)))
 637                 {
 638                     for (; tl; tl = tl->next)
 639                     {
 640                         if (!tl->index_name)
 641                             do_xpindex = 1;
 642                     }
 643                 }
 644             }
 645             if (do_xpindex) {
 646                 (*p->tokenAdd)(wrd);   /* index element pag (AKA tag path) */
 647             }
 648
 649             if (xpath_is_start == 1) /* only for the starting tag... */
 650             {
 651 #define MAX_ATTR_COUNT 50
 652                 data1_termlist *tll[MAX_ATTR_COUNT];
 653
 654                 int i = 0;
 655
 656                 /* get termlists for attributes, and find out, if we have to do xpath indexing */
 657                 for (xp = n->u.tag.attributes; xp; xp = xp->next) {
 658                     i++;
 659                 }
 660
 661                 i = 0;
 662                 for (xp = n->u.tag.attributes; xp; xp = xp->next) {
 663                     char comb[512];
 664                     int do_xpindex = 1 - termlist_only;
 665                     data1_termlist *tl;
 666                     char attr_tag_path_full[1024];
 667
 668                     /* this could be cached as well */
 669                     sprintf (attr_tag_path_full, "@%s/%s",
 670                              xp->name, tag_path_full);
 671
 672                     tll[i] = xpath_termlist_by_tagpath(attr_tag_path_full,n);
 673
 674                     /* if there is a ! in the xelm termlist, or default indexing is on,
 675                        proceed with xpath idx */
 676                     if ((tl = tll[i]))
 677                     {
 678                         for (; tl; tl = tl->next)
 679                         {
 680                             if (!tl->index_name)
 681                                 do_xpindex = 1;
 682                         }
 683                     }
 684
 685                     if (do_xpindex) {
 686
 687                         /* attribute  (no value) */
 688                         wrd->index_type = '0';
 689                         wrd->index_name = ZEBRA_XPATH_ATTR_NAME;
 690                         wrd->term_buf = xp->name;
 691                         wrd->term_len = strlen(xp->name);
 692
 693                         wrd->seqno--;
 694                         (*p->tokenAdd)(wrd);
 695
 696                         if (xp->value &&
 697                             strlen(xp->name) + strlen(xp->value) < sizeof(comb)-2) {
 698
 699                             /* attribute value exact */
 700                             strcpy (comb, xp->name);
 701                             strcat (comb, "=");
 702                             strcat (comb, xp->value);
 703
 704                             wrd->index_name = ZEBRA_XPATH_ATTR_NAME;
 705                             wrd->index_type = '0';
 706                             wrd->term_buf = comb;
 707                             wrd->term_len = strlen(comb);
 708                             wrd->seqno--;
 709
 710                             (*p->tokenAdd)(wrd);
 711                         }
 712                     }
 713                     i++;
 714                 }
 715
 716                 i = 0;
 717                 for (xp = n->u.tag.attributes; xp; xp = xp->next) {
 718                     data1_termlist *tl;
 719                     char attr_tag_path_full[1024];
 720                     int xpdone = 0;
 721
 722                     sprintf (attr_tag_path_full, "@%s/%s",
 723                              xp->name, tag_path_full);
 724
 725                     if ((tl = tll[i]))
 726                     {
 727                         /* If there is a termlist given (=xelm directive) */
 728                         for (; tl; tl = tl->next)
 729                         {
 730                             if (!tl->index_name)
 731                             {
 732                                 /* add xpath index for the attribute */
 733                                 index_xpath_attr (attr_tag_path_full, xp->name,
 734                                                   xp->value, tl->structure,
 735                                                   p, wrd);
 736                                 xpdone = 1;
 737                             } else {
 738                                 /* index attribute value (only path/@attr) */
 739                                 if (xp->value)
 740                                 {
 741                                     wrd->index_name = tl->index_name;
 742                                     wrd->index_type = *tl->structure;
 743                                     wrd->term_buf = xp->value;
 744                                     wrd->term_len = strlen(xp->value);
 745                                     (*p->tokenAdd)(wrd);
 746                                 }
 747                             }
 748                         }
 749                     }
 750                     /* if there was no termlist for the given path,
 751                        or the termlist didn't have a ! element, index
 752                        the attribute as "w" */
 753                     if ((!xpdone) && (!termlist_only))
 754                     {
 755                         index_xpath_attr (attr_tag_path_full, xp->name,
 756                                           xp->value,  "w", p, wrd);
 757                     }
 758                     i++;
 759                 }
 760             }
 761         }
 762     }
 763 }
 764
 765 static void index_termlist (struct source_parser *sp, data1_node *par,
 766                             data1_node *n,
 767                             struct recExtractCtrl *p, int level, RecWord *wrd)
 768 {
 769     data1_termlist *tlist = 0;
 770     data1_datatype dtype = DATA1K_string;
 771
 772     /*
 773      * cycle up towards the root until we find a tag with an att..
 774      * this has the effect of indexing locally defined tags with
 775      * the attribute of their ancestor in the record.
 776      */
 777
 778     while (!par->u.tag.element)
 779         if (!par->parent || !(par=get_parent_tag(p->dh, par->parent)))
 780             break;
 781     if (!par || !(tlist = par->u.tag.element->termlists))
 782         return;
 783     if (par->u.tag.element->tag)
 784         dtype = par->u.tag.element->tag->kind;
 785
 786     for (; tlist; tlist = tlist->next)
 787     {
 788         /* consider source */
 789         wrd->term_buf = 0;
 790         assert(tlist->source);
 791         sp_parse(sp, n, wrd, tlist->source);
 792
 793         if (wrd->term_buf && wrd->term_len)
 794         {
 795             if (p->flagShowRecords)
 796             {
 797                 int i;
 798                 printf("%*sIdx: [%s]", (level + 1) * 4, "",
 799                        tlist->structure);
 800                 printf("%s %s", tlist->index_name, tlist->source);
 801                 printf (" XData:\"");
 802                 for (i = 0; i<wrd->term_len && i < 40; i++)
 803                     fputc (wrd->term_buf[i], stdout);
 804                 fputc ('"', stdout);
 805                 if (wrd->term_len > 40)
 806                     printf (" ...");
 807                 fputc ('\n', stdout);
 808             }
 809             else
 810             {
 811                 wrd->index_type = *tlist->structure;
 812                 wrd->index_name = tlist->index_name;
 813                 (*p->tokenAdd)(wrd);
 814             }
 815         }
 816     }
 817 }
 818
 819 static int dumpkeys_r(struct source_parser *sp,
 820                       data1_node *n, struct recExtractCtrl *p, int level,
 821                       RecWord *wrd)
 822 {
 823     for (; n; n = n->next)
 824     {
 825         if (p->flagShowRecords) /* display element description to user */
 826         {
 827             if (n->which == DATA1N_root)
 828             {
 829                 printf("%*s", level * 4, "");
 830                 printf("Record type: '%s'\n", n->u.root.type);
 831             }
 832             else if (n->which == DATA1N_tag)
 833             {
 834                 data1_element *e;
 835
 836                 printf("%*s", level * 4, "");
 837                 if (!(e = n->u.tag.element))
 838                     printf("Local tag: '%s'\n", n->u.tag.tag);
 839                 else
 840                 {
 841                     printf("Elm: '%s' ", e->name);
 842                     if (e->tag)
 843                     {
 844                         data1_tag *t = e->tag;
 845
 846                         printf("TagNam: '%s' ", t->names->name);
 847                         printf("(");
 848                         if (t->tagset)
 849                             printf("%s[%d],", t->tagset->name, t->tagset->type);
 850                         else
 851                             printf("?,");
 852                         if (t->which == DATA1T_numeric)
 853                             printf("%d)", t->value.numeric);
 854                         else
 855                             printf("'%s')", t->value.string);
 856                     }
 857                     printf("\n");
 858                 }
 859             }
 860         }
 861
 862         if (n->which == DATA1N_tag)
 863         {
 864             index_termlist(sp, n, n, p, level, wrd);
 865             /* index start tag */
 866             if (n->root->u.root.absyn)
 867                 index_xpath(sp, n, p, level, wrd, ZEBRA_XPATH_ELM_BEGIN,
 868                             1 /* is start */);
 869         }
 870
 871         if (n->child)
 872             if (dumpkeys_r(sp, n->child, p, level + 1, wrd) < 0)
 873                 return -1;
 874
 875
 876         if (n->which == DATA1N_data)
 877         {
 878             data1_node *par = get_parent_tag(p->dh, n);
 879
 880             if (p->flagShowRecords)
 881             {
 882                 printf("%*s", level * 4, "");
 883                 printf("Data: ");
 884                 if (n->u.data.len > 256)
 885                     printf("'%.170s ... %.70s'\n", n->u.data.data,
 886                            n->u.data.data + n->u.data.len-70);
 887                 else if (n->u.data.len > 0)
 888                     printf("'%.*s'\n", n->u.data.len, n->u.data.data);
 889                 else
 890                     printf("NULL\n");
 891             }
 892
 893             if (par)
 894                 index_termlist(sp, par, n, p, level, wrd);
 895
 896             index_xpath(sp, n, p, level, wrd, ZEBRA_XPATH_CDATA,
 897                         0 /* is start */);
 898         }
 899
 900         if (n->which == DATA1N_tag)
 901         {
 902             /* index end tag */
 903             index_xpath(sp, n, p, level, wrd, ZEBRA_XPATH_ELM_END,
 904                         0 /* is start */);
 905         }
 906
 907         if (p->flagShowRecords && n->which == DATA1N_root)
 908         {
 909             printf("%*s-------------\n\n", level * 4, "");
 910         }
 911     }
 912     return 0;
 913 }
 914
 915 static int dumpkeys(data1_node *n, struct recExtractCtrl *p, RecWord *wrd)
 916 {
 917     struct source_parser *sp = source_parser_create();
 918     int r = dumpkeys_r(sp, n, p, 0, wrd);
 919     source_parser_destroy(sp);
 920     return r;
 921 }
 922
 923 int grs_extract_tree(struct recExtractCtrl *p, data1_node *n)
 924 {
 925     oident oe;
 926     int oidtmp[OID_SIZE];
 927     RecWord wrd;
 928
 929     oe.proto = PROTO_Z3950;
 930     oe.oclass = CLASS_SCHEMA;
 931     if (n->u.root.absyn)
 932     {
 933         oe.value = n->u.root.absyn->reference;
 934
 935         if ((oid_ent_to_oid (&oe, oidtmp)))
 936             (*p->schemaAdd)(p, oidtmp);
 937     }
 938     (*p->init)(p, &wrd);
 939
 940     /* data1_pr_tree(p->dh, n, stdout); */
 941
 942     return dumpkeys(n, p, &wrd);
 943 }
 944
 945 static int grs_extract_sub(void *clientData, struct recExtractCtrl *p,
 946                            NMEM mem,
 947                            data1_node *(*grs_read)(struct grs_read_info *))
 948 {
 949     data1_node *n;
 950     struct grs_read_info gri;
 951     oident oe;
 952     int oidtmp[OID_SIZE];
 953     RecWord wrd;
 954
 955     gri.stream = p->stream;
 956     gri.mem = mem;
 957     gri.dh = p->dh;
 958     gri.clientData = clientData;
 959
 960     n = (*grs_read)(&gri);
 961     if (!n)
 962         return RECCTRL_EXTRACT_EOF;
 963     oe.proto = PROTO_Z3950;
 964     oe.oclass = CLASS_SCHEMA;
 965 #if 0
 966     if (!n->u.root.absyn)
 967         return RECCTRL_EXTRACT_ERROR;
 968 #endif
 969     if (n->u.root.absyn)
 970     {
 971         oe.value = n->u.root.absyn->reference;
 972         if ((oid_ent_to_oid (&oe, oidtmp)))
 973             (*p->schemaAdd)(p, oidtmp);
 974     }
 975     data1_concat_text(p->dh, mem, n);
 976
 977     /* ensure our data1 tree is UTF-8 */
 978     data1_iconv (p->dh, mem, n, "UTF-8", data1_get_encoding(p->dh, n));
 979
 980
 981     data1_remove_idzebra_subtree (p->dh, n);
 982
 983 #if 0
 984     data1_pr_tree (p->dh, n, stdout);
 985 #endif
 986
 987     (*p->init)(p, &wrd);
 988     if (dumpkeys(n, p, &wrd) < 0)
 989     {
 990         return RECCTRL_EXTRACT_ERROR_GENERIC;
 991     }
 992     return RECCTRL_EXTRACT_OK;
 993 }
 994
 995 int zebra_grs_extract(void *clientData, struct recExtractCtrl *p,
 996                       data1_node *(*grs_read)(struct grs_read_info *))
 997 {
 998     int ret;
 999     NMEM mem = nmem_create ();
1000     ret = grs_extract_sub(clientData, p, mem, grs_read);
1001     nmem_destroy(mem);
1002     return ret;
1003 }
1004
1005 /*
1006  * Return: -1: Nothing done. 0: Ok. >0: Bib-1 diagnostic.
1007  */
1008 static int process_comp(data1_handle dh, data1_node *n, Z_RecordComposition *c,
1009                         char **addinfo, ODR o)
1010 {
1011     data1_esetname *eset;
1012     Z_Espec1 *espec = 0;
1013     Z_ElementSpec *p;
1014
1015     switch (c->which)
1016     {
1017     case Z_RecordComp_simple:
1018         if (c->u.simple->which != Z_ElementSetNames_generic)
1019             return 26; /* only generic form supported. Fix this later */
1020         if (!(eset = data1_getesetbyname(dh, n->u.root.absyn,
1021                                          c->u.simple->u.generic)))
1022         {
1023             yaz_log(YLOG_LOG, "Unknown esetname '%s'", c->u.simple->u.generic);
1024             *addinfo = odr_strdup(o, c->u.simple->u.generic);
1025             return 25; /* invalid esetname */
1026         }
1027         yaz_log(YLOG_DEBUG, "Esetname '%s' in simple compspec",
1028              c->u.simple->u.generic);
1029         espec = eset->spec;
1030         break;
1031     case Z_RecordComp_complex:
1032         if (c->u.complex->generic)
1033         {
1034             /* insert check for schema */
1035             if ((p = c->u.complex->generic->elementSpec))
1036             {
1037                 switch (p->which)
1038                 {
1039                 case Z_ElementSpec_elementSetName:
1040                     if (!(eset =
1041                           data1_getesetbyname(dh, n->u.root.absyn,
1042                                               p->u.elementSetName)))
1043                     {
1044                         yaz_log(YLOG_DEBUG, "Unknown esetname '%s'",
1045                              p->u.elementSetName);
1046                         *addinfo = odr_strdup(o, p->u.elementSetName);
1047                         return 25; /* invalid esetname */
1048                     }
1049                     yaz_log(YLOG_DEBUG, "Esetname '%s' in complex compspec",
1050                          p->u.elementSetName);
1051                     espec = eset->spec;
1052                     break;
1053                 case Z_ElementSpec_externalSpec:
1054                     if (p->u.externalSpec->which == Z_External_espec1)
1055                     {
1056                         yaz_log(YLOG_DEBUG, "Got Espec-1");
1057                         espec = p->u.externalSpec-> u.espec1;
1058                     }
1059                     else
1060                     {
1061                         yaz_log(YLOG_LOG, "Unknown external espec.");
1062                         return 25; /* bad. what is proper diagnostic? */
1063                     }
1064                     break;
1065                 }
1066             }
1067         }
1068         else
1069             return 26; /* fix */
1070     }
1071     if (espec)
1072     {
1073         yaz_log(YLOG_DEBUG, "Element: Espec-1 match");
1074         return data1_doespec1(dh, n, espec);
1075     }
1076     else
1077     {
1078         yaz_log(YLOG_DEBUG, "Element: all match");
1079         return -1;
1080     }
1081 }
1082
1083 /* Add Zebra info in separate namespace ...
1084         <root
1085          ...
1086          <metadata xmlns="http://www.indexdata.dk/zebra/">
1087           <size>359</size>
1088           <localnumber>447</localnumber>
1089           <filename>records/genera.xml</filename>
1090          </metadata>
1091         </root>
1092 */
1093
1094 static void zebra_xml_metadata (struct recRetrieveCtrl *p, data1_node *top,
1095                                 NMEM mem)
1096 {
1097     const char *idzebra_ns[3];
1098     const char *i2 = "\n  ";
1099     const char *i4 = "\n    ";
1100     data1_node *n;
1101
1102     idzebra_ns[0] = "xmlns";
1103     idzebra_ns[1] = "http://www.indexdata.dk/zebra/";
1104     idzebra_ns[2] = 0;
1105
1106     data1_mk_text (p->dh, mem, i2, top);
1107
1108     n = data1_mk_tag (p->dh, mem, "idzebra", idzebra_ns, top);
1109
1110     data1_mk_text (p->dh, mem, "\n", top);
1111
1112     data1_mk_text (p->dh, mem, i4, n);
1113
1114     data1_mk_tag_data_int (p->dh, n, "size", p->recordSize, mem);
1115
1116     if (p->score != -1)
1117     {
1118         data1_mk_text (p->dh, mem, i4, n);
1119         data1_mk_tag_data_int (p->dh, n, "score", p->score, mem);
1120     }
1121     data1_mk_text (p->dh, mem, i4, n);
1122     data1_mk_tag_data_zint (p->dh, n, "localnumber", p->localno, mem);
1123     if (p->fname)
1124     {
1125         data1_mk_text (p->dh, mem, i4, n);
1126         data1_mk_tag_data_text(p->dh, n, "filename", p->fname, mem);
1127     }
1128     data1_mk_text (p->dh, mem, i2, n);
1129 }
1130
1131 int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
1132                        data1_node *(*grs_read)(struct grs_read_info *))
1133 {
1134     data1_node *node = 0, *onode = 0, *top;
1135     data1_node *dnew;
1136     data1_maptab *map;
1137     int res, selected = 0;
1138     NMEM mem;
1139     struct grs_read_info gri;
1140     const char *tagname;
1141
1142     int requested_schema = VAL_NONE;
1143     data1_marctab *marctab;
1144     int dummy;
1145
1146     mem = nmem_create();
1147     gri.stream = p->stream;
1148     gri.mem = mem;
1149     gri.dh = p->dh;
1150     gri.clientData = clientData;
1151
1152     yaz_log(YLOG_DEBUG, "grs_retrieve");
1153     node = (*grs_read)(&gri);
1154     if (!node)
1155     {
1156         p->diagnostic = 14;
1157         nmem_destroy (mem);
1158         return 0;
1159     }
1160     data1_concat_text(p->dh, mem, node);
1161
1162     data1_remove_idzebra_subtree (p->dh, node);
1163
1164 #if 0
1165     data1_pr_tree (p->dh, node, stdout);
1166 #endif
1167     top = data1_get_root_tag (p->dh, node);
1168
1169     yaz_log(YLOG_DEBUG, "grs_retrieve: size");
1170     tagname = data1_systag_lookup(node->u.root.absyn, "size", "size");
1171     if (tagname &&
1172         (dnew = data1_mk_tag_data_wd(p->dh, top, tagname, mem)))
1173     {
1174         dnew->u.data.what = DATA1I_text;
1175         dnew->u.data.data = dnew->lbuf;
1176         sprintf(dnew->u.data.data, "%d", p->recordSize);
1177         dnew->u.data.len = strlen(dnew->u.data.data);
1178     }
1179
1180     tagname = data1_systag_lookup(node->u.root.absyn, "rank", "rank");
1181     if (tagname && p->score >= 0 &&
1182         (dnew = data1_mk_tag_data_wd(p->dh, top, tagname, mem)))
1183     {
1184         yaz_log(YLOG_DEBUG, "grs_retrieve: %s", tagname);
1185         dnew->u.data.what = DATA1I_num;
1186         dnew->u.data.data = dnew->lbuf;
1187         sprintf(dnew->u.data.data, "%d", p->score);
1188         dnew->u.data.len = strlen(dnew->u.data.data);
1189     }
1190
1191     tagname = data1_systag_lookup(node->u.root.absyn, "sysno",
1192                                   "localControlNumber");
1193     if (tagname && p->localno > 0 &&
1194         (dnew = data1_mk_tag_data_wd(p->dh, top, tagname, mem)))
1195     {
1196         yaz_log(YLOG_DEBUG, "grs_retrieve: %s", tagname);
1197         dnew->u.data.what = DATA1I_text;
1198         dnew->u.data.data = dnew->lbuf;
1199
1200         sprintf(dnew->u.data.data, ZINT_FORMAT, p->localno);
1201         dnew->u.data.len = strlen(dnew->u.data.data);
1202     }
1203
1204     if (p->input_format == VAL_TEXT_XML)
1205        zebra_xml_metadata (p, top, mem);
1206
1207 #if 0
1208     data1_pr_tree (p->dh, node, stdout);
1209 #endif
1210     if (p->comp && p->comp->which == Z_RecordComp_complex &&
1211         p->comp->u.complex->generic &&
1212         p->comp->u.complex->generic->which == Z_Schema_oid &&
1213         p->comp->u.complex->generic->schema.oid)
1214     {
1215         oident *oe = oid_getentbyoid (p->comp->u.complex->generic->schema.oid);
1216         if (oe)
1217             requested_schema = oe->value;
1218     }
1219     /* If schema has been specified, map if possible, then check that
1220      * we got the right one
1221      */
1222     if (requested_schema != VAL_NONE)
1223     {
1224         yaz_log(YLOG_DEBUG, "grs_retrieve: schema mapping");
1225         for (map = node->u.root.absyn->maptabs; map; map = map->next)
1226         {
1227             if (map->target_absyn_ref == requested_schema)
1228             {
1229                 onode = node;
1230                 if (!(node = data1_map_record(p->dh, onode, map, mem)))
1231                 {
1232                     p->diagnostic = 14;
1233                     nmem_destroy (mem);
1234                     return 0;
1235                 }
1236                 break;
1237             }
1238         }
1239         if (node->u.root.absyn &&
1240             requested_schema != node->u.root.absyn->reference)
1241         {
1242             p->diagnostic = 238;
1243             nmem_destroy (mem);
1244             return 0;
1245         }
1246     }
1247     /*
1248      * Does the requested format match a known syntax-mapping? (this reflects
1249      * the overlap of schema and formatting which is inherent in the MARC
1250      * family)
1251      */
1252     yaz_log(YLOG_DEBUG, "grs_retrieve: syntax mapping");
1253     if (node->u.root.absyn)
1254         for (map = node->u.root.absyn->maptabs; map; map = map->next)
1255         {
1256             if (map->target_absyn_ref == p->input_format)
1257             {
1258                 onode = node;
1259                 if (!(node = data1_map_record(p->dh, onode, map, mem)))
1260                 {
1261                     p->diagnostic = 14;
1262                     nmem_destroy (mem);
1263                     return 0;
1264                 }
1265                 break;
1266             }
1267         }
1268     yaz_log(YLOG_DEBUG, "grs_retrieve: schemaIdentifier");
1269     if (node->u.root.absyn &&
1270         node->u.root.absyn->reference != VAL_NONE &&
1271         p->input_format == VAL_GRS1)
1272     {
1273         oident oe;
1274         Odr_oid *oid;
1275         int oidtmp[OID_SIZE];
1276
1277         oe.proto = PROTO_Z3950;
1278         oe.oclass = CLASS_SCHEMA;
1279         oe.value = node->u.root.absyn->reference;
1280
1281         if ((oid = oid_ent_to_oid (&oe, oidtmp)))
1282         {
1283             char tmp[128];
1284             data1_handle dh = p->dh;
1285             char *p = tmp;
1286             int *ii;
1287
1288             for (ii = oid; *ii >= 0; ii++)
1289             {
1290                 if (p != tmp)
1291                         *(p++) = '.';
1292                 sprintf(p, "%d", *ii);
1293                 p += strlen(p);
1294             }
1295             if ((dnew = data1_mk_tag_data_wd(dh, top,
1296                                              "schemaIdentifier", mem)))
1297             {
1298                 dnew->u.data.what = DATA1I_oid;
1299                 dnew->u.data.data = (char *) nmem_malloc(mem, p - tmp);
1300                 memcpy(dnew->u.data.data, tmp, p - tmp);
1301                 dnew->u.data.len = p - tmp;
1302             }
1303         }
1304     }
1305
1306     yaz_log(YLOG_DEBUG, "grs_retrieve: element spec");
1307     if (p->comp && (res = process_comp(p->dh, node, p->comp, &p->addinfo,
1308                                        p->odr)) > 0)
1309     {
1310         p->diagnostic = res;
1311         nmem_destroy(mem);
1312         return 0;
1313     }
1314     else if (p->comp && !res)
1315         selected = 1;
1316
1317 #if 0
1318     data1_pr_tree (p->dh, node, stdout);
1319 #endif
1320     yaz_log(YLOG_DEBUG, "grs_retrieve: transfer syntax mapping");
1321     switch (p->output_format = (p->input_format != VAL_NONE ?
1322                                 p->input_format : VAL_SUTRS))
1323     {
1324     case VAL_TEXT_XML:
1325 #if 0
1326         data1_pr_tree (p->dh, node, stdout);
1327 #endif
1328         /* default output encoding for XML is UTF-8 */
1329         data1_iconv (p->dh, mem, node,
1330                      p->encoding ? p->encoding : "UTF-8",
1331                      data1_get_encoding(p->dh, node));
1332
1333         if (!(p->rec_buf = data1_nodetoidsgml(p->dh, node, selected,
1334                                               &p->rec_len)))
1335             p->diagnostic = 238;
1336         else
1337         {
1338             char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
1339             memcpy (new_buf, p->rec_buf, p->rec_len);
1340             p->rec_buf = new_buf;
1341         }
1342         break;
1343     case VAL_GRS1:
1344         data1_iconv (p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
1345         dummy = 0;
1346         if (!(p->rec_buf = data1_nodetogr(p->dh, node, selected,
1347                                           p->odr, &dummy)))
1348             p->diagnostic = 238; /* not available in requested syntax */
1349         else
1350             p->rec_len = -1;
1351         break;
1352     case VAL_EXPLAIN:
1353         /* ensure our data1 tree is UTF-8 */
1354         data1_iconv (p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
1355
1356         if (!(p->rec_buf = data1_nodetoexplain(p->dh, node, selected,
1357                                                p->odr)))
1358             p->diagnostic = 238;
1359         else
1360             p->rec_len = -1;
1361         break;
1362     case VAL_SUMMARY:
1363         /* ensure our data1 tree is UTF-8 */
1364         data1_iconv (p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
1365         if (!(p->rec_buf = data1_nodetosummary(p->dh, node, selected,
1366                                                p->odr)))
1367             p->diagnostic = 238;
1368         else
1369             p->rec_len = -1;
1370         break;
1371     case VAL_SUTRS:
1372         if (p->encoding)
1373             data1_iconv (p->dh, mem, node, p->encoding,
1374                          data1_get_encoding(p->dh, node));
1375         if (!(p->rec_buf = data1_nodetobuf(p->dh, node, selected,
1376                                            &p->rec_len)))
1377             p->diagnostic = 238;
1378         else
1379         {
1380             char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
1381             memcpy (new_buf, p->rec_buf, p->rec_len);
1382             p->rec_buf = new_buf;
1383         }
1384         break;
1385     case VAL_SOIF:
1386         if (p->encoding)
1387             data1_iconv (p->dh, mem, node, p->encoding,
1388                          data1_get_encoding(p->dh, node));
1389         if (!(p->rec_buf = data1_nodetosoif(p->dh, node, selected,
1390                                             &p->rec_len)))
1391             p->diagnostic = 238;
1392         else
1393         {
1394             char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
1395             memcpy (new_buf, p->rec_buf, p->rec_len);
1396             p->rec_buf = new_buf;
1397         }
1398         break;
1399     default:
1400         if (!node->u.root.absyn)
1401         {
1402             p->diagnostic = 238;
1403             break;
1404         }
1405         for (marctab = node->u.root.absyn->marc; marctab;
1406              marctab = marctab->next)
1407             if (marctab->reference == p->input_format)
1408                 break;
1409         if (!marctab)
1410         {
1411             p->diagnostic = 238;
1412             break;
1413         }
1414         if (p->encoding)
1415             data1_iconv (p->dh, mem, node, p->encoding,
1416                          data1_get_encoding(p->dh, node));
1417         if (!(p->rec_buf = data1_nodetomarc(p->dh, marctab, node,
1418                                         selected, &p->rec_len)))
1419             p->diagnostic = 238;
1420         else
1421         {
1422             char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
1423             memcpy (new_buf, p->rec_buf, p->rec_len);
1424                 p->rec_buf = new_buf;
1425         }
1426     }
1427     nmem_destroy(mem);
1428     return 0;
1429 }
1430
1431 /*
1432  * Local variables:
1433  * c-basic-offset: 4
1434  * indent-tabs-mode: nil
1435  * End:
1436  * vim: shiftwidth=4 tabstop=8 expandtab
1437  */
1438