retrieval/d1_absyn.c

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