include/data1.h

   1 /*
   2  * Copyright (C) 1994, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: data1.h,v $
   7  * Revision 1.1  1995-11-01 13:07:18  quinn
   8  * Data1 module now lives in YAZ.
   9  *
  10  * Revision 1.13  1995/10/25  16:00:49  quinn
  11  * USMARC support is now almost operational
  12  *
  13  * Revision 1.12  1995/10/16  14:02:59  quinn
  14  * Changes to support element set names and espec1
  15  *
  16  * Revision 1.11  1995/10/13  16:05:10  quinn
  17  * Adding Espec1-processing
  18  *
  19  * Revision 1.10  1995/10/11  14:53:46  quinn
  20  * Work on variants.
  21  *
  22  * Revision 1.9  1995/10/10  16:27:59  quinn
  23  * *** empty log message ***
  24  *
  25  * Revision 1.8  1995/10/06  16:44:14  quinn
  26  * Work on attribute set mapping, etc.
  27  *
  28  * Revision 1.7  1995/10/06  12:58:36  quinn
  29  * SUTRS support
  30  *
  31  * Revision 1.6  1995/10/04  09:29:51  quinn
  32  * Adjustments to support USGS test data
  33  *
  34  * Revision 1.5  1995/10/03  17:56:44  quinn
  35  * Fixing GRS code.
  36  *
  37  * Revision 1.4  1995/10/02  14:55:43  quinn
  38  * *** empty log message ***
  39  *
  40  * Revision 1.3  1995/09/15  14:41:43  quinn
  41  * GRS1 work
  42  *
  43  * Revision 1.2  1995/09/14  15:18:14  quinn
  44  * Work
  45  *
  46  * Revision 1.1  1995/09/12  11:24:33  quinn
  47  * Beginning to add code for structured records.
  48  *
  49  *
  50  */
  51
  52 #ifndef DATA1_H
  53 #define DATA1_H
  54
  55 #include <stdio.h>
  56
  57 #include <oid.h>
  58 #include <proto.h>
  59
  60 #include <d1_attset.h>
  61 #include "d1_map.h"
  62
  63 #define DATA1_MAX_SYMBOL 31
  64
  65 typedef struct data1_name
  66 {
  67     char *name;
  68     struct data1_name *next;
  69 } data1_name;
  70
  71 typedef enum data1_datatype
  72 {
  73     DATA1K_structured = 1,
  74     DATA1K_string,
  75     DATA1K_numeric,
  76     DATA1K_bool,
  77     DATA1K_oid,
  78     DATA1K_generalizedtime,
  79     DATA1K_intunit,
  80     DATA1K_int,
  81     DATA1K_octetstring,
  82     DATA1K_null
  83 } data1_datatype;
  84
  85 typedef struct data1_marctab
  86 {
  87     char *name;
  88     oid_value reference;
  89
  90     char record_status[2];
  91     char implementation_codes[5];
  92     int  indicator_length;
  93     int  identifier_length;
  94     char user_systems[4];
  95
  96     int  length_data_entry;
  97     int  length_starting;
  98     int  length_implementation;
  99     char future_use[2];
 100
 101     struct data1_marctab *next;
 102 } data1_marctab;
 103
 104 typedef struct data1_esetname
 105 {
 106     char *name;
 107     Z_Espec1 *spec;
 108     struct data1_esetname *next;
 109 } data1_esetname;
 110
 111 /*
 112  * Variant set definitions.
 113  */
 114
 115 typedef struct data1_vartype
 116 {
 117     char *name;
 118     struct data1_varclass *class;
 119     int type;
 120     data1_datatype datatype;
 121     struct data1_vartype *next;
 122 } data1_vartype;
 123
 124 typedef struct data1_varclass
 125 {
 126     char *name;
 127     struct data1_varset *set;
 128     int class;
 129     data1_vartype *types;
 130     struct data1_varclass *next;
 131 } data1_varclass;
 132
 133 typedef struct data1_varset
 134 {
 135     char *name;
 136     oid_value reference;
 137     data1_varclass *classes;
 138 } data1_varset;
 139
 140 /*
 141  * Tagset definitions
 142  */
 143
 144 struct data1_tagset;
 145
 146 typedef struct data1_tag
 147 {
 148     data1_name *names;
 149     enum
 150     {
 151         DATA1T_numeric,
 152         DATA1T_string
 153     } which;
 154     union
 155     {
 156         int numeric;
 157         char *string;
 158     } value;
 159     data1_datatype kind;
 160
 161     struct data1_tagset *tagset;
 162     struct data1_tag *next;
 163 } data1_tag;
 164
 165 typedef struct data1_tagset
 166 {
 167     char *name;                      /* symbolic name */
 168     oid_value reference;
 169     int type;                        /* type of tagset in current context */
 170     data1_tag *tags;                 /* tags defined by this set */
 171     struct data1_tagset *children;   /* included tagsets */
 172     struct data1_tagset *next;       /* sibling */
 173 } data1_tagset;
 174
 175 /*
 176  * abstract syntax specification
 177  */
 178
 179 typedef struct data1_element
 180 {
 181     char *name;
 182     data1_tag *tag;
 183     data1_att *att;
 184     struct data1_element *children;
 185     struct data1_element *next;
 186 } data1_element;
 187
 188 typedef struct data1_absyn
 189 {
 190     char *name;
 191     oid_value reference;
 192     data1_tagset *tagset;
 193     data1_attset *attset;
 194     data1_varset *varset;
 195     data1_esetname *esetnames;
 196     data1_maptab *maptabs;
 197     data1_marctab *marc;
 198     data1_element *elements;
 199 } data1_absyn;
 200
 201 /*
 202  * record data node (tag/data/variant)
 203  */
 204
 205 typedef struct data1_node
 206 {
 207     enum
 208     {
 209         DATA1N_root,
 210         DATA1N_tag,         /* a tag */
 211         DATA1N_data,        /* */
 212         DATA1N_variant,     /* variant specification */
 213         DATA1N_indicator    /* ISO2709 indicator */
 214     } which;
 215
 216     union
 217     {
 218         struct
 219         {
 220             char *type;
 221             data1_absyn *absyn;  /* abstract syntax for this type */
 222         } root;
 223
 224         struct
 225         {
 226             char *tag;
 227             data1_element *element;
 228             int node_selected;
 229         } tag;
 230
 231         struct
 232         {
 233             enum
 234             {
 235                 DATA1I_inctxt,      /* text inclusion */
 236                 DATA1I_incbin,      /* binary data inclusion */
 237                 DATA1I_text,        /* text data */
 238                 DATA1I_num          /* numerical data */
 239             } what;
 240             int len;
 241             char *data;      /* filename or data */
 242 #define DATA1_LOCALDATA 15
 243             char lbuf[DATA1_LOCALDATA]; /* small buffer for local data */
 244         } data;
 245
 246         struct
 247         {
 248             data1_vartype *type;
 249             char *value;
 250         } variant;
 251
 252         struct
 253         {
 254             char *ind;
 255         } indicator;
 256     } u;
 257
 258     int line;
 259     int num_children;
 260     struct data1_node *next;
 261     struct data1_node *child;
 262     struct data1_node *parent;
 263     struct data1_node *root;
 264 } data1_node;
 265
 266 data1_node *get_parent_tag(data1_node *n);
 267 data1_node *data1_read_node(char **buf, data1_node *parent, int *line,
 268     data1_absyn *absyn);
 269 data1_node *data1_read_record(int (*rf)(int, char *, size_t), int fd);
 270 data1_absyn *data1_read_absyn(char *file);
 271 data1_tag *data1_gettagbynum(data1_tagset *s, int type, int value);
 272 data1_tagset *data1_read_tagset(char *file);
 273 data1_element *data1_getelementbytagname(data1_absyn *abs,
 274     data1_element *parent, char *tagname);
 275 Z_GenericRecord *data1_nodetogr(data1_node *n, int select, ODR o);
 276 int data1_matchstr(char *s1, char *s2);
 277 data1_tag *data1_gettagbyname(data1_tagset *s, char *name);
 278 void data1_free_tree(data1_node *t);
 279 char *data1_nodetobuf(data1_node *n, int select, int *len);
 280 data1_node *data1_insert_taggeddata(data1_node *root, data1_node *at,
 281     char *tagname);
 282 data1_datatype data1_maptype(char *t);
 283 data1_varset *data1_read_varset(char *file);
 284 data1_vartype *data1_getvartypebyct(data1_varset *set, char *class, char *type);
 285 Z_Espec1 *data1_read_espec1(char *file, ODR o);
 286 int data1_doespec1(data1_node *n, Z_Espec1 *e);
 287 data1_esetname *data1_getesetbyname(data1_absyn *a, char *name);
 288 data1_element *data1_getelementbyname(data1_absyn *absyn, char *name);
 289 data1_node *data1_mk_node(void);
 290 data1_absyn *data1_get_absyn(char *name);
 291 data1_maptab *data1_read_maptab(char *file);
 292 data1_node *data1_map_record(data1_node *n, data1_maptab *map);
 293 data1_marctab *data1_read_marctab(char *file);
 294 char *data1_nodetomarc(data1_marctab *p, data1_node *n, int selected, int *len);
 295
 296 #endif