apriori 0.2.1

data/ext/util/src/symtab.h

@@ -0,0 +1,121 @@
+/*----------------------------------------------------------------------
+  File    : symtab.h
+  Contents: symbol table and name/identifier map management
+  Author  : Christian Borgelt
+  History : 1995.10.22 file created
+            1995.10.30 functions made independent of symbol data
+            1995.11.26 symbol types and visibility levels added
+            1996.01.04 st_clear added
+            1996.02.27 st_insert modified, st_name and st_type added
+            1996.03.26 insertion into hash bucket simplified
+            1996.06.28 dynamic bucket vector enlargement added
+            1997.04.01 functions st_clear and st_remove combined
+            1998.05.31 list of all symbols removed
+            1998.06.20 deletion function moved to st_create
+            1998.09.28 types ULONG and CCHAR removed, st_stats added
+            1999.02.04 long int changed to int
+            1999.11.10 name/identifier map management added
+            2004.12.15 function nim_trunc added
+----------------------------------------------------------------------*/
+#ifndef __SYMTAB__
+#define __SYMTAB__
+
+/*----------------------------------------------------------------------
+  Preprocessor Definitions
+----------------------------------------------------------------------*/
+#define EXISTS  ((void*)-1)     /* symbol exists already */
+#define NIMAP   SYMTAB          /* name/id maps are special sym.tabs. */
+
+/*----------------------------------------------------------------------
+  Type Definitions
+----------------------------------------------------------------------*/
+typedef unsigned HASHFN   (const char *name, int type);
+typedef void     SYMFN    (void *data);
+typedef int      SYMCMPFN (const void *s1, const void *s2, void *data);
+
+typedef struct _ste {           /* --- symbol table element --- */
+  struct _ste *succ;            /* successor in hash bucket */
+  char        *name;            /* symbol name */
+  int         type;             /* symbol type */
+  int         level;            /* visibility level */
+} STE;                          /* (symbol table element) */
+
+typedef struct {                /* --- symbol table --- */
+  int         cnt;              /* current number of symbols */
+  int         level;            /* current visibility level */
+  int         size;             /* current hash table size */
+  int         max;              /* maximal hash table size */
+  HASHFN      *hash;            /* hash function */
+  SYMFN       *delfn;           /* symbol deletion function */
+  STE         **bvec;           /* bucket vector */
+  int         vsz;              /* size of identifier vector */
+  int         **ids;            /* identifier vector */
+} SYMTAB;                       /* (symbol table) */
+
+/*----------------------------------------------------------------------
+  Symbol Table Functions
+----------------------------------------------------------------------*/
+
+/*
+ * these are the ones from ruby
+int st_delete()
+int st_insert()
+*/
+
+extern SYMTAB*     st_create  (int init, int max,
+                               HASHFN hash, SYMFN delfn);
+extern void        ap_st_delete  (SYMTAB *tab);
+extern void*       ap_st_insert  (SYMTAB *tab, const char *name, int type,
+                               unsigned size);
+extern int         st_remove  (SYMTAB *tab, const char *name, int type);
+extern void*       ap_st_lookup  (SYMTAB *tab, const char *name, int type);
+extern void        st_begblk  (SYMTAB *tab);
+extern void        st_endblk  (SYMTAB *tab);
+extern int         st_symcnt  (const SYMTAB *tab);
+extern const char* st_name    (const void *data);
+extern int         st_type    (const void *data);
+#ifndef NDEBUG
+extern void        st_stats   (const SYMTAB *tab);
+#endif
+
+/*----------------------------------------------------------------------
+  Name/Identifier Map Functions
+----------------------------------------------------------------------*/
+#ifdef NIMAPFN
+extern NIMAP*      nim_create (int init, int max,
+                               HASHFN hash, SYMFN delfn);
+extern void        nim_delete (NIMAP *nim);
+extern void*       nim_add    (NIMAP *nim, const char *name,
+                               unsigned size);
+extern void*       nim_byname (NIMAP *nim, const char *name);
+extern void*       nim_byid   (NIMAP *nim, int id);
+extern const char* nim_name   (const void *data);
+extern int         nim_cnt    (const NIMAP *nim);
+extern void        nim_sort   (NIMAP *nim, SYMCMPFN cmpfn, void *data,
+                               int *map, int dir);
+extern void        nim_trunc  (NIMAP *nim, int n);
+#ifndef NDEBUG
+extern void        nim_stats  (const NIMAP *nimap);
+#endif
+#endif
+/*----------------------------------------------------------------------
+  Preprocessor Definitions
+----------------------------------------------------------------------*/
+#define st_begblk(t)      ((t)->level++)
+#define st_symcnt(t)      ((t)->cnt)
+#define st_name(d)        ((const char*)((STE*)(d)-1)->name)
+#define st_type(d)        (((STE*)(d)-1)->type)
+
+/*--------------------------------------------------------------------*/
+#ifdef NIMAPFN
+#define nim_delete(m)     ap_st_delete(m)
+#define nim_add(m,n,s)    ap_st_insert(m,n,0,s)
+#define nim_byname(m,n)   ap_st_lookup(m,n,0)
+#define nim_byid(m,i)     ((void*)(m)->ids[i])
+#define nim_name(d)       st_name(d)
+#define nim_cnt(m)        st_symcnt(m)
+#ifndef NDEBUG
+#define nim_stats(m)      st_stats(m)
+#endif
+#endif
+#endif

data/ext/util/src/tabscan.c

@@ -0,0 +1,279 @@
+/*----------------------------------------------------------------------
+  File    : tabscan.c
+  Contents: table scanner management
+  Author  : Christian Borgelt
+  History : 1998.01.04 file created
+            1998.03.11 additional character flags enabled
+            1998.08.12 function ts_copy() added
+            1998.09.01 several assertions added
+            1998.09.27 function ts_getfld() improved
+            1998.10.21 bug in ts_sgetc() removed
+            1998.11.26 some function parameters changed to const
+            1999.02.04 long int changed to int
+            1999.11.16 number of characters cleared for an empty field
+            2000.12.01 '\r' made a default blank character
+            2001.07.14 ts_sgetc() modified, ts_buf() and ts_err() added
+            2001.08.19 last delimiter stored in TABSCAN structure
+            2002.02.11 ts_reccnt() and ts_reset() added
+            2006.10.06 result value policy of ts_getfld() improved
+            2007.02.13 renamed to tabscan, redesigned, TS_NULL added
+            2007.05.17 function ts_allchs() added
+            2007.09.02 made '*' a null value character by default
+----------------------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "tabscan.h"
+#ifdef STORAGE
+#include "storage.h"
+#endif
+
+/*----------------------------------------------------------------------
+  Preprocessor Definitions
+----------------------------------------------------------------------*/
+/* --- convenience functions --- */
+#define isrecsep(c)   ts_istype(tsc, TS_RECSEP,  c)
+#define isfldsep(c)   ts_istype(tsc, TS_FLDSEP,  c)
+#define issep(c)      ts_istype(tsc, TS_FLDSEP|TS_RECSEP, c)
+#define isblank(c)    ts_istype(tsc, TS_BLANK,   c)
+#define isnull(c)     ts_istype(tsc, TS_NULL,    c)
+#define iscomment(c)  ts_istype(tsc, TS_COMMENT, c)
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+
+TABSCAN* ts_create (void)
+{                               /* --- create a table scanner */
+  TABSCAN *tsc;                 /* created table scanner */
+  int     i;                    /* loop variable */
+  char    *p;                   /* to traverse character flags */
+
+  tsc = (TABSCAN*)malloc(sizeof(TABSCAN));
+  if (!tsc) return NULL;        /* allocate memory and */
+  tsc->reccnt = 1;              /* initialize the fields */
+  tsc->delim  = TS_EOF;
+  for (p = tsc->cflags +256, i = 256; --i >= 0; )
+    *--p = '\0';                /* initialize the character flags */
+  tsc->cflags['\n'] = TS_RECSEP;
+  tsc->cflags['\t'] = tsc->cflags[' '] = TS_BLANK|TS_FLDSEP;
+  tsc->cflags['\r'] = TS_BLANK;
+  tsc->cflags[',']  = TS_FLDSEP;
+  tsc->cflags['?']  = tsc->cflags['*'] = TS_NULL;
+  tsc->cflags['#']  = TS_COMMENT;
+  return tsc;                   /* return created table scanner */
+}  /* ts_create() */
+
+/*--------------------------------------------------------------------*/
+
+void ts_copy (TABSCAN *dst, const TABSCAN *src)
+{                               /* --- copy character flags */
+  int  i;                       /* loop variable */
+  char *d; const char *s;       /* to traverse the character flags */
+
+  assert(src && dst);           /* check the function arguments */
+  s = src->cflags +256; d = dst->cflags +256;
+  for (i = 256; --i >= 0; ) *--d = *--s;
+}  /* ts_copy() */              /* copy the character flags */
+
+/*--------------------------------------------------------------------*/
+
+int ts_chars (TABSCAN *tsc, int type, const char *chars)
+{                               /* --- set characters of a class */
+  int  i, c, d;                 /* loop variable, characters */
+  char *p;                      /* to traverse character flags */
+  char const **s;
+
+  assert(tsc);                  /* check argument */
+  if (!chars) return -1;        /* if no characters given, abort */
+  p = tsc->cflags +256;         /* clear character flags in type */
+  for (i = 256; --i >= 0; ) *--p &= (char)~type;
+  s = &chars;                   /* traverse the given characters */
+  for (c = d = ts_decode(s); c >= 0; c = ts_decode(s))
+    tsc->cflags[c] |= (char)type;  /* set character flags */
+  return (d >= 0) ? d : 0;      /* return first character */
+}  /* ts_chars() */
+
+/*--------------------------------------------------------------------*/
+
+void ts_allchs (TABSCAN *tsc, const char *recseps, const char *fldseps,
+                const char *blanks, const char *nullchs,
+                const char *comment)
+{                               /* --- set characters of all classes */
+  if (recseps != NULL) ts_chars(tsc, TS_RECSEP,  recseps);
+  if (fldseps != NULL) ts_chars(tsc, TS_FLDSEP,  fldseps);
+  if (blanks  != NULL) ts_chars(tsc, TS_BLANK,   blanks);
+  if (nullchs != NULL) ts_chars(tsc, TS_NULL,    nullchs);
+  if (comment != NULL) ts_chars(tsc, TS_COMMENT, comment);
+}  /* ts_allchs() */
+
+/*--------------------------------------------------------------------*/
+
+int ts_next (TABSCAN *tsc, FILE *file, char *buf, int len)
+{                               /* --- read the next table field */
+  int  c, d;                    /* character read, delimiter type */
+  char *p;                      /* to traverse the buffer */
+
+  assert(tsc && (!buf || (len >= 0)));  /* check function argumens */
+
+  /* --- initialize --- */
+  if (!buf) {                   /* if no buffer given, use internal */
+    buf = tsc->buf; len = TS_SIZE; }
+  p = buf; *p = '\0';           /* clear the read buffer and */
+  tsc->cnt = 0;                 /* the number of characters read */
+  c = getc(file);               /* get the first character and */
+  if (c == EOF)                 /* check for end of file/error */
+    return tsc->delim = (ferror(file)) ? TS_ERR : TS_EOF;
+
+  /* --- skip comment records --- */
+  if (tsc->delim != 0) {        /* if at the start of a record */
+    while (iscomment(c)) {      /* while the record is a comment */
+      tsc->reccnt++;            /* count the record to be read */
+      while (!isrecsep(c)) {    /* while not at end of record */
+        c = getc(file);         /* get the next character and */
+        if (c == EOF)           /* check for end of file/error */
+          return tsc->delim = (ferror(file)) ? TS_ERR : TS_EOF;
+      }                         /* (read up to a record separator) */
+      c = getc(file);           /* get the next character and */
+      if (c == EOF)             /* check for end of file/error */
+        return tsc->delim = (ferror(file)) ? TS_ERR : TS_EOF;
+    }              
+  }                             /* (comment records are skipped) */
+
+  /* --- skip leading blanks --- */
+  while (isblank(c)) {          /* while character is blank, */
+    c = getc(file);             /* get the next character and */
+    if (c == EOF)               /* check for end of file/error */
+      return tsc->delim = (ferror(file)) ? TS_ERR : TS_REC;
+  }                             /* check for end of file */
+  if (issep(c)) {               /* check for field/record separator */
+    if (isfldsep(c)) return tsc->delim = TS_FLD;
+    tsc->reccnt++;   return tsc->delim = TS_REC;
+  }                             /* if at end of record, count reocrd */
+  /* Note that after at least one valid character was read, even  */
+  /* if it is a blank, the end of file/input is translated into a */
+  /* record separator. -1 is returned only if no character could  */
+  /* be read before the end of file/input is encountered.         */
+
+  /* --- read the field --- */
+  while (1) {                   /* field read loop */
+    if (len > 0) {              /* if the buffer is not full, */
+      len--; *p++ = (char)c; }  /* store the character in the buffer */
+    c = getc(file);             /* get the next character */
+    if (issep(c)) { d = (isfldsep(c))  ? TS_FLD : TS_REC; break; }
+    if (c == EOF) { d = (ferror(file)) ? TS_ERR : TS_REC; break; }
+  }                             /* while character is no separator */
+
+  /* --- remove trailing blanks --- */
+  while (isblank(*--p));        /* while character is blank */
+  *++p = '\0';                  /* terminate string in buffer */
+  tsc->cnt = (int)(p -buf);     /* store number of characters read */
+  if (d != TS_FLD) {            /* if not at a field separator */
+    if (d == TS_REC) tsc->reccnt++;
+    return tsc->delim = d;      /* if at end of record, count record, */
+  }                             /* and then abort the function */
+
+  /* --- check for a null value --- */
+  while (--p >= buf)            /* check for only null value chars. */
+    if (!isnull((unsigned char)*p)) break;
+  if (p < buf) buf[0] = '\0';   /* clear buffer if null value */
+  
+  /* --- skip trailing blanks --- */
+  while (isblank(c)) {          /* while character is blank, */
+    c = getc(file);             /* get the next character and */
+    if (c == EOF)               /* check for end of file/error */
+      return tsc->delim = ferror(file) ? TS_ERR : TS_REC;
+  }                             /* check for end of file */
+  if (isrecsep(c)) {            /* check for a record separator */
+    tsc->reccnt++; return tsc->delim = TS_REC; }
+  if (!isfldsep(c))             /* put back character (may be */
+    ungetc(c, file);            /* necessary if blank = field sep.) */
+  return tsc->delim = TS_FLD;   /* return the delimiter type */
+}  /* ts_next() */
+
+/*--------------------------------------------------------------------*/
+
+void ts_reset (TABSCAN *tsc)
+{                               /* --- reset a table scanner */
+  tsc->reccnt =  1;             /* reset the record counter */
+  tsc->delim  = -1;             /* and the field delimiter */
+}  /* ts_reset() */
+
+/*--------------------------------------------------------------------*/
+
+int ts_decode (char const **s)
+{                               /* --- decode ASCII character codes */
+  int c, code;                  /* character and character code */
+
+  assert(s && *s);              /* check the function arguments */
+  if (**s == '\0')              /* if at the end of the string, */
+    return -1;                  /* abort the function */
+  c = (unsigned char)*(*s)++;   /* get the next character */
+  if (c != '\\')                /* if no quoted character, */
+    return c;                   /* simply return the character */
+  c = (unsigned char)*(*s)++;   /* get the next character */
+  switch (c) {                  /* and evaluate it */
+    case 'a': return '\a';      /* 0x07 (BEL) */
+    case 'b': return '\b';      /* 0x08 (BS)  */
+    case 'f': return '\f';      /* 0x0c (FF)  */
+    case 'n': return '\n';      /* 0x0a (NL)  */
+    case 'r': return '\r';      /* 0x0d (CR)  */
+    case 't': return '\t';      /* 0x09 (HT)  */
+    case 'v': return '\v';      /* 0x0b (VT)  */
+    case '0': case '1': case '2': case '3':
+    case '4': case '5': case '6': case '7':
+      code = c -'0';            /* --- octal character code */
+      c    = **s;               /* get the next character */
+      if ((c >= '0') && (c <= '7')) code = (code << 3) +c -'0';
+      else return code;         /* decode second digit */
+      c    = *++(*s);           /* get the next character */
+      if ((c >= '0') && (c <= '7')) code = (code << 3) +c -'0';
+      else return c;            /* decode third digit */
+      (*s)++;                   /* consume the decoded character */
+      return code & 0xff;       /* and return the character code */
+    case 'x':                   /* --- hexadecimal character code */
+      c = **s;                  /* get the next character */
+      if      ((c >= '0') && (c <= '9')) code = c -'0';
+      else if ((c >= 'a') && (c <= 'f')) code = c -'a' +10;
+      else if ((c >= 'A') && (c <= 'F')) code = c -'A' +10;
+      else return 'x';          /* decode first digit */
+      c = *++(*s);              /* get the next character */
+      if      ((c >= '0') && (c <= '9')) code = (code << 4) +c -'0';
+      else if ((c >= 'a') && (c <= 'f')) code = (code << 4) +c -'a' +10;
+      else if ((c >= 'A') && (c <= 'F')) code = (code << 4) +c -'A' +10;
+      else return code;         /* decode second digit */
+      (*s)++;                   /* consume the decoded character */
+      return code;              /* and return the character code */
+    default:                    /* non-function characters */
+      if (**s == '\0') return '\\';
+      else             return (unsigned char)*(*s)++;
+  }                             /* return character or backslash */
+}  /* ts_decode() */
+
+/*--------------------------------------------------------------------*/
+#if 0
+
+int main (int argc, char* argv[])
+{                               /* --- main function for testing */
+  int     d;                    /* delimiter of current field */
+  FILE    *file;                /* file to read */
+  TABSCAN *tsc;                 /* table scanner for testing */
+  char    buf[256];             /* read buffer */
+
+  if (argc < 2) {               /* if no arguments given, abort */
+    printf("usage: %s file\n", argv[0]); return 0; }
+  file = fopen(argv[1], "rb");  /* open the input file */
+  if (!file) { printf("cannot open %s\n", argv[1]); return -1; }
+  tsc = ts_create();            /* create a table scanner */
+  if (!tsc)  { printf("not enough memory\n");       return -1; }
+  ts_chars(tsc, TS_COMMENT, "#");
+  do {                          /* file read loop */
+    d = ts_next(tsc, file, buf, sizeof(buf));
+    printf("%d : %s\n", d, buf);/* print delimiter and field */
+  } while (d >= 0);             /* while not at end of file */
+  ts_delete(tsc);               /* delete the table scanner */
+  fclose(file);                 /* and close the input file */
+  return 0;                     /* return 'ok' */
+}  /* main() */
+
+#endif

data/ext/util/src/tabscan.h

@@ -0,0 +1,99 @@
+/*----------------------------------------------------------------------
+  File    : tabscan.h
+  Contents: table scanner management
+  Author  : Christian Borgelt
+  History : 1998.01.04 file created as tfscan.h
+            1998.03.11 additional character flags enabled
+            1998.08.12 function ts_copy() added
+            1998.11.26 some function parameters changed to const
+            1999.02.04 long int changed to int
+            2001.07.14 ts_sgetc() modified, ts_buf() and ts_err() added
+            2001.08.19 ts_delim() added (last delimiter type)
+            2002.02.11 ts_reccnt() and ts_reset() added
+            2007.02.13 renamed to tabscan, TS_NULL added
+            2007.05.17 function ts_allchs() added
+----------------------------------------------------------------------*/
+#ifndef __TABSCAN__
+#define __TABSCAN__
+#include <stdio.h>
+
+/*----------------------------------------------------------------------
+  Preprocessor Definitions
+----------------------------------------------------------------------*/
+/* --- character flags --- */
+#define TS_RECSEP   0x01       /* flag for record separator */
+#define TS_FLDSEP   0x02       /* flag for field separator */
+#define TS_BLANK    0x04       /* flag for blank character */
+#define TS_NULL     0x08       /* flag for null value characters */
+#define TS_COMMENT  0x10       /* flag for comment character */
+#define TS_OTHER    0x20       /* flag for other character type */
+
+/* --- delimiter types --- */
+#define TS_ERR     -2          /* error indicator */
+#define TS_EOF     -1          /* end of file delimiter */
+#define TS_FLD      0          /* field  delimiter */
+#define TS_REC      1          /* record delimiter */
+
+/* --- buffer size --- */
+#define TS_SIZE     256        /* size of internal read buffer */
+
+/*----------------------------------------------------------------------
+  Type Definitions
+----------------------------------------------------------------------*/
+typedef struct {                /* --- error information --- */
+  int    code;                  /* error code */
+  int    rec, fld;              /* record and field number */
+  int    exp;                   /* expected number of records/fields */
+  char   *s;                    /* a string (e.g., field contents) */
+} TSINFO;                       /* (error information) */
+
+typedef struct {                /* --- table scanner --- */
+  char   cflags[256];           /* character flags */
+  int    reccnt;                /* number of records read */
+  int    delim;                 /* last delimiter read */
+  int    cnt;                   /* number of characters read */
+  char   buf[TS_SIZE+4];        /* read buffer */
+  TSINFO info;                  /* error information */
+} TABSCAN;                      /* (table file scanner) */
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+extern TABSCAN* ts_create (void);
+extern void     ts_delete (TABSCAN *tsc);
+extern void     ts_copy   (TABSCAN *dst, const TABSCAN *src);
+
+extern int      ts_chars  (TABSCAN *tsc, int type, const char *chars);
+extern void     ts_allchs (TABSCAN *tsc, const char *recseps,
+                           const char *fldseps, const char *blanks,
+                           const char *nullchs, const char *comment);
+extern int      ts_istype (const TABSCAN *tsc, int type, int c);
+extern int      ts_type   (const TABSCAN *tsc, int c);
+
+extern int      ts_next   (TABSCAN *tsc, FILE *file, char *buf,int len);
+extern int      ts_delim  (TABSCAN *tsc);
+extern int      ts_cnt    (TABSCAN *tsc);
+extern char*    ts_buf    (TABSCAN *tsc);
+
+extern int      ts_reccnt (TABSCAN *tsc);
+extern void     ts_reset  (TABSCAN *tsc);
+
+extern TSINFO*  ts_info   (TABSCAN *tsc);
+
+extern int      ts_decode (char const **s);
+
+/*----------------------------------------------------------------------
+  Preprocessor Definitions
+----------------------------------------------------------------------*/
+#define ts_delete(s)     free(s)
+
+#define ts_istype(s,t,c) ((s)->cflags[(unsigned char)(c)] & (t))
+#define ts_type(s,c)     ((s)->cflags[(unsigned char)(c)])
+
+#define ts_delim(s)      ((s)->delim)
+#define ts_cnt(s)        ((s)->cnt)
+#define ts_buf(s)        ((s)->buf)
+
+#define ts_reccnt(s)     ((s)->reccnt)
+#define ts_info(s)       (&(s)->info)
+#endif