ferret 0.11.6 → 0.11.8.4

data/ext/global.h

@@ -1,50 +1,80 @@
 #ifndef FRT_GLOBAL_H
 #define FRT_GLOBAL_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "config.h"
 #include "except.h"
 #include "lang.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <string.h>
+
+#define FRT_MAX_WORD_SIZE 255
+#define FRT_MAX_FILE_PATH 1024
+#define FRT_BUFFER_SIZE 1024
+
+#define FRT_DBL2S "%#.7g"
+
+#if defined(__GNUC__) && !defined(__cplusplus)
+#  define FRT_INLINE
+#else
+#  define FRT_INLINE
+#endif
 
-#define MAX_WORD_SIZE 255
-#define MAX_FILE_PATH 1024
+#if __GNUC__ >= 3
+#  define FRT_ATTR_ALWAYS_INLINE inline __attribute__ ((always_inline))
+#  define FRT_ATTR_MALLOC               __attribute__ ((malloc))
+#  define FRT_ATTR_PURE                 __attribute__ ((pure))
+#  define FRT_ATTR_CONST                __attribute__ ((const))
+#  define likely(x)   __builtin_expect(!!(x), 1)
+#  define unlikely(x) __builtin_expect(!!(x), 0)
+#else
+#  define FRT_ATTR_ALWAYS_INLINE
+#  define FRT_ATTR_MALLOC
+#  define FRT_ATTR_PURE
+#  define FRT_ATTR_CONST
+#  define likely(x)   (x)
+#  define unlikely(x) (x)
+#endif
 
-#if defined(__GNUC__)
-# define INLINE __inline__
+#ifdef __cplusplus
+#define FRT_EXTERNC extern "C"
 #else
-# define INLINE
+#define FRT_EXTERNC
 #endif
 
-typedef void (*free_ft)(void *key);
+typedef void (*frt_free_ft)(void *key);
 
-#define NELEMS(array) ((int)(sizeof(array)/sizeof(array[0])))
+#define FRT_NELEMS(array) ((int)(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 FRT_ZEROSET(ptr, type) memset(ptr, 0, sizeof(type))
+#define FRT_ZEROSET_N(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*)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 FRT_ALLOC_AND_ZERO(type) (type*)frt_ecalloc(sizeof(type))
+#define FRT_ALLOC_AND_ZERO_N(type,n) (type*)frt_ecalloc(sizeof(type)*(n))
 
-#define REF(a) (a)->ref_cnt++
-#define DEREF(a) (a)->ref_cnt--
+#define FRT_REF(a) (a)->ref_cnt++
+#define FRT_DEREF(a) (a)->ref_cnt--
 
-#define NEXT_NUM(index, size) (((index) + 1) % (size))
-#define PREV_NUM(index, size) (((index) + (size) - 1) % (size))
+#define FRT_NEXT_NUM(index, size) (((index) + 1) % (size))
+#define FRT_PREV_NUM(index, size) (((index) + (size) - 1) % (size))
 
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define FRT_MIN(a, b) ((a) < (b) ? (a) : (b))
+#define FRT_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 FRT_MIN3(a, b, c) ((a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)))
+#define FRT_MAX3(a, b, c) ((a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c)))
 
-#define RECAPA(self, len, capa, ptr, type) \
+#define FRT_ABS(n) ((n >= 0) ? n : -n)
+#define FRT_TO_WORD(n) (((n - 1) >> 5) + 1)
+
+#define FRT_RECAPA(self, len, capa, ptr, type) \
   do {\
     if (self->len >= self->capa) {\
       if (self->capa > 0) {\
@@ -52,7 +82,7 @@ typedef void (*free_ft)(void *key);
       } else {\
         self->capa = 4;\
       }\
-      REALLOC_N(self->ptr, type, self->capa);\
+      self->ptr = (type *)frt_erealloc(self->ptr, sizeof(type) * self->capa);\
     }\
   } while (0)
 
@@ -64,39 +94,37 @@ typedef void (*free_ft)(void *key);
 # define Xj fprintf(stdout,"%s, %d: %s\n", __FILE__, __LINE__, __func__);
 #endif
 
-extern char *progname();
-extern void setprogname(const char *str);
-
-extern unsigned int *imalloc(unsigned int value);
-extern unsigned long *lmalloc(unsigned long value);
-extern f_u32 *u32malloc(f_u32 value);
-extern f_u64 *u64malloc(f_u64 value);
+extern unsigned int *frt_imalloc(unsigned int value);
+extern unsigned long *frt_lmalloc(unsigned long value);
+extern frt_u32 *frt_u32malloc(frt_u32 value);
+extern frt_u64 *frt_u64malloc(frt_u64 value);
 
-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 *estrcat(char *str, char *str_cat);
+extern char *frt_estrdup(const char *s);
+extern char *frt_estrcat(char *str, char *str_cat);
+extern void frt_weprintf(const char *fmt, ...);
+extern char *frt_epstrdup(const char *fmt, int len, ...);
 
-extern const char *EMPTY_STRING;
+extern const char *FRT_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);
+extern int frt_scmp(const void *p1, const void *p2);
+extern int frt_icmp(const void *p1, const void *p2);
+extern int frt_icmp_risky(const void *p1, const void *p2);
+extern void frt_strsort(char **string_array, int size);
 
-extern int min2(int a, int b);
-extern int min3(int a, int b, int c);
-extern int max2(int a, int b);
-extern int max3(int a, int b, int c);
+extern int frt_min2(int a, int b);
+extern int frt_min3(int a, int b, int c);
+extern int frt_max2(int a, int b);
+extern int frt_max3(int a, int b, int c);
 
-extern char *dbl_to_s(char *buf, double num);
-extern char *strfmt(const char *fmt, ...);
-extern char *vstrfmt(const char *fmt, va_list args);
+extern char *frt_dbl_to_s(char *buf, double num);
+extern char *frt_strfmt(const char *fmt, ...);
+extern char *frt_vstrfmt(const char *fmt, va_list args);
 
-extern void micro_sleep(const int micro_seconds);
+extern char *frt_get_stacktrace();
+extern void  frt_print_stacktrace();
 
-extern void register_for_cleanup(void *p, free_ft free_func);
-extern void do_clean_up();
+extern void frt_register_for_cleanup(void *p, frt_free_ft free_func);
+extern void frt_do_clean_up();
 
 /**
  * A dummy function which can be passed to functions which expect a free
@@ -105,13 +133,183 @@ extern void do_clean_up();
  *
  * @param p the object which this function will be called on.
  */
-extern void dummy_free(void *p);
+extern void frt_dummy_free(void *p);
+
+/**
+ * Returns the count of leading [MSB] 0 bits in +word+.
+ */
+static FRT_ATTR_ALWAYS_INLINE FRT_ATTR_CONST
+int frt_count_leading_zeros(frt_u32 word)
+{
+#ifdef __GNUC__
+    if (word)
+        return __builtin_clz(word);
+    return 32;
+#else
+    static const int count_leading_zeros[] = {
+        8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
+        3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+                if (word & 0xff) return count_leading_zeros[word & 0xff];
+    word >>= 8; if (word & 0xff) return count_leading_zeros[word & 0xff] + 8;
+    word >>= 8; if (word & 0xff) return count_leading_zeros[word & 0xff] + 16;
+    word >>= 8;                  return count_leading_zeros[word & 0xff] + 24;
+#endif
+}
+
+static FRT_ATTR_ALWAYS_INLINE FRT_ATTR_CONST
+int frt_count_leading_ones(frt_u32 word)
+{
+    return frt_count_leading_zeros(~word);
+}
+
+/**
+ * Return the count of trailing [LSB] 0 bits in +word+.
+ */
+
+static FRT_ATTR_ALWAYS_INLINE FRT_ATTR_CONST
+int frt_count_trailing_zeros(frt_u32 word)
+{
+#ifdef __GNUC__
+    if (word)
+        return __builtin_ctz(word);
+    return 32;
+#else
+    static const int count_trailing_zeros[] = {
+        8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+        4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
+    };
+                if (word & 0xff) return count_trailing_zeros[word & 0xff];
+    word >>= 8; if (word & 0xff) return count_trailing_zeros[word & 0xff] + 8;
+    word >>= 8; if (word & 0xff) return count_trailing_zeros[word & 0xff] + 16;
+    word >>= 8;                  return count_trailing_zeros[word & 0xff] + 24;
+#endif
+}
+
+static FRT_ATTR_ALWAYS_INLINE FRT_ATTR_CONST
+int frt_count_trailing_ones(frt_u32 word)
+{
+    return frt_count_trailing_zeros(~word);
+}
+
+static FRT_ATTR_ALWAYS_INLINE FRT_ATTR_CONST
+int frt_count_ones(frt_u32 word)
+{
+#ifdef __GNUC__
+    return __builtin_popcount(word);
+#else
+    static const frt_uchar count_ones[] = {
+        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
+    };
+    return count_ones[(word      ) & 0xff]
+        +  count_ones[(word >> 8 ) & 0xff]
+        +  count_ones[(word >> 16) & 0xff]
+        +  count_ones[(word >> 24) & 0xff];
+#endif
+}
+
+static FRT_ATTR_ALWAYS_INLINE FRT_ATTR_CONST
+int frt_count_zeros(frt_u32 word)
+{
+    return frt_count_ones(~word);
+}
+
+/**
+ * Round up to the next power of 2
+ */
+static FRT_ATTR_ALWAYS_INLINE FRT_ATTR_CONST
+int frt_round2(frt_u32 word)
+{
+    return 1 << (32 - frt_count_leading_zeros(word));
+}
+
+/**
+ * For coverage, we don't want FRT_XEXIT to actually exit on uncaught
+ * exceptions.  +frt_x_abort_on_exception+ is +true+ by default, set it to
+ * +false+, and +frt_x_has_aborted+ will be set as appropriate.  We also
+ * don't want spurious errors to be printed out to stderr, so we give
+ * the option to set where errors go to with +frt_x_exception_stream+.
+ */
+
+extern bool  frt_x_abort_on_exception;
+extern bool  frt_x_has_aborted;
+extern FILE *frt_x_exception_stream;
+
+/**
+ * The convenience macro +EXCEPTION_STREAM+ returns stderr when
+ * +frt_x_exception_stream+ isn't explicitely set.
+ */
+#define EXCEPTION_STREAM (frt_x_exception_stream ? frt_x_exception_stream : stderr)
 
 #ifdef DEBUG
-extern bool x_do_logging;
-#define xlog if (x_do_logging) printf
+extern bool frt_x_do_logging;
+#define xlog if (frt_x_do_logging) printf
 #else
 #define xlog()
 #endif
 
+extern void frt_init(int arc, const char *const argv[]);
+extern void frt_setprogname(const char *str);
+extern const char *frt_progname();
+extern void frt_micro_sleep(const int micro_seconds);
+extern void frt_clean_up();
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+
+/**
+ * For general use during testing. Switch this on and off for print statements
+ * to only print when p_on is called and not after p_off is called
+ */
+extern void p(const char *format, ...);
+extern void p_on();
+extern void p_off();
+extern void p_pause();
+extern void p_resume();
+
 #endif

data/ext/hash.c

@@ -1,27 +1,30 @@
 #include "hash.h"
 #include "global.h"
 #include <string.h>
+#include "internal.h"
 
 /****************************************************************************
  *
- * HashTable
+ * Hash
  *
  * 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 = "";
+static char *dummy_int_key = "i";
+
 
 #define PERTURB_SHIFT 5
 #define MAX_FREE_HASH_TABLES 80
 
-static HashTable *free_hts[MAX_FREE_HASH_TABLES];
+static Hash *free_hts[MAX_FREE_HASH_TABLES];
 static int num_free_hts = 0;
 
 unsigned long str_hash(const char *const str)
 {
     register unsigned long h = 0;
-    register unsigned char *p = (unsigned char *) str;
+    register unsigned char *p = (unsigned char *)str;
 
     for (; *p; p++) {
         h = 37 * h + *p;
@@ -40,33 +43,26 @@ int ptr_eq(const void *q1, const void *q2)
     return q1 == q2;
 }
 
-static int int_eq(const void *q1, const void *q2)
-{
-    (void)q1;
-    (void)q2;
-    return true;
-}
-
-static unsigned long int_hash(const void *i)
+static int str_eq(const void *q1, const void *q2)
 {
-    return *((unsigned long *)i);
+    return strcmp((const char *)q1, (const char *)q2) == 0;
 }
 
-typedef HashEntry *(*lookup_ft)(struct HashTable *ht, register const void *key);
+typedef HashEntry *(*lookup_ft)(struct Hash *self, 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 self the Hash to do the fast lookup in
  * @param the hashkey we are looking for
  */
-static INLINE HashEntry *h_resize_lookup(HashTable *ht,
-                                           register const unsigned long hash)
+static INLINE HashEntry *h_resize_lookup(Hash *self,
+                                         register const unsigned long hash)
 {
     register unsigned long perturb;
-    register int mask = ht->mask;
-    register HashEntry *he0 = ht->table;
+    register int mask = self->mask;
+    register HashEntry *he0 = self->table;
     register int i = hash & mask;
     register HashEntry *he = &he0[i];
 
@@ -85,12 +81,12 @@ static INLINE HashEntry *h_resize_lookup(HashTable *ht,
     }
 }
 
-HashEntry *h_lookup_int(HashTable *ht, const void *key)
+static HashEntry *h_lookup_ptr(Hash *self, const void *key)
 {
-    register unsigned long hash = *((int *)key);
+    register const unsigned long hash = (long)key;
     register unsigned long perturb;
-    register int mask = ht->mask;
-    register HashEntry *he0 = ht->table;
+    register int mask = self->mask;
+    register HashEntry *he0 = self->table;
     register int i = hash & mask;
     register HashEntry *he = &he0[i];
     register HashEntry *freeslot = NULL;
@@ -122,61 +118,16 @@ HashEntry *h_lookup_int(HashTable *ht, const void *key)
     }
 }
 
-HashEntry *h_lookup_str(HashTable *ht, register const char *key)
+HashEntry *h_lookup(Hash *self, register const void *key)
 {
-    register unsigned long hash = str_hash(key);
+    register const unsigned long hash = self->hash_i(key);
     register unsigned long perturb;
-    register int mask = ht->mask;
-    register HashEntry *he0 = ht->table;
+    register int mask = self->mask;
+    register HashEntry *he0 = self->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;
-        }
-    }
-}
-
-HashEntry *h_lookup(HashTable *ht, register const void *key)
-{
-    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;
+    register HashEntry *freeslot = NULL;
+    eq_ft eq = self->eq_i;
 
     if (he->key == NULL || he->key == key) {
         he->hash = hash;
@@ -189,7 +140,6 @@ HashEntry *h_lookup(HashTable *ht, register const void *key)
         if ((he->hash == hash) && eq(he->key, key)) {
             return he;
         }
-        freeslot = NULL;
     }
 
     for (perturb = hash;; perturb >>= PERTURB_SHIFT) {
@@ -213,58 +163,63 @@ HashEntry *h_lookup(HashTable *ht, register const void *key)
     }
 }
 
-HashTable *h_new_str(free_ft free_key, free_ft free_value)
+Hash *h_new_str(free_ft free_key, free_ft free_value)
 {
-    HashTable *ht;
+    Hash *self;
     if (num_free_hts > 0) {
-        ht = free_hts[--num_free_hts];
+        self = 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;
-    ht->ref_cnt = 1;
-    return ht;
+        self = ALLOC(Hash);
+    }
+    self->fill = 0;
+    self->size = 0;
+    self->mask = HASH_MINSIZE - 1;
+    self->table = self->smalltable;
+    memset(self->smalltable, 0, sizeof(self->smalltable));
+    self->lookup_i = (lookup_ft)&h_lookup;
+    self->eq_i = str_eq;
+    self->hash_i = (hash_ft)str_hash;
+
+    self->free_key_i = free_key != NULL ? free_key : &dummy_free;
+    self->free_value_i = free_value != NULL ? free_value : &dummy_free;
+    self->ref_cnt = 1;
+    return self;
 }
 
-HashTable *h_new_int(free_ft free_value)
+Hash *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;
+    Hash *self     = h_new_str(NULL, free_value);
+
+    self->lookup_i = &h_lookup_ptr;
+    self->eq_i     = NULL;
+    self->hash_i   = NULL;
+
+    return self;
 }
 
-HashTable *h_new(hash_ft hash, eq_ft eq, free_ft free_key, free_ft free_value)
+Hash *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);
+    Hash *self     = h_new_str(free_key, free_value);
 
-    ht->lookup_i = &h_lookup;
-    ht->eq_i = eq;
-    ht->hash_i = hash;
-    return ht;
+    self->lookup_i = &h_lookup;
+    self->eq_i     = eq;
+    self->hash_i   = hash;
+
+    return self;
 }
 
-void h_clear(HashTable *ht)
+void h_clear(Hash *self)
 {
     int i;
     HashEntry *he;
-    free_ft free_key = ht->free_key_i;
-    free_ft free_value = ht->free_value_i;
+    free_ft free_key   = self->free_key_i;
+    free_ft free_value = self->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];
+        for (i = 0; i <= self->mask; i++) {
+            he = &self->table[i];
             if (he->key != NULL && he->key != dummy_key) {
                 free_value(he->value);
                 free_key(he->key);
@@ -272,50 +227,46 @@ void h_clear(HashTable *ht)
             he->key = NULL;
         }
     }
-    ZEROSET_N(ht->table, HashEntry, ht->mask + 1);
-    ht->size = 0;
-    ht->fill = 0;
+    ZEROSET_N(self->table, HashEntry, self->mask + 1);
+    self->size = 0;
+    self->fill = 0;
 }
 
-void h_destroy(HashTable *ht)
+void h_destroy(Hash *self)
 {
-    if (--(ht->ref_cnt) <= 0) {
-        h_clear(ht);
+    if (--(self->ref_cnt) <= 0) {
+        h_clear(self);
 
         /* if a new table was created, be sure to free it */
-        if (ht->table != ht->smalltable) {
-            free(ht->table);
+        if (self->table != self->smalltable) {
+            free(self->table);
         }
 
-#ifdef DEBUG
-        free(ht);
-#else
         if (num_free_hts < MAX_FREE_HASH_TABLES) {
-            free_hts[num_free_hts++] = ht;
+            free_hts[num_free_hts++] = self;
         }
         else {
-            free(ht);
+            free(self);
         }
-#endif
     }
 }
 
-void *h_get(HashTable *ht, const void *key)
+void *h_get(Hash *self, const void *key)
 {
     /* Note: lookup_i will never return NULL. */
-    return ht->lookup_i(ht, key)->value;
+    return self->lookup_i(self, key)->value;
 }
 
-int h_del(HashTable *ht, const void *key)
+int h_del(Hash *self, const void *key)
 {
-    HashEntry *he = ht->lookup_i(ht, key);
+    HashEntry *he = self->lookup_i(self, key);
 
     if (he->key != NULL && he->key != dummy_key) {
-        ht->free_key_i(he->key);
-        ht->free_value_i(he->value);
+        self->free_key_i(he->key);
+        self->free_value_i(he->value);
         he->key = dummy_key;
         he->value = NULL;
-        ht->size--;
+        self->size--;
         return true;
     }
     else {
@@ -323,20 +274,20 @@ int h_del(HashTable *ht, const void *key)
     }
 }
 
-void *h_rem(HashTable *ht, const void *key, bool destroy_key)
+void *h_rem(Hash *self, const void *key, bool destroy_key)
 {
     void *val;
-    HashEntry *he = ht->lookup_i(ht, key);
+    HashEntry *he = self->lookup_i(self, key);
 
     if (he->key != NULL && he->key != dummy_key) {
         if (destroy_key) {
-            ht->free_key_i(he->key);
+            self->free_key_i(he->key);
         }
 
         he->key = dummy_key;
         val = he->value;
         he->value = NULL;
-        ht->size--;
+        self->size--;
         return val;
     }
     else {
@@ -344,7 +295,7 @@ void *h_rem(HashTable *ht, const void *key, bool destroy_key)
     }
 }
 
-static int h_resize(HashTable *ht, int min_newsize)
+static int h_resize(Hash *self, int min_newsize)
 {
     HashEntry smallcopy[HASH_MINSIZE];
     HashEntry *oldtable;
@@ -355,171 +306,167 @@ static int h_resize(HashTable *ht, int min_newsize)
     for (newsize = HASH_MINSIZE; newsize < min_newsize; newsize <<= 1) {
     }
 
-    oldtable = ht->table;
+    oldtable = self->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
+        if (self->table == self->smalltable) {
+            /* need to copy the data out so we can rebuild the table into
              * the same space */
-            memcpy(smallcopy, ht->smalltable, sizeof(smallcopy));
+            memcpy(smallcopy, self->smalltable, sizeof(smallcopy));
             oldtable = smallcopy;
         }
         else {
-            ht->table = ht->smalltable;
+            self->table = self->smalltable;
         }
     }
     else {
-        ht->table = ALLOC_N(HashEntry, newsize);
+        self->table = ALLOC_N(HashEntry, newsize);
     }
-    memset(ht->table, 0, sizeof(HashEntry) * newsize);
-    ht->fill = ht->size;
-    ht->mask = newsize - 1;
+    memset(self->table, 0, sizeof(HashEntry) * newsize);
+    self->fill = self->size;
+    self->mask = newsize - 1;
 
-    for (num_active = ht->size, he_old = oldtable; num_active > 0; he_old++) {
+    for (num_active = self->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 = self->lookup_i(self, he_old->key); */
+            he_new = h_resize_lookup(self, 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) {
+    if (oldtable != smallcopy && oldtable != self->smalltable) {
         free(oldtable);
     }
     return 0;
 }
 
-int h_set(HashTable *ht, const void *key, void *value)
+INLINE bool h_set_ext(Hash *self, const void *key, HashEntry **he)
 {
-    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);
+    *he = self->lookup_i(self, key);
+    if ((*he)->key == NULL) {
+        if (self->fill * 3 > self->mask * 2) {
+            h_resize(self, self->size * ((self->size > SLOW_DOWN) ? 4 : 2));
+            *he = self->lookup_i(self, key);
         }
-        ret_val = HASH_KEY_EQUAL;
+        self->fill++;
+        self->size++;
+        return true;
     }
-    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;
+    else if ((*he)->key == dummy_key) {
+        self->size++;
+        return true;
     }
-    he->key = (void *)key;
-    he->value = value;
 
-    /*
-    if ((ht->fill > fill) && (ht->fill * 3 > ht->mask * 2)) {
-        h_resize(ht, ht->size * ((ht->size > SLOW_DOWN) ? 4 : 2));
-    }
-    */
-    return ret_val;
+    return false;
 }
 
-HashEntry *h_set_ext(HashTable *ht, const void *key)
+HashKeyStatus h_set(Hash *self, const void *key, void *value)
 {
-    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);
+    HashKeyStatus ret_val = HASH_KEY_DOES_NOT_EXIST;
+    HashEntry *he;
+    if (!h_set_ext(self, key, &he)) {
+        if (he->key != key) {
+            self->free_key_i(he->key);
+            if (he->value != value) {
+                self->free_value_i(he->value);
+            }
+            ret_val = HASH_KEY_EQUAL;
+        }
+        else {
+            /* Only free old value if it isn't the new value */
+            if (he->value != value) {
+                self->free_value_i(he->value);
+            }
+            ret_val = HASH_KEY_SAME;
         }
-        ht->fill++;
-        ht->size++;
-    }
-    else if (he->key == dummy_key) {
-        ht->size++;
     }
+    he->key = (void *)key;
+    he->value = value;
 
-    return he;
+    return ret_val;
 }
 
-int h_set_safe(HashTable *ht, const void *key, void *value)
+int h_set_safe(Hash *self, const void *key, void *value)
 {
-    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++;
+    HashEntry *he;
+    if (h_set_ext(self, key, &he)) {
+        he->key = (void *)key;
+        he->value = value;
+        return true;
     }
     else {
         return false;
     }
-    he->key = (void *)key;
-    he->value = value;
-
-    if ((ht->fill > fill) && (ht->fill * 3 > ht->mask * 2)) {
-        h_resize(ht, ht->size * ((ht->size > SLOW_DOWN) ? 4 : 2));
-    }
-    return true;
 }
 
-int h_has_key(HashTable *ht, const void *key)
+HashKeyStatus h_has_key(Hash *self, const void *key)
 {
-    HashEntry *he = ht->lookup_i(ht, key);
+    HashEntry *he = self->lookup_i(self, 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 HASH_KEY_EQUAL;
 }
 
-void *h_get_int(HashTable *self, const unsigned long key)
+INLINE void *h_get_int(Hash *self, const unsigned long key)
 {
-  return h_get(self, &key);
+    return h_get(self, (const void *)key);
 }
 
-int h_del_int(HashTable *self, const unsigned long key)
+INLINE int h_del_int(Hash *self, const unsigned long key)
 {
-  return h_del(self, &key);
+    return h_del(self, (const void *)key);
 }
 
-void *h_rem_int(HashTable *self, const unsigned long key)
+INLINE void *h_rem_int(Hash *self, const unsigned long key)
 {
-  return h_rem(self, &key, false);
+    return h_rem(self, (const void *)key, false);
 }
 
-int h_set_int(HashTable *self, const unsigned long key, void *value)
+INLINE HashKeyStatus h_set_int(Hash *self,
+                               const unsigned long key,
+                               void *value)
 {
-  return h_set(self, &key, value);
+    HashKeyStatus ret_val = HASH_KEY_DOES_NOT_EXIST;
+    HashEntry *he;
+    if (!h_set_ext(self, (const void *)key, &he)) {
+        /* Only free old value if it isn't the new value */
+        if (he->value != value) {
+            self->free_value_i(he->value);
+        }
+        ret_val = HASH_KEY_EQUAL;
+    }
+    he->key = dummy_int_key;
+    he->value = value;
+
+    return ret_val;
 }
 
-int h_set_safe_int(HashTable *self, const unsigned long key, void *value)
+INLINE int h_set_safe_int(Hash *self, const unsigned long key, void *value)
 {
-  return h_set_safe(self, &key, value);
+    HashEntry *he;
+    if (h_set_ext(self, (const void *)key, &he)) {
+        he->key = dummy_int_key;
+        he->value = value;
+        return true;
+    }
+    return false;
 }
 
-int h_has_key_int(HashTable *self, const unsigned long key)
+INLINE int h_has_key_int(Hash *self, const unsigned long key)
 {
-  return h_has_key(self, &key);
+    return h_has_key(self, (const void *)key);
 }
 
-void h_each(HashTable *ht,
+void h_each(Hash *self,
             void (*each_kv) (void *key, void *value, void *arg), void *arg)
 {
     HashEntry *he;
-    int i = ht->size;
-    for (he = ht->table; i > 0; he++) {
+    int i = self->size;
+    for (he = self->table; i > 0; he++) {
         if (he->key && he->key != dummy_key) {        /* active entry */
             each_kv(he->key, he->value, arg);
             i--;
@@ -527,22 +474,19 @@ void h_each(HashTable *ht,
     }
 }
 
-HashTable *h_clone(HashTable *ht,
-                   h_clone_func_t clone_key, h_clone_func_t clone_value)
+Hash *h_clone(Hash *self, h_clone_ft clone_key, h_clone_ft clone_value)
 {
     void *key, *value;
     HashEntry *he;
-    int i = ht->size;
-    HashTable *ht_clone;
+    int i = self->size;
+    Hash *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);
-    }
+    ht_clone = h_new(self->hash_i,
+                     self->eq_i,
+                     self->free_key_i,
+                     self->free_value_i);
 
-    for (he = ht->table; i > 0; he++) {
+    for (he = self->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;
@@ -553,15 +497,28 @@ HashTable *h_clone(HashTable *ht,
     return ht_clone;
 }
 
-void h_str_print_keys(HashTable *ht)
+void h_str_print_keys(Hash *self, FILE *out)
 {
     HashEntry *he;
-    int i = ht->size;
-    printf("keys:\n");
-    for (he = ht->table; i > 0; he++) {
+    int i = self->size;
+    char **keys = ALLOC_N(char *, self->size);
+    for (he = self->table; i > 0; he++) {
         if (he->key && he->key != dummy_key) {        /* active entry */
-            printf("\t%s\n", (char *)he->key);
             i--;
+            keys[i] = (char *)he->key;
         }
     }
+    strsort(keys, self->size);
+    fprintf(out, "keys:\n");
+    for (i = 0; i < self->size; i++) {
+        fprintf(out, "\t%s\n", keys[i]);
+    }
+    free(keys);
+}
+
+void hash_finalize()
+{
+    while (num_free_hts > 0) {
+        free(free_hts[--num_free_hts]);
+    }
 }