dalan.c

   1 /* source: dalan.c */
   2 /* Copyright Gerhard Rieger */
   3 /* Published under the GNU General Public License V.2, see file COPYING */
   4
   5 /* idea of a low level data description language. currently only a most
   6    primitive subset exists. */
   7
   8 #include "config.h"
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #if HAVE_STDBOOL_H
  12 #include <stdbool.h>
  13 #endif
  14 #include <ctype.h>
  15 #include "dalan.h"
  16
  17 /* test structure to find maximal alignment */
  18 static struct {
  19   char a;
  20   long double b;
  21 } maxalign;
  22
  23 /* test structure to find minimal alignment */
  24 static struct {
  25   char a;
  26   char b;
  27 } minalign;
  28
  29 /* test union to find kind of byte ordering */
  30 static union {
  31   char a[2];
  32   short b;
  33 } byteorder = { "01" };
  34
  35 struct dalan_opts_s dalan_opts = {
  36   sizeof(int),
  37   sizeof(short),
  38   sizeof(long),
  39   sizeof(char),
  40   sizeof(float),
  41   sizeof(double)
  42 } ;
  43
  44 /* fill the dalan_opts structure with machine dependent defaults values. */
  45 static void _dalan_dflts(struct dalan_opts_s *dlo) {
  46   dlo->c_int = sizeof(int);
  47   dlo->c_short = sizeof(short);
  48   dlo->c_long = sizeof(long);
  49   dlo->c_char = sizeof(char);
  50   dlo->c_float = sizeof(float);
  51   dlo->c_double = sizeof(double);
  52   dlo->maxalign = (char *)&maxalign.b-&maxalign.a;
  53   dlo->minalign = &minalign.b-&minalign.a;
  54   dlo->byteorder = (byteorder.b!=7711);
  55 }
  56
  57 /* allocate a new dalan_opts structure, fills it with machine dependent
  58    defaults values, and returns the pointer. */
  59 struct dalan_opts_s *dalan_props(void) {
  60   struct dalan_opts_s *dlo;
  61   dlo = malloc(sizeof(struct dalan_opts_s));
  62   if (dlo == NULL) {
  63     return NULL;
  64   }
  65   _dalan_dflts(dlo);
  66   return dlo;
  67 }
  68
  69 void dalan_init(void) {
  70   _dalan_dflts(&dalan_opts);
  71 }
  72
  73 /* read data description from line, write result to data; do not write
  74    so much data that *p exceeds n !
  75    p must be initialized to 0.
  76    return 0 on success,
  77    -1 if the data was cut due to n limit,
  78    1 if a syntax error occurred
  79    *p is a global data counter; especially it must be used when calculating
  80      alignment. On successful return from the function *p must be actual!
  81 */
  82 int dalan(const char *line, char *data, size_t *p, size_t n) {
  83   int align, mask, i, x;
  84   size_t p1 = *p;
  85   char c;
  86
  87   /*fputs(line, stderr); fputc('\n', stderr);*/
  88   while (c = *line++) {
  89     switch (c) {
  90     case ' ':
  91     case '\t':
  92     case '\r':
  93     case '\n':
  94       break;
  95     case ',':
  96       align = 2;
  97       while (*line == ',') {
  98         align <<= 1;
  99         ++line;
 100       }
 101       mask = align - 1; /* create the bitmask */
 102       i = (align - (p1 & mask)) & mask;
 103       while (i && p1<n) data[p1++] = 0, --i;
 104       if (i) { *p = p1; return -1; }
 105       break;
 106     case ';':
 107       align = dalan_opts.c_int;
 108       mask = align - 1;
 109       i = (align - (p1 & mask)) & mask;
 110       while (i && p1<n) data[p1++] = 0, --i;
 111       if (i) { *p = p1; return -1; }
 112       break;
 113     case '"':
 114       while (1) {
 115         switch (c = *line++) {
 116         case '\0': fputs("unterminated string\n", stderr);
 117           return 1;
 118         case '"':
 119           break;
 120         case '\\':
 121           if (!(c = *line++)) {
 122             fputs("continuation line not implemented\n", stderr);
 123             return 1;
 124           }
 125           switch (c) {
 126           case 'n': c = '\n'; break;
 127           case 'r': c = '\r'; break;
 128           case 't': c = '\t'; break;
 129           case 'f': c = '\f'; break;
 130           case 'b': c = '\b'; break;
 131           case 'a': c = '\a'; break;
 132 #if 0
 133           case 'e': c = '\e'; break;
 134 #else
 135           case 'e': c = '\033'; break;
 136 #endif
 137           case '0': c = '\0'; break;
 138           }
 139           /* PASSTHROUGH */
 140         default:
 141           if (p1 >= n) { *p = p1; return -1; }
 142           data[p1++] = c;
 143           continue;
 144         }
 145         if (c == '"')
 146           break;
 147       }
 148       break;
 149     case '\'':
 150       switch (c = *line++) {
 151       case '\0': fputs("unterminated character\n", stderr);
 152         return 1;
 153       case '\'': fputs("error in character\n", stderr);
 154         return 1;
 155       case '\\':
 156         if (!(c = *line++)) {
 157           fputs("continuation line not implemented\n", stderr);
 158           return 1;
 159         }
 160         switch (c) {
 161         case 'n': c = '\n'; break;
 162         case 'r': c = '\r'; break;
 163         case 't': c = '\t'; break;
 164         case 'f': c = '\f'; break;
 165         case 'b': c = '\b'; break;
 166         case 'a': c = '\a'; break;
 167 #if 0
 168         case 'e': c = '\e'; break;
 169 #else
 170         case 'e': c = '\033'; break;
 171 #endif
 172         }
 173         /* PASSTHROUGH */
 174       default:
 175         if (p1 >= n) { *p = p1; return -1; }
 176         data[p1++] = c;
 177         break;
 178       }
 179       if (*line != '\'') {
 180         fputs("error in character termination\n", stderr);
 181         *p = p1; return 1;
 182       }
 183       ++line;
 184       break;
 185 #if LATER
 186     case '0':
 187       c = *line++;
 188       if (c == 'x') {
 189       /* hexadecimal */ ;
 190       } else if (isdigit(c&0xff)) {
 191         /* octal */
 192       } else {
 193         /* it was only 0 */
 194       }
 195       break;
 196 #endif /* LATER */
 197     case 'x':
 198       /* expecting hex data, must be an even number of digits!! */
 199       while (true) {
 200         c = *line;
 201         if (isdigit(c&0xff)) {
 202           x = (c-'0') << 4;
 203         } else if (isxdigit(c&0xff)) {
 204           x = ((c&0x07) + 9) << 4;
 205         } else
 206           break;
 207         ++line;
 208         c = *line;
 209         if (isdigit(c&0xff)) {
 210           x |= (c-'0');
 211         } else if (isxdigit(c&0xff)) {
 212           x |= (c&0x07) + 9;
 213         } else {
 214           fputs("odd number of hexadecimal digits\n", stderr);
 215           *p = p1; return 1;
 216         }
 217         ++line;
 218         if (p1 >= n) { *p = p1; return -1; }
 219         data[p1++] = x;
 220       }
 221       break;
 222     case 'A': case 'a':
 223     case 'C': case 'c':
 224     default: fprintf(stderr, "syntax error in \"%s\"\n", line-1);
 225       return 1;
 226     }
 227   }
 228   *p = p1; return 0;
 229 }