retrieval/d1_attset.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_attset.c,v $
   7  * Revision 1.9  1998-05-18 13:07:03  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.8  1998/02/11 11:53:35  adam
  13  * Changed code so that it compiles as C++.
  14  *
  15  * Revision 1.7  1997/09/17 12:10:34  adam
  16  * YAZ version 1.4.
  17  *
  18  * Revision 1.6  1997/09/05 09:50:56  adam
  19  * Removed global data1_tabpath - uses data1_get_tabpath() instead.
  20  *
  21  * Revision 1.5  1996/05/09 07:27:43  quinn
  22  * Multiple local attributes values supported.
  23  *
  24  * Revision 1.4  1996/02/21  15:23:36  quinn
  25  * Reversed fclose and return;
  26  *
  27  * Revision 1.3  1995/12/13  17:14:26  quinn
  28  * *** empty log message ***
  29  *
  30  * Revision 1.2  1995/11/01  16:34:55  quinn
  31  * Making data1 look for tables in data1_tabpath
  32  *
  33  * Revision 1.1  1995/11/01  11:56:07  quinn
  34  * Added Retrieval (data management) functions en masse.
  35  *
  36  *
  37  */
  38
  39 #include <ctype.h>
  40 #include <stdio.h>
  41 #include <assert.h>
  42 #include <stdlib.h>
  43
  44 #include <log.h>
  45 #include <d1_attset.h>
  46 #include <data1.h>
  47 #include <tpath.h>
  48
  49 data1_att *data1_getattbyname(data1_handle dh, data1_attset *s, char *name)
  50 {
  51     data1_att *r;
  52     data1_attset_child *c;
  53
  54     /* scan local set */
  55     for (r = s->atts; r; r = r->next)
  56         if (!data1_matchstr(r->name, name))
  57             return r;
  58     for (c = s->children; c; c = c->next)
  59     {
  60         assert (c->child);
  61         /* scan included sets */
  62         if ((r = data1_getattbyname (dh, c->child, name)))
  63             return r;
  64     }
  65     return 0;
  66 }
  67
  68 data1_attset *data1_read_attset(data1_handle dh, const char *file)
  69 {
  70     char line[512], *r, cmd[512], args[512];
  71     data1_attset *res = 0;
  72     data1_attset_child **childp;
  73     data1_att **attp;
  74     FILE *f;
  75     NMEM mem = data1_nmem_get (dh);
  76
  77     if (!(f = yaz_path_fopen(data1_get_tabpath(dh), file, "r")))
  78         return NULL;
  79     res = (data1_attset *)nmem_malloc(mem, sizeof(*res));
  80     res->name = 0;
  81     res->reference = VAL_NONE;
  82     res->atts = 0;
  83     res->children = 0;
  84     childp = &res->children;
  85     attp = &res->atts;
  86
  87     for (;;)
  88     {
  89         while ((r = fgets(line, 512, f)))
  90         {
  91             while (*r && isspace(*r))
  92                 r++;
  93             if (*r && *r != '#')
  94                 break;
  95         }
  96         if (!r)
  97         {
  98             fclose(f);
  99             return res;
 100         }
 101         if (sscanf(r, "%s %[^\n]", cmd, args) < 2)
 102             *args = '\0';
 103         if (!strcmp(cmd, "att"))
 104         {
 105             int num, rr;
 106             char name[512], localstr[512];
 107             data1_att *t;
 108             data1_local_attribute *locals;
 109
 110             if ((rr = sscanf(args, "%511d %s %511s", &num, name, localstr)) < 2)
 111             {
 112                 logf(LOG_WARN, "Not enough arguments to att in '%s' in %s",
 113                     args, file);
 114                 fclose(f);
 115                 return 0;
 116             }
 117             if (rr < 3) /* no local attributes given */
 118             {
 119                 locals = (data1_local_attribute *)nmem_malloc(mem, sizeof(*locals));
 120                 locals->local = num;
 121                 locals->next = 0;
 122             }
 123             else /* parse the string "local{,local}" */
 124             {
 125                 char *p = localstr;
 126                 data1_local_attribute **ap = &locals;
 127                 do
 128                 {
 129                     *ap = (data1_local_attribute *)nmem_malloc(mem, sizeof(**ap));
 130                     (*ap)->local = atoi(p);
 131                     (*ap)->next = 0;
 132                     ap = &(*ap)->next;
 133                 }
 134                 while ((p = strchr(p, ',')) && *(++p));
 135             }
 136             t = *attp = (data1_att *)nmem_malloc(mem, sizeof(*t));
 137             t->parent = res;
 138             t->name = nmem_strdup(mem, name);
 139             t->value = num;
 140             t->locals = locals;
 141             t->next = 0;
 142             attp = &t->next;
 143         }
 144         else if (!strcmp(cmd, "name"))
 145         {
 146             char name[512];
 147
 148             if (!sscanf(args, "%s", name))
 149             {
 150                 logf(LOG_WARN, "%s malformed name directive in %s", file);
 151                 fclose(f);
 152                 return 0;
 153             }
 154         }
 155         else if (!strcmp(cmd, "reference"))
 156         {
 157             char name[512];
 158
 159             if (!sscanf(args, "%s", name))
 160             {
 161                 logf(LOG_WARN, "%s malformed reference directive in %s", file);
 162                 fclose(f);
 163                 return 0;
 164             }
 165             if ((res->reference = oid_getvalbyname(name)) == VAL_NONE)
 166             {
 167                 logf(LOG_WARN, "Unknown attset name '%s' in %s", name, file);
 168                 fclose(f);
 169                 return 0;
 170             }
 171         }
 172         else if (!strcmp(cmd, "ordinal"))
 173         {
 174             int dummy;
 175             if (!sscanf(args, "%d", &dummy))
 176             {
 177                 logf(LOG_WARN, "%s malformed ordinal directive in %s", file);
 178                 fclose(f);
 179                 return 0;
 180             }
 181         }
 182         else if (!strcmp(cmd, "include"))
 183         {
 184             char name[512];
 185
 186             if (!sscanf(args, "%s", name))
 187             {
 188                 logf(LOG_WARN, "%s malformed reference directive in %s", file);
 189                 fclose(f);
 190                 return 0;
 191             }
 192             *childp = (data1_attset_child *)
 193                 nmem_malloc (mem, sizeof(**childp));
 194             if (!((*childp)->child = data1_get_attset (dh, name)))
 195             {
 196                 logf(LOG_WARN, "Inclusion failed in %s", file);
 197                 fclose(f);
 198                 return 0;
 199             }
 200             (*childp)->next = 0;
 201             childp = &(*childp)->next;
 202         }
 203         else
 204         {
 205             logf(LOG_WARN, "Unknown directive '%s' in %s", cmd, file);
 206             fclose(f);
 207             return 0;
 208         }
 209     }
 210 }