ferret 0.9.6 → 0.10.0

data/ext/global.h

@@ -1,38 +1,36 @@
 #ifndef FRT_GLOBAL_H
 #define FRT_GLOBAL_H
 
+#include "defines.h"
+#include "except.h"
+#include "lang.h"
 #include <stdlib.h>
 #include <stdio.h>
-#include <assert.h>
-/*
-#define DEBUG 
-#define VALGRIND
-*/
-#define false 0
-#define true 1
+#include <stdarg.h>
 
-typedef unsigned int bool;
-typedef unsigned char uchar;
-typedef unsigned int uint;
+#define MAX_WORD_SIZE 255
+#define MAX_FILE_PATH 1024
 
 typedef void (*free_ft)(void *key);
 
-#include "lang.h"
-#include "except.h"
-
-#define ref(obj) obj->ref_cnt++
-#define deref(obj) obj->ref_cnt--
+#define NELEMS(array) ((int)(sizeof(array)/sizeof(array[0])))
 
-#define MAX_WORD_SIZE 255
-#define MAX_FILE_PATH 1024
-#define MAX_BUFFER_SIZE 1024
-#define ARRAY_INIT_SIZE 4
 
-#define NELEMS(array) sizeof(array)/sizeof(array[0])
+#define ZEROSET(ptr, type) memset(ptr, 0, sizeof(type))
+#define ZEROSET_N(ptr, type, n) memset(ptr, 0, sizeof(type)*(n))
 
-#define ZEROSET(ptr, type, n) memset(ptr, 0, sizeof(type)*(n))
+/*
 #define ALLOC_AND_ZERO(type) (type*)memset(emalloc(sizeof(type)), 0, sizeof(type))
-#define ALLOC_AND_ZERO_N(type,n) (type*)ZEROSET(emalloc(sizeof(type)*(n)), type, n)
+#define ALLOC_AND_ZERO_N(type,n) (type*)memset(emalloc(sizeof(type)*(n)), 0, sizeof(type)*(n))
+*/
+#define ALLOC_AND_ZERO(type) (type*)frt_calloc(sizeof(type))
+#define ALLOC_AND_ZERO_N(type,n) (type*)frt_calloc(sizeof(type)*(n))
+
+#define REF(a) (a)->ref_cnt++
+#define DEREF(a) (a)->ref_cnt--
+
+#define NEXT_NUM(index, size) (((index) + 1) % (size))
+#define PREV_NUM(index, size) (((index) + (size) - 1) % (size))
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
@@ -43,8 +41,8 @@ typedef void (*free_ft)(void *key);
 #define RECAPA(self, len, capa, ptr, type) \
   do {\
     if (self->len >= self->capa) {\
-      if (self->capa) {\
-        self->capa *= 2;\
+      if (self->capa > 0) {\
+        self->capa <<= 1;\
       } else {\
         self->capa = 4;\
       }\
@@ -55,10 +53,13 @@ typedef void (*free_ft)(void *key);
 #define Jx fprintf(stderr,"%s, %d: %s\n", __FILE__, __LINE__, __func__);
 #define Xj fprintf(stdout,"%s, %d: %s\n", __FILE__, __LINE__, __func__);
 
+extern char *progname();
+extern void setprogname(const char *str);
+
 extern void *emalloc(size_t n);
+extern void *ecalloc(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;
@@ -73,6 +74,23 @@ extern int max2(int a, int b);
 extern int max3(int a, int b, int c);
 
 extern char *dbl_to_s(char *buf, double num);
-extern void lower_str(char *str);
 extern char *strfmt(const char *fmt, ...);
+extern char *vstrfmt(const char *fmt, va_list args);
+
+/**
+ * A dummy function which can be passed to functions which expect a free
+ * function such as h_new() if you don't want the free functions to do anything.
+ * This function will do nothing.
+ *
+ * @param p the object which this function will be called on.
+ */
+extern void dummy_free(void *p);
+
+#ifdef DEBUG
+extern bool x_do_logging;
+#define xlog if (x_do_logging) printf
+#else
+#define xlog()
+#endif
+
 #endif

data/ext/hash.c

@@ -1,477 +1,560 @@
-#include <hash.h>
-#include <global.h>
+#include "hash.h"
+#include "global.h"
 #include <string.h>
 
-unsigned int hash(const char *str)
-{
-  register unsigned int h;
-  register unsigned char *p;
+/****************************************************************************
+ *
+ * HashTable
+ *
+ * This hash table is modeled after Python's dictobject and a description of
+ * the algorithm can be found in the file dictobject.c in Python's src
+ ****************************************************************************/
+
+static char *dummy_key = "";
 
-  h = 0;
-  for (p = (unsigned char *) str; *p != '\0'; p++)
-    h = MULTIPLIER * h + *p;
+#define PERTURB_SHIFT 5
+#define MAX_FREE_HASH_TABLES 80
 
-  return h % NUM_ENTRIES;
+static HashTable *free_hts[MAX_FREE_HASH_TABLES];
+static int num_free_hts = 0;
+
+ulong *imalloc(ulong value)
+{
+  ulong *p = ALLOC(ulong);
+  *p = value;
+  return p;
 }
 
-HashEntry **ht_create()
+ulong str_hash(const char *const str)
 {
-  int i;
-  HashEntry **new_ht = ALLOC_N(HashEntry *, NUM_ENTRIES);
+    register ulong h = 0;
+    register unsigned char *p = (unsigned char *) str;
 
-  for (i = 0; i < NUM_ENTRIES; i++)
-    new_ht[i] = NULL;
+    for (; *p; p++) {
+        h = 37 * h + *p;
+    }
 
-  return new_ht;
+    return h;
 }
 
-int ht_count(HashEntry **ht)
+static int int_eq(const void *q1, const void *q2)
 {
-  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)q1;
+    (void)q2;
+    return true;
 }
 
-void ht_destroy_all(HashEntry **ht, void (*fn)(void *))
+static ulong int_hash(const void *i)
 {
-  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);
+    return *((ulong *)i);
 }
 
-void ht_destroy(HashEntry **ht)
+typedef HashEntry *(*lookup_ft)(struct HashTable *ht, register const void *key);
+
+/**
+ * Fast lookup function for resizing as we know there are no equal elements or
+ * deletes to worry about.
+ *
+ * @param ht the HashTable to do the fast lookup in
+ * @param the hashkey we are looking for
+ */
+static inline HashEntry *h_resize_lookup(HashTable *ht, register const ulong hash)
 {
-  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);
+    register ulong perturb;
+    register int mask = ht->mask;
+    register HashEntry *he0 = ht->table;
+    register int i = hash & mask;
+    register HashEntry *he = &he0[i];
+
+    if (he->key == NULL) {
+        he->hash = hash;
+        return he;
+    }
+
+    for (perturb = hash;; perturb >>= PERTURB_SHIFT) {
+        i = (i << 2) + i + perturb + 1;
+        he = &he0[i & mask];
+        if (he->key == NULL) {
+            he->hash = hash;
+            return he;
+        }
+    }
 }
 
-void *ht_get(HashEntry **ht, char *name)
+HashEntry *h_lookup_int(HashTable *ht, const void *key)
 {
-  HashEntry *he;
-  int h = hash(name);
-
-  for (he = ht[h]; he != NULL; he = he->next) {
-    if (strcmp(name, he->name) == 0) {
-      return he->value;
+    register ulong hash = *((int *)key);
+    register ulong perturb;
+    register int mask = ht->mask;
+    register HashEntry *he0 = ht->table;
+    register int i = hash & mask;
+    register HashEntry *he = &he0[i];
+    register HashEntry *freeslot = NULL;
+
+    if (he->key == NULL || he->hash == hash) {
+        he->hash = hash;
+        return he;
+    }
+    if (he->key == dummy_key) {
+        freeslot = he;
     }
-  }
 
-  return 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->hash == hash) {
+            return he;
+        }
+        if (he->key == dummy_key && freeslot == NULL) {
+            freeslot = he;
+        }
+    }
 }
 
-void ht_set(HashEntry **ht, char *name, void *value)
+HashEntry *h_lookup_str(HashTable *ht, register const char *key)
 {
-  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;
+    register ulong hash = str_hash(key);
+    register ulong perturb;
+    register int mask = ht->mask;
+    register HashEntry *he0 = ht->table;
+    register int i = hash & mask;
+    register HashEntry *he = &he0[i];
+    register HashEntry *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;
+        }
+    }
 }
 
-void *ht_delete(HashEntry **ht, char *name)
+HashEntry *h_lookup(HashTable *ht, register const void *key)
 {
-  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;
+    register unsigned int hash = ht->hash_i(key);
+    register unsigned int perturb;
+    register int mask = ht->mask;
+    register HashEntry *he0 = ht->table;
+    register int i = hash & mask;
+    register HashEntry *he = &he0[i];
+    register HashEntry *freeslot;
+    eq_ft eq = ht->eq_i;
+
+    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;
+        }
+    }
 }
 
-/****************************************************************************
- *
- * HshTable
- *
- ****************************************************************************/
+HashTable *h_new_str(free_ft free_key, free_ft free_value)
+{
+    HashTable *ht;
+    if (num_free_hts > 0) {
+        ht = free_hts[--num_free_hts];
+    }
+    else {
+        ht = ALLOC(HashTable);
+    }
+    ht->fill = 0;
+    ht->size = 0;
+    ht->mask = HASH_MINSIZE - 1;
+    ht->table = ht->smalltable;
+    memset(ht->smalltable, 0, sizeof(ht->smalltable));
+    ht->lookup_i = (lookup_ft)&h_lookup_str;
+
+    ht->free_key_i = free_key != NULL ? free_key : &dummy_free;
+    ht->free_value_i = free_value != NULL ? free_value : &dummy_free;
+    return ht;
+}
 
-char *dummy_key = "";
+HashTable *h_new_int(free_ft free_value)
+{
+    HashTable *ht = h_new_str(NULL, free_value);
+    ht->lookup_i = &h_lookup_int;
+    ht->eq_i = int_eq;
+    ht->hash_i = int_hash;
+    return ht;
+}
 
-#define PERTURB_SHIFT 5
+HashTable *h_new(hash_ft hash, eq_ft eq, free_ft free_key, free_ft free_value)
+{
+    HashTable *ht = h_new_str(free_key, free_value);
 
-#ifdef VALGRIND
-#define MAX_FREE_HASH_TABLES 0
-#else
-#define MAX_FREE_HASH_TABLES 80
-#endif
+    ht->lookup_i = &h_lookup;
+    ht->eq_i = eq;
+    ht->hash_i = hash;
+    return ht;
+}
 
-static HshTable *free_hts[MAX_FREE_HASH_TABLES];
-static int num_free_hts = 0;
+void h_clear(HashTable *ht)
+{
+    int i;
+    HashEntry *he;
+    free_ft free_key = ht->free_key_i;
+    free_ft free_value = ht->free_value_i;
+
+    /* Clear all the hash values and keys as necessary */
+    if (free_key != dummy_free || free_value != dummy_free) {
+        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;
+        }
+    }
+    ZEROSET_N(ht->table, HashEntry, ht->mask + 1);
+    ht->size = 0;
+    ht->fill = 0;
+}
 
-inline unsigned int str_hash(const char *const str)
+void h_destroy(HashTable *ht)
 {
-  register unsigned int h=0;
-  register unsigned char *p = (unsigned char *)str;
+    h_clear(ht);
 
-  for (; *p; p++)
-    h = 37 * h + *p;
+    /* if a new table was created, be sure to free it */
+    if (ht->table != ht->smalltable) {
+        free(ht->table);
+    }
 
-  return h;
+#ifdef DEBUG
+    free(ht);
+#else
+    if (num_free_hts < MAX_FREE_HASH_TABLES) {
+        free_hts[num_free_hts++] = ht;
+    }
+    else {
+        free(ht);
+    }
+#endif
 }
 
-HshEntry *h_lookup_str(HshTable *ht, register const void *key_p)
+void *h_get(HashTable *ht, const void *key)
 {
-  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;
-  }
+    /* Note: lookup_i will never return NULL. */
+    return ht->lookup_i(ht, key)->value;
 }
 
-typedef int (*eq_func)(const void *key1, const void *key2);
-
-HshEntry *h_lookup(HshTable *ht, register const void *key)
+int h_del(HashTable *ht, 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;
-  }
+    HashEntry *he = ht->lookup_i(ht, key);
+
+    if (he->key != NULL && he->key != dummy_key) {
+        ht->free_key_i(he->key);
+        ht->free_value_i(he->value);
+        he->key = dummy_key;
+        he->value = NULL;
+        ht->size--;
+        return true;
+    }
+    else {
+        return false;
+    }
 }
 
-typedef void (*free_func)(void *);
-void dummy_free(void *p)
-{ }
+void *h_rem(HashTable *ht, const void *key, bool destroy_key)
+{
+    void *val;
+    HashEntry *he = ht->lookup_i(ht, key);
 
-HshTable *h_new_str(free_ft free_key, free_ft free_value)
+    if (he->key != NULL && he->key != dummy_key) {
+        if (destroy_key) {
+            ht->free_key_i(he->key);
+        }
+
+        he->key = dummy_key;
+        val = he->value;
+        he->value = NULL;
+        ht->size--;
+        return val;
+    }
+    else {
+        return NULL;
+    }
+}
+
+static int h_resize(HashTable *ht, int min_newsize)
 {
-  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;
+    HashEntry smallcopy[HASH_MINSIZE];
+    HashEntry *oldtable;
+    HashEntry *he_old, *he_new;
+    int newsize, num_active;
+
+    /* newsize will be a power of two */
+    for (newsize = HASH_MINSIZE; newsize < min_newsize; newsize <<= 1) {
+    }
+
+    oldtable = ht->table;
+    if (newsize == HASH_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(HashEntry, newsize);
+    }
+    memset(ht->table, 0, sizeof(HashEntry) * newsize);
+    ht->fill = ht->size;
+    ht->mask = newsize - 1;
+
+    for (num_active = ht->size, he_old = oldtable; num_active > 0; he_old++) {
+        if (he_old->key && he_old->key != dummy_key) {    /* active entry */
+            /*he_new = ht->lookup_i(ht, he_old->key); */
+            he_new = h_resize_lookup(ht, he_old->hash);
+            he_new->key = he_old->key;
+            he_new->value = he_old->value;
+            num_active--;
+        }                       /* else empty entry so nothing to do */
+    }
+    if (oldtable != smallcopy && oldtable != ht->smalltable) {
+        free(oldtable);
+    }
+    return 0;
 }
 
-HshTable *h_new(hash_ft hash, eq_ft eq, free_ft free_key, free_ft free_value)
+int h_set(HashTable *ht, const void *key, void *value)
 {
-  HshTable *ht = h_new_str(free_key, free_value);
+    int ret_val = HASH_KEY_DOES_NOT_EXIST;
+    HashEntry *he = ht->lookup_i(ht, key);
+    if (he->key == NULL) {
+        if (ht->fill * 3 > ht->mask * 2) {
+            h_resize(ht, ht->size * ((ht->size > SLOW_DOWN) ? 4 : 2));
+            he = ht->lookup_i(ht, key);
+        }
+        ht->fill++;
+        ht->size++;
+    }
+    else if (he->key == dummy_key) {
+        ht->size++;
+    }
+    else if (he->key != key) {
+        ht->free_key_i(he->key);
+        if (he->value != value) {
+            ht->free_value_i(he->value);
+        }
+        ret_val = HASH_KEY_EQUAL;
+    }
+    else {
+        /* safety check. Only free old value if it isn't the new value */
+        if (he->value != value) {
+            ht->free_value_i(he->value);
+        }
+        ret_val = HASH_KEY_SAME;
+    }
+    he->key = (void *)key;
+    he->value = value;
 
-  ht->lookup = &h_lookup;
-  ht->eq = eq;
-  ht->hash = hash;
-  return ht;
+    /*
+    if ((ht->fill > fill) && (ht->fill * 3 > ht->mask * 2)) {
+        h_resize(ht, ht->size * ((ht->size > SLOW_DOWN) ? 4 : 2));
+    }
+    */
+    return ret_val;
 }
 
-void h_clear(HshTable *ht)
+HashEntry *h_set_ext(HashTable *ht, const void *key)
 {
-  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;
-  /* for some reason the following line doesn't seem to help */
-  /* ZEROSET(ht->table, HshEntry, ht->mask + 1); */
+    HashEntry *he = ht->lookup_i(ht, key);
+    if (he->key == NULL) {
+        if (ht->fill * 3 > ht->mask * 2) {
+            h_resize(ht, ht->size * ((ht->size > SLOW_DOWN) ? 4 : 2));
+            he = ht->lookup_i(ht, key);
+        }
+        ht->fill++;
+        ht->size++;
+    }
+    else if (he->key == dummy_key) {
+        ht->size++;
+    }
+
+    return he;
 }
 
-void h_destroy(HshTable *ht)
+int h_set_safe(HashTable *ht, const void *key, void *value)
 {
-  h_clear(ht);
+    HashEntry *he = ht->lookup_i(ht, key);
+    int fill = ht->fill;
+    if (he->key == NULL) {
+        ht->fill++;
+        ht->size++;
+    }
+    else if (he->key == dummy_key) {
+        ht->size++;
+    }
+    else {
+        return false;
+    }
+    he->key = (void *)key;
+    he->value = value;
 
-  /* if a new table was created, be sure to free it */
-  if (ht->table != ht->smalltable) free(ht->table);
+    if ((ht->fill > fill) && (ht->fill * 3 > ht->mask * 2)) {
+        h_resize(ht, ht->size * ((ht->size > SLOW_DOWN) ? 4 : 2));
+    }
+    return true;
+}
 
-  if (num_free_hts < MAX_FREE_HASH_TABLES) {
-    free_hts[num_free_hts++] = ht;
-  } else {
-    free(ht);
-  }
+int h_has_key(HashTable *ht, const void *key)
+{
+    HashEntry *he = ht->lookup_i(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;
+    }
 }
 
-void *h_get(HshTable *ht, const void *key)
+void *h_get_int(HashTable *self, const ulong key)
 {
-  return ht->lookup(ht, key)->value;
+  return h_get(self, &key);
 }
 
-int h_del(HshTable *ht, const void *key)
+int h_del_int(HashTable *self, const ulong 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;
-  }
+  return h_del(self, &key);
 }
 
-void *h_rem(HshTable *ht, const void *key, bool destory_key)
+void *h_rem_int(HashTable *self, const ulong 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;
-  }
+  return h_rem(self, &key, false);
 }
 
-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->used;
-  ht->fill = ht->used;
-  ht->mask = newsize - 1;
-
-  for (he_old = oldtable; i > 0; he_old++) {
-    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 empty entry so nothing to do */
-  }
-  if (oldtable != smallcopy && oldtable != ht->smalltable)
-    free(oldtable);
-  return 0;
+int h_set_int(HashTable *self, const ulong key, void *value)
+{
+  return h_set(self, &key, value);
 }
 
-int h_set(HshTable *ht, const void *key, void *value)
+int h_set_safe_int(HashTable *self, const ulong 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;
+  return h_set_safe(self, &key, value);
 }
 
-int h_has_key(HshTable *ht, const void *key)
+int h_has_key_int(HashTable *self, const ulong 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;
-  }
+  return h_has_key(self, &key);
 }
 
-void h_each(HshTable *ht,
-    void (*each_kv)(void *key, void *value, void *arg),
-    void *arg)
+void h_each(HashTable *ht,
+            void (*each_kv) (void *key, void *value, void *arg), void *arg)
 {
-  HshEntry *he;
-  int i = ht->used;
-  for (he = ht->table; i > 0; he++) {
-    if (he->value != NULL) {/* active entry */
-      each_kv(he->key, he->value, arg);
-      i--;
-    }
-  }
+    HashEntry *he;
+    int i = ht->size;
+    for (he = ht->table; i > 0; he++) {
+        if (he->key && he->key != dummy_key) {        /* active entry */
+            each_kv(he->key, he->value, arg);
+            i--;
+        }
+    }
 }
 
-HshTable *h_clone(HshTable *ht,
-    h_clone_func_t clone_key,
-    h_clone_func_t clone_value)
+HashTable *h_clone(HashTable *ht,
+                   h_clone_func_t clone_key, h_clone_func_t clone_value)
 {
-  void *key, *value;
-  HshEntry *he;
-  int i = ht->used;
-  HshTable *ht_clone;
-
-  if (ht->lookup == &h_lookup_str) {
-    ht_clone = h_new_str(ht->free_key, ht->free_value);
-  } else {
-    ht_clone = h_new(ht->hash, ht->eq, ht->free_key, ht->free_value);
-  }
-
-  for (he = ht->table; i > 0; he++) {
-    if (he->value != NULL) {/* active entry */
-      key = clone_key ? clone_key(he->key) : he->key;
-      value = clone_value ? clone_value(he->value) : he->value;
-      h_set(ht_clone, key, value);
-      i--;
-    }
-  }
-  return ht_clone;
+    void *key, *value;
+    HashEntry *he;
+    int i = ht->size;
+    HashTable *ht_clone;
+
+    if (ht->lookup_i == (lookup_ft)&h_lookup_str) {
+        ht_clone = h_new_str(ht->free_key_i, ht->free_value_i);
+    }
+    else {
+        ht_clone = h_new(ht->hash_i, ht->eq_i, ht->free_key_i, ht->free_value_i);
+    }
+
+    for (he = ht->table; i > 0; he++) {
+        if (he->key && he->key != dummy_key) {        /* active entry */
+            key = clone_key ? clone_key(he->key) : he->key;
+            value = clone_value ? clone_value(he->value) : he->value;
+            h_set(ht_clone, key, value);
+            i--;
+        }
+    }
+    return ht_clone;
 }
 
+void h_str_print_keys(HashTable *ht)
+{
+    HashEntry *he;
+    int i = ht->size;
+    printf("keys:\n");
+    for (he = ht->table; i > 0; he++) {
+        if (he->key && he->key != dummy_key) {        /* active entry */
+            printf("\t%s\n", (char *)he->key);
+            i--;
+        }
+    }
+}