retrieval/d1_marc.c

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