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