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