retrieval/d1_marc.c

   1 /*
   2  * Copyright (c) 1995-1997, Index Data.
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: d1_marc.c,v $
   7  * Revision 1.7  1997-09-05 09:50:57  adam
   8  * Removed global data1_tabpath - uses data1_get_tabpath() instead.
   9  *
  10  * Revision 1.6  1997/09/04 13:51:58  adam
  11  * Added data1 to marc conversion with indicators.
  12  *
  13  * Revision 1.5  1997/09/04 13:48:04  adam
  14  * Added data1 to marc conversion.
  15  *
  16  * Revision 1.4  1996/03/25 10:18:03  quinn
  17  * Removed trailing whitespace from data elements
  18  *
  19  * Revision 1.3  1995/11/01  16:34:57  quinn
  20  * Making data1 look for tables in data1_tabpath
  21  *
  22  * Revision 1.2  1995/11/01  13:54:48  quinn
  23  * Minor adjustments
  24  *
  25  * Revision 1.1  1995/11/01  11:56:08  quinn
  26  * Added Retrieval (data management) functions en masse.
  27  *
  28  *
  29  */
  30
  31
  32 #include <assert.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <ctype.h>
  36
  37 #include <oid.h>
  38 #include <log.h>
  39 #include <marcdisp.h>
  40 #include <readconf.h>
  41 #include <xmalloc.h>
  42 #include <data1.h>
  43 #include <tpath.h>
  44
  45 data1_marctab *data1_read_marctab(char *file)
  46 {
  47     FILE *f;
  48     data1_marctab *res = xmalloc(sizeof(*res));
  49     char line[512], *argv[50];
  50     int argc;
  51
  52     if (!(f = yaz_path_fopen(data1_get_tabpath(), file, "r")))
  53     {
  54         logf(LOG_WARN|LOG_ERRNO, "%s", file);
  55         return 0;
  56     }
  57
  58     res->name = 0;
  59     res->reference = VAL_NONE;
  60     res->next = 0;
  61     res->length_data_entry = 4;
  62     res->length_starting = 5;
  63     res->length_implementation = 0;
  64     strcpy(res->future_use, "4");
  65
  66     strcpy(res->record_status, "n");
  67     strcpy(res->implementation_codes, "    ");
  68     res->indicator_length = 2;
  69     res->identifier_length = 2;
  70     strcpy(res->user_systems, "z  ");
  71
  72     while ((argc = readconf_line(f, line, 512, argv, 50)))
  73         if (!strcmp(argv[0], "name"))
  74         {
  75             if (argc != 2)
  76             {
  77                 logf(LOG_WARN, "%s: Bad name directive");
  78                 continue;
  79             }
  80             res->name = xmalloc(strlen(argv[1])+1);
  81             strcpy(res->name, argv[1]);
  82         }
  83         else if (!strcmp(argv[0], "reference"))
  84         {
  85             if (argc != 2)
  86             {
  87                 logf(LOG_WARN, "%s: Bad name directive");
  88                 continue;
  89             }
  90             if ((res->reference = oid_getvalbyname(argv[1])) == VAL_NONE)
  91             {
  92                 logf(LOG_WARN, "%s: Unknown tagset ref '%s' in %s", file,
  93                     argv[1]);
  94                 continue;
  95             }
  96         }
  97         else if (!strcmp(argv[0], "length-data-entry"))
  98         {
  99             if (argc != 2)
 100             {
 101                 logf(LOG_WARN, "%s: Bad data-length-entry");
 102                 continue;
 103             }
 104             res->length_data_entry = atoi(argv[1]);
 105         }
 106         else if (!strcmp(argv[0], "length-starting"))
 107         {
 108             if (argc != 2)
 109             {
 110                 logf(LOG_WARN, "%s: Bad length-starting");
 111                 continue;
 112             }
 113             res->length_starting = atoi(argv[1]);
 114         }
 115         else if (!strcmp(argv[0], "length-implementation"))
 116         {
 117             if (argc != 2)
 118             {
 119                 logf(LOG_WARN, "%s: Bad length-implentation");
 120                 continue;
 121             }
 122             res->length_implementation = atoi(argv[1]);
 123         }
 124         else if (!strcmp(argv[0], "future-use"))
 125         {
 126             if (argc != 2)
 127             {
 128                 logf(LOG_WARN, "%s: Bad future-use");
 129                 continue;
 130             }
 131             strncpy(res->future_use, argv[1], 2);
 132         }
 133         else
 134             logf(LOG_WARN, "%s: Bad directive '%s'", file, argv[0]);
 135
 136     fclose(f);
 137     return res;
 138 }
 139
 140 /*
 141  * Locate some data under this node. This routine should handle variants
 142  * prettily.
 143  */
 144 static char *get_data(data1_node *n, int *len)
 145 {
 146     char *r;
 147
 148     while (n->which != DATA1N_data && n->child)
 149         n = n->child;
 150     if (n->which != DATA1N_data || n->u.data.what != DATA1I_text)
 151     {
 152         r = "[Structured/included data]";
 153         *len = strlen(r);
 154         return r;
 155     }
 156
 157     *len = n->u.data.len;
 158     while (*len && isspace(n->u.data.data[*len - 1]))
 159         (*len)--;
 160     return n->u.data.data;
 161 }
 162
 163 static void memint (char *p, int val, int len)
 164 {
 165     static char buf[9];
 166
 167     if (len == 1)
 168         *p = val + '0';
 169     else
 170     {
 171         sprintf (buf, "%08d", val);
 172         memcpy (p, buf+8-len, len);
 173     }
 174 }
 175
 176 static int is_indicator (data1_marctab *p, data1_node *subf)
 177 {
 178 #if 1
 179     if (p->indicator_length != 2 ||
 180         (subf->which == DATA1N_tag && strlen(subf->u.tag.tag) == 2))
 181         return 1;
 182 #else
 183     if (subf->which == DATA1N_tag && subf->child->which == DATA1N_tag)
 184         return 1;
 185 #endif
 186     return 0;
 187 }
 188
 189 static int nodetomarc(data1_marctab *p, data1_node *n, int selected,
 190     char **buf, int *size)
 191 {
 192     int len = 26;
 193     int dlen;
 194     int base_address = 25;
 195     int entry_p, data_p;
 196     char *op;
 197     data1_node *field, *subf;
 198
 199     for (field = n->child; field; field = field->next)
 200     {
 201         if (field->which != DATA1N_tag)
 202         {
 203             logf(LOG_WARN, "Malformed field composition for marc output.");
 204             return -1;
 205         }
 206         if (selected && !field->u.tag.node_selected)
 207             continue;
 208         len += 4 + p->length_data_entry + p->length_starting
 209             + p->length_implementation;
 210         base_address += 3 + p->length_data_entry + p->length_starting
 211             + p->length_implementation;
 212         if (strncmp(field->u.tag.tag, "00", 2))
 213             len += p->indicator_length;      /* this is fairly bogus */
 214         subf = field->child;
 215
 216         /*  we'll allow no indicator if length is not 2 */
 217         if (is_indicator (p, subf))
 218             subf = subf->child;
 219
 220         for (; subf; subf = subf->next)
 221         {
 222             if (subf->which != DATA1N_tag)
 223             {
 224                 logf(LOG_WARN,
 225                     "Malformed subfield composition for marc output.");
 226                 return -1;
 227             }
 228             if (strncmp(field->u.tag.tag, "00", 2))
 229                 len += p->identifier_length;
 230             get_data(subf, &dlen);
 231             len += dlen;
 232         }
 233     }
 234
 235     if (!*buf)
 236         *buf = xmalloc(*size = len);
 237     else if (*size <= len)
 238         *buf = xrealloc(*buf, *size = len);
 239
 240     op = *buf;
 241     memint (op, len, 5);
 242     memcpy (op+5, p->record_status, 1);
 243     memcpy (op+6, p->implementation_codes, 4);
 244     memint (op+10, p->indicator_length, 1);
 245     memint (op+11, p->identifier_length, 1);
 246     memint (op+12, base_address, 5);
 247     memcpy (op+17, p->user_systems, 3);
 248     memint (op+20, p->length_data_entry, 1);
 249     memint (op+21, p->length_starting, 1);
 250     memint (op+22, p->length_implementation, 1);
 251     memcpy (op+23, p->future_use, 1);
 252
 253     entry_p = 24;
 254     data_p = base_address;
 255
 256     for (field = n->child; field; field = field->next)
 257     {
 258         int data_0 = data_p;
 259         char *indicator_data = "    ";
 260         if (selected && !field->u.tag.node_selected)
 261             continue;
 262
 263         subf = field->child;
 264
 265         if (is_indicator (p, subf))
 266         {
 267             indicator_data = subf->u.tag.tag;
 268             subf = subf->child;
 269         }
 270         if (strncmp(field->u.tag.tag, "00", 2))   /* bogus */
 271         {
 272             memcpy (op + data_p, indicator_data, p->indicator_length);
 273             data_p += p->indicator_length;
 274         }
 275         for (; subf; subf = subf->next)
 276         {
 277             char *data;
 278
 279             if (strncmp(field->u.tag.tag, "00", 2))
 280             {
 281                 op[data_p] = ISO2709_IDFS;
 282                 memcpy (op + data_p+1, subf->u.tag.tag, p->identifier_length-1);
 283                 data_p += p->identifier_length;
 284             }
 285             data = get_data(subf, &dlen);
 286             memcpy (op + data_p, data, dlen);
 287             data_p += dlen;
 288         }
 289         op[data_p++] = ISO2709_FS;
 290
 291         memcpy (op + entry_p, field->u.tag.tag, 3);
 292         entry_p += 3;
 293         memint (op + entry_p, data_p - data_0, p->length_data_entry);
 294         entry_p += p->length_data_entry;
 295         memint (op + entry_p, data_0 - base_address, p->length_starting);
 296         entry_p += p->length_starting;
 297         entry_p += p->length_implementation;
 298     }
 299     op[entry_p++] = ISO2709_FS;
 300     assert (entry_p == base_address);
 301     op[data_p++] = ISO2709_RS;
 302     assert (data_p == len);
 303     return len;
 304 }
 305
 306 char *data1_nodetomarc(data1_marctab *p, data1_node *n, int selected, int *len)
 307 {
 308     static char *buf = 0;
 309     static int size = 0;
 310
 311     *len = nodetomarc(p, n, selected, &buf, &size);
 312     return buf;
 313 }