retrieval/d1_absyn.c

   1 /*
   2  * Copyright (c) 1995-2000, Index Data.
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: d1_absyn.c,v $
   7  * Revision 1.31  2002-04-04 20:49:46  adam
   8  * New functions yaz_is_abspath, yaz_path_fopen_base
   9  *
  10  * Revision 1.30  2000/12/05 19:07:24  adam
  11  * Fixed problem with element level in reading of abstract syntax.
  12  *
  13  * Revision 1.29  2000/12/05 14:34:49  adam
  14  * Fixed bug with termlists (introduced by previous commit).
  15  *
  16  * Revision 1.28  2000/12/05 12:21:45  adam
  17  * Added termlist source for data1 system.
  18  *
  19  * Revision 1.27  1999/12/21 14:16:19  ian
  20  * Changed retrieval module to allow data1 trees with no associated absyn.
  21  * Also added a simple interface for extracting values from data1 trees using
  22  * a string based tagpath.
  23  *
  24  * Revision 1.26  1999/11/30 13:47:12  adam
  25  * Improved installation. Moved header files to include/yaz.
  26  *
  27  * Revision 1.25  1999/10/21 12:06:29  adam
  28  * Retrieval module no longer uses ctype.h - functions.
  29  *
  30  * Revision 1.24  1999/08/27 09:40:32  adam
  31  * Renamed logf function to yaz_log. Removed VC++ project files.
  32  *
  33  * Revision 1.23  1998/10/15 08:29:16  adam
  34  * Tag set type may be specified in reference to it using "tagset"
  35  * directive in .abs-files and "include" directive in .tag-files.
  36  *
  37  * Revision 1.22  1998/10/13 16:09:47  adam
  38  * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
  39  * Added support for multiple attribute set references and tagset references
  40  * from an abstract syntax file.
  41  * Fixed many bad logs-calls in routines that read the various
  42  * specifications regarding data1 (*.abs,*.att,...) and made the messages
  43  * consistent whenever possible.
  44  * Added extra 'lineno' argument to function readconf_line.
  45  *
  46  * Revision 1.21  1998/06/09 13:55:07  adam
  47  * Minor changes.
  48  *
  49  * Revision 1.20  1998/05/18 13:07:02  adam
  50  * Changed the way attribute sets are handled by the retriaval module.
  51  * Extended Explain conversion / schema.
  52  * Modified server and client to work with ASN.1 compiled protocol handlers.
  53  *
  54  * Revision 1.19  1998/03/05 08:15:32  adam
  55  * Implemented data1_add_insert_taggeddata utility which is more flexible
  56  * than data1_insert_taggeddata.
  57  *
  58  * Revision 1.18  1998/02/27 14:08:04  adam
  59  * Added const to some char pointer arguments.
  60  * Reworked data1_read_node so that it doesn't create a tree with
  61  * pointers to original "SGML"-buffer.
  62  *
  63  * Revision 1.17  1998/02/11 11:53:34  adam
  64  * Changed code so that it compiles as C++.
  65  *
  66  * Revision 1.16  1997/12/18 10:51:30  adam
  67  * Implemented sub-trees feature for schemas - including forward
  68  * references.
  69  *
  70  * Revision 1.15  1997/12/09 16:18:16  adam
  71  * Work on EXPLAIN schema. First implementation of sub-schema facility
  72  * in the *.abs files.
  73  *
  74  * Revision 1.14  1997/10/31 12:20:09  adam
  75  * Improved memory debugging for xmalloc/nmem.c. References to NMEM
  76  * instead of ODR in n ESPEC-1 handling in source d1_espec.c.
  77  * Bug fix: missing fclose in data1_read_espec1.
  78  *
  79  * Revision 1.13  1997/10/27 13:54:18  adam
  80  * Changed structure field in data1 node to be simple string which
  81  * is "unknown" to the retrieval system itself.
  82  *
  83  * Revision 1.12  1997/09/17 12:10:34  adam
  84  * YAZ version 1.4.
  85  *
  86  * Revision 1.11  1997/09/05 09:50:55  adam
  87  * Removed global data1_tabpath - uses data1_get_tabpath() instead.
  88  *
  89  * Revision 1.10  1997/05/14 06:54:01  adam
  90  * C++ support.
  91  *
  92  * Revision 1.9  1997/02/19 14:46:15  adam
  93  * The "all" specifier only affects elements that are indexed (and not
  94  * all elements).
  95  *
  96  * Revision 1.8  1997/01/02 10:47:59  quinn
  97  * Added optional, physical ANY
  98  *
  99  * Revision 1.7  1996/06/10 08:56:01  quinn
 100  * Work on Summary.
 101  *
 102  * Revision 1.6  1996/05/31  13:52:21  quinn
 103  * Fixed uninitialized variable for local tags in abstract syntax.
 104  *
 105  * Revision 1.5  1996/05/09  07:27:43  quinn
 106  * Multiple local attributes values supported.
 107  *
 108  * Revision 1.4  1996/05/01  12:45:28  quinn
 109  * Support use of local tag names in abs file.
 110  *
 111  * Revision 1.3  1995/11/01  16:34:55  quinn
 112  * Making data1 look for tables in data1_tabpath
 113  *
 114  * Revision 1.2  1995/11/01  13:54:44  quinn
 115  * Minor adjustments
 116  *
 117  * Revision 1.1  1995/11/01  11:56:06  quinn
 118  * Added Retrieval (data management) functions en masse.
 119  *
 120  */
 121
 122 #include <stdio.h>
 123 #include <assert.h>
 124 #include <stdlib.h>
 125 #include <string.h>
 126
 127 #include <yaz/oid.h>
 128 #include <yaz/log.h>
 129 #include <yaz/data1.h>
 130
 131 #define D1_MAX_NESTING  128
 132
 133 struct data1_absyn_cache_info
 134 {
 135     char *name;
 136     data1_absyn *absyn;
 137     data1_absyn_cache next;
 138 };
 139
 140 struct data1_attset_cache_info
 141 {
 142     char *name;
 143     data1_attset *attset;
 144     data1_attset_cache next;
 145 };
 146
 147 data1_absyn *data1_absyn_search (data1_handle dh, const char *name)
 148 {
 149     data1_absyn_cache p = *data1_absyn_cache_get (dh);
 150
 151     while (p)
 152     {
 153         if (!strcmp (name, p->name))
 154             return p->absyn;
 155         p = p->next;
 156     }
 157     return NULL;
 158 }
 159
 160 void data1_absyn_trav (data1_handle dh, void *handle,
 161                        void (*fh)(data1_handle dh, void *h, data1_absyn *a))
 162 {
 163     data1_absyn_cache p = *data1_absyn_cache_get (dh);
 164
 165     while (p)
 166     {
 167         (*fh)(dh, handle, p->absyn);
 168         p = p->next;
 169     }
 170 }
 171
 172 data1_absyn *data1_absyn_add (data1_handle dh, const char *name)
 173 {
 174     char fname[512];
 175     NMEM mem = data1_nmem_get (dh);
 176
 177     data1_absyn_cache p = (data1_absyn_cache)nmem_malloc (mem, sizeof(*p));
 178     data1_absyn_cache *pp = data1_absyn_cache_get (dh);
 179
 180     sprintf(fname, "%s.abs", name);
 181     p->absyn = data1_read_absyn (dh, fname);
 182     p->name = nmem_strdup (mem, name);
 183     p->next = *pp;
 184     *pp = p;
 185     return p->absyn;
 186 }
 187
 188 data1_absyn *data1_get_absyn (data1_handle dh, const char *name)
 189 {
 190     data1_absyn *absyn;
 191
 192     if (!(absyn = data1_absyn_search (dh, name)))
 193         absyn = data1_absyn_add (dh, name);
 194     return absyn;
 195 }
 196
 197 data1_attset *data1_attset_search_name (data1_handle dh, const char *name)
 198 {
 199     data1_attset_cache p = *data1_attset_cache_get (dh);
 200
 201     while (p)
 202     {
 203         if (!strcmp (name, p->name))
 204             return p->attset;
 205         p = p->next;
 206     }
 207     return NULL;
 208 }
 209
 210 data1_attset *data1_attset_search_id (data1_handle dh, int id)
 211 {
 212     data1_attset_cache p = *data1_attset_cache_get (dh);
 213
 214     while (p)
 215     {
 216         if (id == p->attset->reference)
 217             return p->attset;
 218         p = p->next;
 219     }
 220     return NULL;
 221 }
 222
 223 data1_attset *data1_attset_add (data1_handle dh, const char *name)
 224 {
 225     char fname[512], aname[512];
 226     NMEM mem = data1_nmem_get (dh);
 227     data1_attset *attset;
 228
 229     strcpy (aname, name);
 230     sprintf(fname, "%s.att", name);
 231     attset = data1_read_attset (dh, fname);
 232     if (!attset)
 233     {
 234         char *cp;
 235         attset = data1_read_attset (dh, name);
 236         if (attset && (cp = strrchr (aname, '.')))
 237             *cp = '\0';
 238     }
 239     if (!attset)
 240         yaz_log (LOG_WARN|LOG_ERRNO, "Couldn't load attribute set %s", name);
 241     else
 242     {
 243         data1_attset_cache p = (data1_attset_cache)
 244             nmem_malloc (mem, sizeof(*p));
 245         data1_attset_cache *pp = data1_attset_cache_get (dh);
 246
 247         attset->name = p->name = nmem_strdup (mem, aname);
 248         p->attset = attset;
 249         p->next = *pp;
 250         *pp = p;
 251     }
 252     return attset;
 253 }
 254
 255 data1_attset *data1_get_attset (data1_handle dh, const char *name)
 256 {
 257     data1_attset *attset;
 258
 259     if (!(attset = data1_attset_search_name (dh, name)))
 260         attset = data1_attset_add (dh, name);
 261     return attset;
 262 }
 263
 264 data1_esetname *data1_getesetbyname(data1_handle dh, data1_absyn *a,
 265                                     const char *name)
 266 {
 267     data1_esetname *r;
 268
 269     for (r = a->esetnames; r; r = r->next)
 270         if (!data1_matchstr(r->name, name))
 271             return r;
 272     return 0;
 273 }
 274
 275 data1_element *data1_getelementbytagname (data1_handle dh, data1_absyn *abs,
 276                                           data1_element *parent,
 277                                           const char *tagname)
 278 {
 279     data1_element *r;
 280
 281     /* It's now possible to have a data1 tree with no abstract syntax */
 282     if ( !abs )
 283         return 0;
 284
 285     if (!parent)
 286         r = abs->main_elements;
 287     else
 288         r = parent->children;
 289     assert (abs->main_elements);
 290     for (; r; r = r->next)
 291     {
 292         data1_name *n;
 293
 294         for (n = r->tag->names; n; n = n->next)
 295             if (!data1_matchstr(tagname, n->name))
 296                 return r;
 297     }
 298     return 0;
 299 }
 300
 301 data1_element *data1_getelementbyname (data1_handle dh, data1_absyn *absyn,
 302                                        const char *name)
 303 {
 304     data1_element *r;
 305
 306     /* It's now possible to have a data1 tree with no abstract syntax */
 307     if ( !absyn )
 308         return 0;
 309
 310     assert (absyn->main_elements);
 311     for (r = absyn->main_elements; r; r = r->next)
 312         if (!data1_matchstr(r->name, name))
 313             return r;
 314     return 0;
 315 }
 316
 317
 318 void fix_element_ref (data1_handle dh, data1_absyn *absyn, data1_element *e)
 319 {
 320     /* It's now possible to have a data1 tree with no abstract syntax */
 321     if ( !absyn )
 322         return;
 323
 324     for (; e; e = e->next)
 325     {
 326         if (!e->sub_name)
 327         {
 328             if (e->children)
 329                 fix_element_ref (dh, absyn, e->children);
 330         }
 331         else
 332         {
 333             data1_sub_elements *sub_e = absyn->sub_elements;
 334             while (sub_e && strcmp (e->sub_name, sub_e->name))
 335                 sub_e = sub_e->next;
 336             if (sub_e)
 337                 e->children = sub_e->elements;
 338             else
 339                 yaz_log (LOG_WARN, "Unresolved reference to sub-elements %s",
 340                       e->sub_name);
 341         }
 342     }
 343 }
 344
 345
 346 static int parse_termlists (data1_handle dh, data1_termlist ***tpp,
 347                             char *p, const char *file, int lineno,
 348                             const char *element_name, data1_absyn *res)
 349 {
 350     data1_termlist **tp = *tpp;
 351     do
 352     {
 353         char attname[512], structure[512];
 354         char *source;
 355         int r;
 356
 357         if (!(r = sscanf(p, "%511[^:,]:%511[^,]", attname,
 358                          structure)))
 359         {
 360             yaz_log(LOG_WARN,
 361                     "%s:%d: Syntax error in termlistspec '%s'",
 362                     file, lineno, p);
 363             return -1;
 364 /*
 365   fclose(f);
 366   return 0;
 367 */
 368         }
 369         if (*attname == '!')
 370             strcpy(attname, element_name);
 371         *tp = (data1_termlist *)
 372             nmem_malloc(data1_nmem_get(dh), sizeof(**tp));
 373         (*tp)->next = 0;
 374         if (!((*tp)->att = data1_getattbyname(dh, res->attset,
 375                                               attname)))
 376         {
 377             yaz_log(LOG_WARN,
 378                     "%s:%d: Couldn't find att '%s' in attset",
 379                     file, lineno, attname);
 380             return -1;
 381 /*
 382             fclose(f);
 383             return 0;
 384 */
 385         }
 386         if (r == 2 && (source = strchr(structure, ':')))
 387             *source++ = '\0';   /* cut off structure .. */
 388         else
 389             source = "data";    /* ok: default is leaf data */
 390         (*tp)->source = (char *)
 391             nmem_strdup (data1_nmem_get (dh), source);
 392
 393         if (r < 2) /* is the structure qualified? */
 394             (*tp)->structure = "w";
 395         else
 396             (*tp)->structure = (char *)
 397                 nmem_strdup (data1_nmem_get (dh), structure);
 398         tp = &(*tp)->next;
 399     }
 400     while ((p = strchr(p, ',')) && *(++p));
 401     *tpp = tp;
 402     return 0;
 403 }
 404
 405 data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 406 {
 407     data1_sub_elements *cur_elements = NULL;
 408     data1_absyn *res = 0;
 409     FILE *f;
 410     data1_element **ppl[D1_MAX_NESTING];
 411     data1_esetname **esetpp;
 412     data1_maptab **maptabp;
 413     data1_marctab **marcp;
 414     data1_termlist *all = 0;
 415     data1_attset_child **attset_childp;
 416     data1_tagset **tagset_childp;
 417     int level = 0;
 418     int lineno = 0;
 419     int argc;
 420     char *argv[50], line[512];
 421
 422     if (!(f = data1_path_fopen(dh, file, "r")))
 423     {
 424         yaz_log(LOG_WARN|LOG_ERRNO, "Couldn't open %s", file);
 425         return 0;
 426     }
 427
 428     res = (data1_absyn *) nmem_malloc(data1_nmem_get(dh), sizeof(*res));
 429     res->name = 0;
 430     res->reference = VAL_NONE;
 431     res->tagset = 0;
 432     tagset_childp = &res->tagset;
 433
 434     res->attset = data1_empty_attset (dh);
 435     attset_childp =  &res->attset->children;
 436
 437     res->varset = 0;
 438     res->esetnames = 0;
 439     esetpp = &res->esetnames;
 440     res->maptabs = 0;
 441     maptabp = &res->maptabs;
 442     res->marc = 0;
 443     marcp = &res->marc;
 444
 445     res->sub_elements = NULL;
 446     res->main_elements = NULL;
 447
 448     while ((argc = readconf_line(f, &lineno, line, 512, argv, 50)))
 449     {
 450         char *cmd = *argv;
 451         if (!strcmp(cmd, "elm"))
 452         {
 453             data1_element *new_element;
 454             int i;
 455             char *p, *sub_p, *path, *name, *termlists;
 456             int type, value;
 457             data1_termlist **tp;
 458
 459             if (argc < 4)
 460             {
 461                 yaz_log(LOG_WARN, "%s:%d: Bad # of args to elm", file, lineno);
 462                 continue;
 463             }
 464             path = argv[1];
 465             name = argv[2];
 466             termlists = argv[3];
 467
 468             if (!cur_elements)
 469             {
 470                 cur_elements = (data1_sub_elements *)
 471                     nmem_malloc(data1_nmem_get(dh), sizeof(*cur_elements));
 472                 cur_elements->next = res->sub_elements;
 473                 cur_elements->elements = NULL;
 474                 cur_elements->name = "main";
 475                 res->sub_elements = cur_elements;
 476
 477                 level = 0;
 478                 ppl[level] = &cur_elements->elements;
 479             }
 480             p = path;
 481             for (i = 1;; i++)
 482             {
 483                 char *e;
 484
 485                 if ((e = strchr(p, '/')))
 486                     p = e+1;
 487                 else
 488                     break;
 489             }
 490             if (i > level+1)
 491             {
 492                 yaz_log(LOG_WARN, "%s:%d: Bad level increase", file, lineno);
 493                 fclose(f);
 494                 return 0;
 495             }
 496             level = i;
 497             new_element = *ppl[level-1] = (data1_element *)
 498                 nmem_malloc(data1_nmem_get(dh), sizeof(*new_element));
 499             new_element->next = new_element->children = 0;
 500             new_element->tag = 0;
 501             new_element->termlists = 0;
 502             new_element->sub_name = 0;
 503
 504             tp = &new_element->termlists;
 505             ppl[level-1] = &new_element->next;
 506             ppl[level] = &new_element->children;
 507
 508             /* consider subtree (if any) ... */
 509             if ((sub_p = strchr (p, ':')) && sub_p[1])
 510             {
 511                 *sub_p++ = '\0';
 512                 new_element->sub_name =
 513                     nmem_strdup (data1_nmem_get(dh), sub_p);
 514             }
 515             /* well-defined tag */
 516             if (sscanf(p, "(%d,%d)", &type, &value) == 2)
 517             {
 518                 if (!res->tagset)
 519                 {
 520                     yaz_log(LOG_WARN, "%s:%d: No tagset loaded", file, lineno);
 521                     fclose(f);
 522                     return 0;
 523                 }
 524                 if (!(new_element->tag = data1_gettagbynum (dh, res->tagset,
 525                                                             type, value)))
 526                 {
 527                     yaz_log(LOG_WARN, "%s:%d: Couldn't find tag %s in tagset",
 528                          file, lineno, p);
 529                     fclose(f);
 530                     return 0;
 531                 }
 532             }
 533             /* private tag */
 534             else if (*p)
 535             {
 536                 data1_tag *nt =
 537                     new_element->tag = (data1_tag *)
 538                     nmem_malloc(data1_nmem_get (dh),
 539                                 sizeof(*new_element->tag));
 540                 nt->which = DATA1T_string;
 541                 nt->value.string = nmem_strdup(data1_nmem_get (dh), p);
 542                 nt->names = (data1_name *)
 543                     nmem_malloc(data1_nmem_get(dh),
 544                                 sizeof(*new_element->tag->names));
 545                 nt->names->name = nt->value.string;
 546                 nt->names->next = 0;
 547                 nt->kind = DATA1K_string;
 548                 nt->next = 0;
 549                 nt->tagset = 0;
 550             }
 551             else
 552             {
 553                 yaz_log(LOG_WARN, "%s:%d: Bad element", file, lineno);
 554                 fclose(f);
 555                 return 0;
 556             }
 557             /* parse termList definitions */
 558             p = termlists;
 559             if (*p != '-')
 560             {
 561                 assert (res->attset);
 562
 563                 if (parse_termlists (dh, &tp, p, file, lineno, name, res))
 564                 {
 565                     fclose (f);
 566                     return 0;
 567                 }
 568                 *tp = all; /* append any ALL entries to the list */
 569             }
 570             new_element->name = nmem_strdup(data1_nmem_get (dh), name);
 571         }
 572         else if (!strcmp(cmd, "section"))
 573         {
 574             char *name;
 575
 576             if (argc < 2)
 577             {
 578                 yaz_log(LOG_WARN, "%s:%d: Bad # of args to section",
 579                      file, lineno);
 580                 continue;
 581             }
 582             name = argv[1];
 583
 584             cur_elements = (data1_sub_elements *)
 585                 nmem_malloc(data1_nmem_get(dh), sizeof(*cur_elements));
 586             cur_elements->next = res->sub_elements;
 587             cur_elements->elements = NULL;
 588             cur_elements->name = nmem_strdup (data1_nmem_get(dh), name);
 589             res->sub_elements = cur_elements;
 590
 591             level = 0;
 592             ppl[level] = &cur_elements->elements;
 593         }
 594         else if (!strcmp(cmd, "all"))
 595         {
 596             data1_termlist **tp = &all;
 597             if (all)
 598             {
 599                 yaz_log(LOG_WARN, "%s:%d: Too many 'all' directives - ignored",
 600                      file, lineno);
 601                 continue;
 602             }
 603             if (argc != 2)
 604             {
 605                 yaz_log(LOG_WARN, "%s:%d: Bad # of args to 'all' directive",
 606                      file, lineno);
 607                 continue;
 608             }
 609             if (parse_termlists (dh, &tp, argv[1], file, lineno, 0, res))
 610             {
 611                 fclose (f);
 612                 return 0;
 613             }
 614         }
 615         else if (!strcmp(cmd, "name"))
 616         {
 617             if (argc != 2)
 618             {
 619                 yaz_log(LOG_WARN, "%s:%d: Bad # of args to name directive",
 620                      file, lineno);
 621                 continue;
 622             }
 623             res->name = nmem_strdup(data1_nmem_get(dh), argv[1]);
 624         }
 625         else if (!strcmp(cmd, "reference"))
 626         {
 627             char *name;
 628
 629             if (argc != 2)
 630             {
 631                 yaz_log(LOG_WARN, "%s:%d: Bad # of args to reference",
 632                      file, lineno);
 633                 continue;
 634             }
 635             name = argv[1];
 636             if ((res->reference = oid_getvalbyname(name)) == VAL_NONE)
 637             {
 638                 yaz_log(LOG_WARN, "%s:%d: Unknown tagset ref '%s'",
 639                      file, lineno, name);
 640                 continue;
 641             }
 642         }
 643         else if (!strcmp(cmd, "attset"))
 644         {
 645             char *name;
 646             data1_attset *attset;
 647
 648             if (argc != 2)
 649             {
 650                 yaz_log(LOG_WARN, "%s:%d: Bad # of args to attset",
 651                      file, lineno);
 652                 continue;
 653             }
 654             name = argv[1];
 655             if (!(attset = data1_get_attset (dh, name)))
 656             {
 657                 yaz_log(LOG_WARN, "%s:%d: Couldn't find attset  %s",
 658                      file, lineno, name);
 659                 continue;
 660             }
 661             *attset_childp = (data1_attset_child *)
 662                 nmem_malloc (data1_nmem_get(dh), sizeof(**attset_childp));
 663             (*attset_childp)->child = attset;
 664             (*attset_childp)->next = 0;
 665             attset_childp = &(*attset_childp)->next;
 666         }
 667         else if (!strcmp(cmd, "tagset"))
 668         {
 669             char *name;
 670             int type = 0;
 671             if (argc < 2)
 672             {
 673                 yaz_log(LOG_WARN, "%s:%d: Bad # of args to tagset",
 674                      file, lineno);
 675                 continue;
 676             }
 677             name = argv[1];
 678             if (argc == 3)
 679                 type = atoi(argv[2]);
 680             *tagset_childp = data1_read_tagset (dh, name, type);
 681             if (!(*tagset_childp))
 682             {
 683                 yaz_log(LOG_WARN, "%s:%d: Couldn't load tagset %s",
 684                      file, lineno, name);
 685                 continue;
 686             }
 687             tagset_childp = &(*tagset_childp)->next;
 688         }
 689         else if (!strcmp(cmd, "varset"))
 690         {
 691             char *name;
 692
 693             if (argc != 2)
 694             {
 695                 yaz_log(LOG_WARN, "%s:%d: Bad # of args in varset",
 696                      file, lineno);
 697                 continue;
 698             }
 699             name = argv[1];
 700             if (!(res->varset = data1_read_varset (dh, name)))
 701             {
 702                 yaz_log(LOG_WARN, "%s:%d: Couldn't load Varset %s",
 703                      file, lineno, name);
 704                 continue;
 705             }
 706         }
 707         else if (!strcmp(cmd, "esetname"))
 708         {
 709             char *name, *fname;
 710
 711             if (argc != 3)
 712             {
 713                 yaz_log(LOG_WARN, "%s:%d: Bad # of args in esetname",
 714                      file, lineno);
 715                 continue;
 716             }
 717             name = argv[1];
 718             fname = argv[2];
 719
 720             *esetpp = (data1_esetname *)
 721                 nmem_malloc(data1_nmem_get(dh), sizeof(**esetpp));
 722             (*esetpp)->name = nmem_strdup(data1_nmem_get(dh), name);
 723             (*esetpp)->next = 0;
 724             if (*fname == '@')
 725                 (*esetpp)->spec = 0;
 726             else if (!((*esetpp)->spec = data1_read_espec1 (dh, fname)))
 727             {
 728                 yaz_log(LOG_WARN, "%s:%d: Espec-1 read failed for %s",
 729                      file, lineno, fname);
 730                 continue;
 731             }
 732             esetpp = &(*esetpp)->next;
 733         }
 734         else if (!strcmp(cmd, "maptab"))
 735         {
 736             char *name;
 737
 738             if (argc != 2)
 739             {
 740                 yaz_log(LOG_WARN, "%s:%d: Bad # of args for maptab",
 741                      file, lineno);
 742                 continue;
 743             }
 744             name = argv[1];
 745             if (!(*maptabp = data1_read_maptab (dh, name)))
 746             {
 747                 yaz_log(LOG_WARN, "%s:%d: Couldn't load maptab %s",
 748                      file, lineno, name);
 749                 continue;
 750             }
 751             maptabp = &(*maptabp)->next;
 752         }
 753         else if (!strcmp(cmd, "marc"))
 754         {
 755             char *name;
 756
 757             if (argc != 2)
 758             {
 759                 yaz_log(LOG_WARN, "%s:%d: Bad # or args for marc",
 760                      file, lineno);
 761                 continue;
 762             }
 763             name = argv[1];
 764             if (!(*marcp = data1_read_marctab (dh, name)))
 765             {
 766                 yaz_log(LOG_WARN, "%s:%d: Couldn't read marctab %s",
 767                      file, lineno, name);
 768                 continue;
 769             }
 770             marcp = &(*marcp)->next;
 771         }
 772         else
 773         {
 774             yaz_log(LOG_WARN, "%s:%d: Unknown directive '%s'", file, lineno, cmd);
 775             continue;
 776         }
 777     }
 778     fclose(f);
 779
 780     for (cur_elements = res->sub_elements; cur_elements;
 781          cur_elements = cur_elements->next)
 782     {
 783         if (!strcmp (cur_elements->name, "main"))
 784             res->main_elements = cur_elements->elements;
 785         fix_element_ref (dh, res, cur_elements->elements);
 786     }
 787     yaz_log (LOG_DEBUG, "%s: data1_read_absyn end", file);
 788     return res;
 789 }