ferret 0.3.2 → 0.9.0

data/ext/global.c

@@ -0,0 +1,219 @@
+#include "global.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <math.h>
+#include <ctype.h>
+
+const char *EMPTY_STRING = "";
+
+int min3(int a, int b, int c)
+{
+  return MIN3(a, b, c);
+}
+
+int min(int a, int b)
+{
+  return MIN(a, b);
+}
+
+int max3(int a, int b, int c)
+{
+  return MAX3(a, b, c);
+}
+
+int max(int a, int b)
+{
+  return MAX(a, b);
+}
+
+int scmp(const void *p1, const void *p2)
+{
+  return strcmp(*(char **)p1, *(char **)p2);
+}
+
+int icmp_risky(const void *p1, const void *p2)
+{
+  return (*(int *)p1) - *((int *)p2);
+}
+
+int icmp(const void *p1, const void *p2)
+{
+  int i1 = *(int *)p1;
+  int i2 = *(int *)p2;
+
+  if (i1 > i2) return 1;
+  else if (i1 < i2) return -1;
+  return 0;
+}
+
+
+/* eprintf: print error message and exit */
+void eprintf_old(const char *fmt, ...)
+{
+  va_list args;
+
+  fflush(stdout);
+  if (progname() != NULL)
+    fprintf(stderr, "%s: ", progname());
+
+  va_start(args, fmt);
+  vfprintf(stderr, fmt, args);
+  va_end(args);
+
+  if (fmt[0] != '\0' && fmt[strlen(fmt)-1] == ':')
+    fprintf(stderr, " %s", strerror(errno));
+  fprintf(stderr, "\n");
+  exit(2); /* conventional value for failed execution */
+}
+
+/* eprintf: print error message and exit */
+void eprintf_inner(char *file, int line_num, const char *etype, const char *fmt, ...)
+{
+  va_list args;
+
+  fflush(stdout);
+  fprintf(stderr, "\n");
+  if (progname() != NULL)
+    fprintf(stderr, "%s: ", progname());
+
+  fprintf(stderr, "%s occured at <%s>:%d\n", etype, file, line_num);
+  va_start(args, fmt);
+  vfprintf(stderr, fmt, args);
+  va_end(args);
+
+  if (fmt[0] != '\0' && fmt[strlen(fmt)-1] == ':')
+    fprintf(stderr, " %s", strerror(errno));
+  fprintf(stderr, "\n");
+  exit(2); /* conventional value for failed execution */
+}
+
+/* weprintf: print error message and don't exit */
+void weprintf(const char *fmt, ...)
+{
+  va_list args;
+
+  fflush(stdout);
+  if (progname() != NULL)
+    fprintf(stderr, "%s: ", progname());
+
+  va_start(args, fmt);
+  vfprintf(stderr, fmt, args);
+  va_end(args);
+
+  if (fmt[0] != '\0' && fmt[strlen(fmt)-1] == ':')
+    fprintf(stderr, " %s", strerror(errno));
+  fprintf(stderr, "\n");
+}
+
+static char name[200]; /* program name for error msgs */
+
+/* setprogname: set stored name of program */
+void setprogname(const char *str)
+{
+  strcpy(name, str);
+}
+
+char *progname(void)
+{
+  return name;
+}
+
+/* concatenate two strings freeing the second */
+char *estrcat(char *str1, char *str2)
+{
+  int len1 = strlen(str1);
+  int len2 = strlen(str2);
+  REALLOC_N(str1, char, len1 + len2 + 3); // leave room for <CR>
+  memcpy(str1 + len1, str2, len2 + 1); // make sure '\0' copied too
+  free(str2);
+  return str1;
+}
+
+/* epstrdup: duplicate a string with a format, report if error */
+char *epstrdup(const char *fmt, int len, ...)
+{
+  va_list args;
+  len += strlen(fmt);
+
+  char *string = ALLOC_N(char, len + 1);
+  va_start(args, len);
+  vsprintf(string, fmt, args);
+  va_end(args);
+
+  return string;
+}
+
+/* estrdup: duplicate a string, report if error */
+char *estrdup(const char *s)
+{
+  char *t;
+
+  t = (char *)malloc(strlen(s) + 1);
+  if (t == NULL)
+    eprintf(MEM_ERROR, "estrdup(\"%.20s\") failed:", s);
+
+  strcpy(t, s);
+  return t;
+}
+
+/* emalloc: malloc and report if error */
+void *emalloc(size_t size)
+{
+  void *p;
+  p = malloc(size);
+  if (p == NULL)
+    eprintf(MEM_ERROR, "malloc of %u bytes failed:", size);
+  return p;
+}
+
+void *erealloc(void *ptr, size_t size)
+{
+  void *p;
+  p = realloc(ptr, size);
+  if (p == NULL)
+    eprintf(MEM_ERROR, "malloc of %u bytes failed:", size);
+  return p;
+}
+
+/*
+ * The following method comes slightly modified from the ruby core flo_to_s in
+ * numeric.c. We use it so that tests comparing floats as strings will pass.
+ */
+char *dbl_to_s(char *buf, double num)
+{
+  char *p, *e;
+
+  if (isinf(num)) {
+    return estrdup(num < 0 ? "-Infinity" : "Infinity");
+  } else if(isnan(num)) {
+    return estrdup("NaN");
+  }
+
+  sprintf(buf, "%#.7g", num);
+  if (!(e = strchr(buf, 'e'))) {
+    e = buf + strlen(buf);
+  }
+  if (!isdigit(e[-1])) {
+    /* reformat if ended with decimal point (ex 111111111111111.) */
+    sprintf(buf, "%#.6e", num);
+    if (!(e = strchr(buf, 'e'))) {
+      e = buf + strlen(buf);
+    }
+  }
+  p = e;
+  while (p[-1]=='0' && isdigit(p[-2]))
+    p--;
+  memmove(p, e, strlen(e)+1);
+  return buf;
+}
+
+void lower_str(char *str)
+{
+  while (*str) {
+    *str = tolower(*str);
+    str++;
+  }
+}

data/ext/global.h

@@ -0,0 +1,73 @@
+#ifndef FRT_GLOBAL_H
+#define FRT_GLOBAL_H
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <pthread.h>
+#include "lang.h"
+
+//#define DEBUG
+#define VALGRIND
+
+#define false 0
+#define true 1
+
+typedef unsigned char bool;
+typedef unsigned char uchar;
+typedef unsigned int uint;
+
+typedef void (*destroy_func_t)(void *p);
+
+#define MAX_WORD_SIZE 255
+#define MAX_PATH 1024
+#define MAX_BUFFER_SIZE 1024
+#define ARRAY_INIT_SIZE 4
+
+#define NELEMS(array) sizeof(array)/sizeof(array[0])
+
+#define ZEROSET(ptr, type, n) memset(ptr, 0, sizeof(type)*(n))
+#define ALLOC_AND_ZERO_N(type,n) (type*)ZEROSET(emalloc(sizeof(type)*(n)), type, n)
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+#define MIN3(a, b, c) ((a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)))
+#define MAX3(a, b, c) ((a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c)))
+
+#define RECAPA(self, len, capa, ptr, type) \
+  do {\
+    if (self->len >= self->capa) {\
+      if (self->capa) {\
+        self->capa *= 2;\
+      } else {\
+        self->capa = 4;\
+      }\
+      REALLOC_N(self->ptr, type, self->capa);\
+    }\
+  } while (0)
+
+#define Jx fprintf(stderr,"%s, %d: %s\n", __FILE__, __LINE__, __func__);
+#define Xj fprintf(stdout,"%s, %d: %s\n", __FILE__, __LINE__, __func__);
+
+#define efree free
+extern void *emalloc(size_t n);
+extern void *erealloc(void *ptr, size_t n);
+extern char *estrdup(const char *s);
+extern char *epstrdup(const char *fmt, int len, ...);
+extern char *estrcat(char *str, char *str_cat);
+
+extern const char *EMPTY_STRING;
+
+extern int scmp(const void *p1, const void *p2);
+extern int icmp(const void *p1, const void *p2);
+extern int icmp_risky(const void *p1, const void *p2);
+
+int min(int a, int b);
+int min3(int a, int b, int c);
+int max(int a, int b);
+int max3(int a, int b, int c);
+
+char *dbl_to_s(char *buf, double num);
+void lower_str(char *str);
+#endif

data/ext/hash.c

@@ -0,0 +1,446 @@
+#include <hash.h>
+#include <global.h>
+#include <string.h>
+
+unsigned int hash(const char *str)
+{
+  register unsigned int h;
+  register unsigned char *p;
+
+  h = 0;
+  for (p = (unsigned char *) str; *p != '\0'; p++)
+    h = MULTIPLIER * h + *p;
+
+  return h % NUM_ENTRIES;
+}
+
+HashEntry **ht_create()
+{
+  int i;
+  HashEntry **new_ht = ALLOC_N(HashEntry *, NUM_ENTRIES);
+
+  for (i = 0; i < NUM_ENTRIES; i++)
+    new_ht[i] = NULL;
+
+  return new_ht;
+}
+
+int ht_count(HashEntry **ht)
+{
+  int i, cnt=0;
+  HashEntry *he;
+  for (i = 0; i < NUM_ENTRIES; i++) {
+    for (he = ht[i]; he != NULL; he = he->next) {
+      cnt++;
+    }
+  }
+  return cnt;
+}
+
+void ht_destroy_all(HashEntry **ht, void (*fn)(void *))
+{
+  int i;
+  HashEntry *he, *he_tmp;
+  for (i = 0; i < NUM_ENTRIES; i++) {
+    for (he = ht[i]; he != NULL;) {
+      he_tmp = he;
+      he = he->next;
+      fn(he_tmp->value);
+      free(he_tmp->name);
+      free(he_tmp);
+    }
+  }
+  free(ht);
+}
+
+void ht_destroy(HashEntry **ht)
+{
+  int i;
+  HashEntry *he, *he_tmp;
+  for (i = 0; i < NUM_ENTRIES; i++) {
+    for (he = ht[i]; he != NULL;) {
+      he_tmp = he;
+      he = he->next;
+      free(he_tmp->name);
+      free(he_tmp);
+    }
+  }
+  free(ht);
+}
+
+void *ht_get(HashEntry **ht, char *name)
+{
+  HashEntry *he;
+  int h = hash(name);
+
+  for (he = ht[h]; he != NULL; he = he->next) {
+    if (strcmp(name, he->name) == 0) {
+      return he->value;
+    }
+  }
+
+  return NULL;
+}
+
+void ht_set(HashEntry **ht, char *name, void *value)
+{
+  HashEntry *he;
+  int h = hash(name);
+
+  for (he = ht[h]; he != NULL; he = he->next) {
+    if (strcmp(name, he->name) == 0) {
+      he->value = value;
+      return;
+    }
+  }
+
+  he = ALLOC(HashEntry);
+  he->name = estrdup(name);
+  he->value = value;
+  he->next = ht[h];
+  ht[h] = he;
+  return;
+}
+
+void *ht_delete(HashEntry **ht, char *name)
+{
+  HashEntry *he, *tmp;
+  void *rval;
+
+  int h = hash(name);
+
+  if (ht[h] == NULL)
+    return NULL;
+
+  if (strcmp(ht[h]->name, name) == 0) {
+    tmp = ht[h];
+    ht[h] = tmp->next;
+    rval = tmp->value;
+    free(tmp->name);
+    free(tmp);
+    return rval;
+  }
+
+  for (he = ht[h]; he != NULL; he = he->next) {
+    if (he->next != NULL && strcmp(name, he->next->name) == 0) {
+      tmp = he->next;
+      he->next = tmp->next;
+      rval = tmp->value;
+      free(tmp->name);
+      free(tmp);
+      return rval;
+    }
+  }
+  return NULL;
+}
+
+/****************************************************************************
+ *
+ * HshTable
+ *
+ ****************************************************************************/
+
+char *dummy_key = "";
+
+#define PERTURB_SHIFT 5
+
+#ifdef VALGRIND
+#define MAX_FREE_HASH_TABLES 0
+#else
+#define MAX_FREE_HASH_TABLES 80
+#endif
+
+static HshTable *free_hts[MAX_FREE_HASH_TABLES];
+static int num_free_hts = 0;
+
+inline unsigned int str_hash(const char *const str)
+{
+  register unsigned int h=0;
+  register unsigned char *p = (unsigned char *)str;
+
+  for (; *p; p++)
+    h = 37 * h + *p;
+
+  return h;
+}
+
+HshEntry *h_lookup_str(HshTable *ht, register const void *key_p)
+{
+  register char *key = (char *)key_p;
+  register unsigned int hash = str_hash(key);
+  register unsigned int perturb;
+  register int mask = ht->mask;
+  register HshEntry *he0 = ht->table;
+  register int i = hash & mask;
+  register HshEntry *he = &he0[i];
+  register HshEntry *freeslot;
+
+  if (he->key == NULL || he->key == key) {
+    he->hash = hash;
+    return he;
+  }
+  if (he->key == dummy_key) {
+    freeslot = he;
+  } else {
+    if ((he->hash == hash) && (strcmp(he->key, key) == 0)) {
+      return he;
+    }
+    freeslot = NULL;
+  }
+
+  for (perturb = hash; ; perturb >>= PERTURB_SHIFT) {
+    i = (i << 2) + i + perturb + 1;
+    he = &he0[i & mask];
+    if (he->key == NULL) {
+      if (freeslot != NULL) he = freeslot;
+      he->hash = hash;
+      return he;
+    }
+    if (he->key == key
+        || (he->hash == hash
+          && he->key != dummy_key
+          && strcmp(he->key, key) == 0))
+      return he;
+    if (he->key == dummy_key && freeslot == NULL)
+      freeslot = he;
+  }
+  if (he->key == NULL || he->key == key) {
+    he->hash = hash;
+    return he;
+  }
+}
+
+typedef int (*eq_func)(const void *key1, const void *key2);
+
+HshEntry *h_lookup(HshTable *ht, register const void *key)
+{
+  register unsigned int hash = ht->hash(key);
+  register unsigned int perturb;
+  register int mask = ht->mask;
+  register HshEntry *he0 = ht->table;
+  register int i = hash & mask;
+  register HshEntry *he = &he0[i];
+  register HshEntry *freeslot;
+  eq_func eq = ht->eq;
+
+  if (he->key == NULL || he->key == key) {
+    he->hash = hash;
+    return he;
+  }
+  if (he->key == dummy_key) {
+    freeslot = he;
+  } else {
+    if ((he->hash == hash) && eq(he->key, key))
+      return he;
+    freeslot = NULL;
+  }
+
+  for (perturb = hash; ; perturb >>= PERTURB_SHIFT) {
+    i = (i << 2) + i + perturb + 1;
+    he = &he0[i & mask];
+    if (he->key == NULL) {
+      if (freeslot != NULL) he = freeslot;
+      he->hash = hash;
+      return he;
+    }
+    if (he->key == key
+        || (he->hash == hash
+          && he->key != dummy_key
+          && eq(he->key, key)))
+      return he;
+    if (he->key == dummy_key && freeslot == NULL)
+      freeslot = he;
+  }
+}
+
+typedef void (*free_func)(void *);
+void dummy_free(void *p)
+{
+  //printf("Shouldn't do nuthin");
+}
+
+HshTable *h_new_str(void (*free_key)(void *key), void (*free_value)(void *value))
+{
+  HshTable *ht;
+  if (num_free_hts > 0) {
+    ht = free_hts[--num_free_hts];
+  } else {
+    ht = ALLOC(HshTable);
+  }
+  ht->fill = 0;
+  ht->used = 0;
+  ht->mask = Hsh_MINSIZE - 1;
+  ht->table = ht->smalltable;
+  memset(ht->smalltable, 0, sizeof(ht->smalltable));
+  ht->lookup = &h_lookup_str;
+  ht->free_key = free_key != NULL ? free_key : &dummy_free;
+  ht->free_value = free_value != NULL ? free_value : &dummy_free;
+  return ht;
+}
+
+HshTable *h_new(unsigned int (*hash)(const void *key),
+    int (*eq)(const void *key1, const void *key2),
+    void (*free_key)(void *key),
+    void (*free_value)(void *value))
+{
+  HshTable *ht = h_new_str(free_key, free_value);
+
+  ht->lookup = &h_lookup;
+  ht->eq = eq;
+  ht->hash = hash;
+  return ht;
+}
+
+void h_clear(HshTable *ht)
+{
+  int i;
+  HshEntry *he;
+  free_func free_key = ht->free_key;
+  free_func free_value = ht->free_value;
+
+  // Clear all the hash values and keys as necessary
+  for (i = 0; i <= ht->mask; i++) {
+    he = &ht->table[i];
+    if (he->key != NULL && he->key != dummy_key) {
+      free_value(he->value);
+      free_key(he->key);
+    }
+    he->key = NULL;
+  }
+  ht->used = 0;
+  ht->fill = 0;
+}
+
+void h_destroy(HshTable *ht)
+{
+  h_clear(ht);
+
+  // if a new table was created, be sure to free it
+  if (ht->table != ht->smalltable) free(ht->table);
+
+  if (num_free_hts < MAX_FREE_HASH_TABLES) {
+    free_hts[num_free_hts++] = ht;
+  } else {
+    free(ht);
+  }
+}
+
+void *h_get(HshTable *ht, const void *key)
+{
+  return ht->lookup(ht, key)->value;
+}
+
+int h_del(HshTable *ht, const void *key)
+{
+  HshEntry *he = ht->lookup(ht, key);
+
+  if (he->key != NULL && he->key != dummy_key) {
+    ht->free_key(he->key);
+    ht->free_value(he->value);
+    he->key = dummy_key;
+    he->value = NULL;
+    ht->used--;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+void *h_rem(HshTable *ht, const void *key, bool destory_key)
+{
+  void *val;
+  HshEntry *he = ht->lookup(ht, key);
+
+  if (he->key != NULL && he->key != dummy_key) {
+    if (destory_key)
+      ht->free_key(he->key);
+
+    he->key = dummy_key;
+    val = he->value;
+    he->value = NULL;
+    ht->used--;
+    return val;
+  } else {
+    return NULL;
+  }
+}
+
+int h_resize(HshTable *ht, int min_newsize) {
+  HshEntry smallcopy[Hsh_MINSIZE];
+  HshEntry *oldtable;
+  HshEntry *he_old, *he_new;
+  int newsize, i;
+
+  for (newsize = Hsh_MINSIZE; newsize < min_newsize; newsize <<= 1)
+    ;
+  
+  oldtable = ht->table;
+  if (newsize == Hsh_MINSIZE) {
+    if (ht->table == ht->smalltable) {
+      /* need to copy the d*(int *)ata out so we can rebuild the table into
+       * the same space */
+      memcpy(smallcopy, ht->smalltable, sizeof(smallcopy));
+      oldtable = smallcopy;
+    } else {
+      ht->table = ht->smalltable;
+    } 
+  } else {
+    ht->table = ALLOC_N(HshEntry, newsize);
+  }
+  memset(ht->table, 0, sizeof(HshEntry) * newsize);
+  i = ht->fill;
+  ht->fill = ht->used;
+  ht->mask = newsize - 1;
+  int j = 0;
+  for (he_old = oldtable; i > 0; he_old++) {
+    j++;
+    if (he_old->value != NULL) {// active entry
+      he_new = ht->lookup(ht, he_old->key);
+      he_new->key = he_old->key;
+      he_new->value = he_old->value;
+      i--;
+    } else if (he_old->key == dummy_key) { //dummy entry
+      i--;
+    } // else empty entry so nothing to do
+  }
+  if (oldtable != smallcopy && oldtable != ht->smalltable)
+    free(oldtable);
+  return 0;
+}
+
+int h_set(HshTable *ht, const void *key, void *value)
+{
+  int ret_val = HASH_KEY_DOES_NOT_EXIST;
+  HshEntry *he = ht->lookup(ht, key);
+  int fill = ht->fill;
+  if (he->key == NULL) {
+    ht->fill++;
+    ht->used++;
+  } else if (he->key == dummy_key) {
+    ht->used++;
+  } else if (he->key != key) {
+    ht->free_key(he->key);
+    if (he->value != value) ht->free_value(he->value);
+    ret_val = HASH_KEY_EQUAL;
+  } else {
+    if (he->value != value) ht->free_value(he->value);
+    ret_val = HASH_KEY_SAME;
+  }
+  he->key = (void *)key;
+  he->value = value;
+  if ((ht->fill > fill) && (ht->fill * 3 > ht->mask * 2))
+    h_resize(ht, ht->used * ((ht->used > SLOW_DOWN) ? 4 : 2));
+  return ret_val;
+}
+
+int h_has_key(HshTable *ht, const void *key)
+{
+  HshEntry *he = ht->lookup(ht, key);
+  if (he->key == NULL || he->key == dummy_key) {
+    return HASH_KEY_DOES_NOT_EXIST;
+  } else if (he->key == key) {
+    return HASH_KEY_SAME;
+  } else {
+    return HASH_KEY_EQUAL;
+  }
+}