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