isomorfeus-ferret 0.12.0

data/ext/isomorfeus_ferret_ext/frt_global.c

@@ -0,0 +1,427 @@
+#include "frt_global.h"
+#include "frt_hash.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <math.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <signal.h>
+
+const char *FRT_EMPTY_STRING = "";
+
+int frt_scmp(const void *p1, const void *p2)
+{
+    return strcmp(*(char **) p1, *(char **) p2);
+}
+
+void frt_strsort(char **str_array, int size)
+{
+    qsort(str_array, size, sizeof(char *), &frt_scmp);
+}
+
+int frt_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;
+}
+
+int frt_icmp_risky(const void *p1, const void *p2)
+{
+  return (*(int *)p1) - *((int *)p2);
+}
+
+unsigned int *frt_imalloc(unsigned int value)
+{
+  unsigned int *p = FRT_ALLOC(unsigned int);
+  *p = value;
+  return p;
+}
+
+unsigned long *frt_lmalloc(unsigned long value)
+{
+  unsigned long *p = FRT_ALLOC(unsigned long);
+  *p = value;
+  return p;
+}
+
+frt_u32 *frt_u32malloc(frt_u32 value)
+{
+  frt_u32 *p = FRT_ALLOC(frt_u32);
+  *p = value;
+  return p;
+}
+
+frt_u64 *frt_u64malloc(frt_u64 value)
+{
+  frt_u64 *p = FRT_ALLOC(frt_u64);
+  *p = value;
+  return p;
+}
+
+/* concatenate two strings freeing the second */
+char *frt_estrcat(char *str1, char *str2)
+{
+    size_t len1 = strlen(str1);
+    size_t len2 = strlen(str2);
+    FRT_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 *frt_epstrdup(const char *fmt, int len, ...)
+{
+    char *string;
+    va_list args;
+    len += (int) strlen(fmt);
+
+    string = FRT_ALLOC_N(char, len + 1);
+    va_start(args, len);
+    vsprintf(string, fmt, args);
+    va_end(args);
+
+    return string;
+}
+
+/* frt_estrdup: duplicate a string, report if error */
+char *frt_estrdup(const char *s)
+{
+    char *t = FRT_ALLOC_N(char, strlen(s) + 1);
+    strcpy(t, s);
+    return t;
+}
+
+/* Pretty print a float to the buffer. The buffer should have at least 32
+ * bytes available.
+ */
+char *frt_dbl_to_s(char *buf, double num)
+{
+    char *p, *e;
+
+#ifdef FRT_IS_C99
+    if (isinf(num)) {
+        return frt_estrdup(num < 0 ? "-Infinity" : "Infinity");
+    }
+    else if (isnan(num)) {
+        return frt_estrdup("NaN");
+    }
+#endif
+
+    sprintf(buf, FRT_DBL2S, 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;
+}
+
+/**
+ * frt_strapp: appends a string up to, but not including the \0 character to the
+ * end of a string returning a pointer to the next unassigned character in the
+ * string.
+ */
+char *frt_strapp(char *dst, const char *src) {
+    while (*src != '\0') {
+        *dst = *src;
+        ++dst;
+        ++src;
+    }
+    return dst;
+}
+
+/* strfmt: like sprintf except that it allocates memory for the string */
+char *frt_vstrfmt(const char *fmt, va_list args)
+{
+    char *string;
+    char *p = (char *) fmt, *q;
+    int len = (int) strlen(fmt) + 1;
+    int slen, curlen;
+    const char *s;
+    long l;
+    double d;
+
+    q = string = FRT_ALLOC_N(char, len);
+
+    while (*p) {
+        if (*p == '%') {
+            p++;
+            switch (*p) {
+            case 's':
+                p++;
+                s = va_arg(args, char *);
+                /* to be consistent with printf print (null) for NULL */
+                if (!s) {
+                    s = "(null)";
+                }
+                slen = (int) strlen(s);
+                len += slen;
+                curlen = q - string;
+                FRT_REALLOC_N(string, char, len);
+                q = string + curlen;
+                memcpy(q, s, slen);
+                q += slen;
+                continue;
+            case 'f':
+                p++;
+                len += 32;
+                *q = 0;
+                FRT_REALLOC_N(string, char, len);
+                q = string + strlen(string);
+                d = va_arg(args, double);
+                frt_dbl_to_s(q, d);
+                q += strlen(q);
+                continue;
+            case 'd':
+                p++;
+                len += 20;
+                *q = 0;
+                FRT_REALLOC_N(string, char, len);
+                q = string + strlen(string);
+                l = va_arg(args, long);
+                q += sprintf(q, "%ld", l);
+                continue;
+            default:
+                break;
+            }
+        }
+        *q = *p;
+        p++;
+        q++;
+    }
+    *q = 0;
+
+    return string;
+}
+
+char *frt_strfmt(const char *fmt, ...)
+{
+    va_list args;
+    char *str;
+    va_start(args, fmt);
+    str = frt_vstrfmt(fmt, args);
+    va_end(args);
+    return str;
+}
+
+void frt_dummy_free(void *p)
+{
+    (void)p; /* suppress unused argument warning */
+}
+
+#ifdef HAVE_GDB
+#define CMD_BUF_SIZE (128 + FILENAME_MAX)
+/* need to declare this as it is masked by default in linux */
+
+static char *build_shell_command()
+{
+    int   pid = getpid();
+    char *buf = FRT_ALLOC_N(char, CMD_BUF_SIZE);
+    char *command =
+        "gdb -quiet -ex='bt' -ex='quit' %s %d 2>/dev/null | grep '^[ #]'";
+
+    snprintf(buf, CMD_BUF_SIZE, command, frt_progname(), pid);
+    return buf;
+}
+
+#endif
+
+/**
+ * Call out to gdb to get our stacktrace.
+ */
+char *frt_get_stacktrace()
+{
+#ifdef HAVE_GDB
+    FILE *stream;
+    char *gdb_filename = NULL, *buf = NULL, *stack = NULL;
+    int   offset = -FRT_BUFFER_SIZE;
+
+    if ( !(buf = build_shell_command()) ) {
+        fprintf(EXCEPTION_STREAM,
+                "Unable to build stacktrace shell command\n");
+        goto cleanup;
+    }
+
+    if ( !(stream = popen(buf, "r")) ) {
+        fprintf(EXCEPTION_STREAM,
+                "Unable to exec stacktrace shell command: '%s'\n", buf);
+        goto cleanup;
+    }
+
+    do {
+        offset += FRT_BUFFER_SIZE;
+        FRT_REALLOC_N(stack, char, offset + FRT_BUFFER_SIZE);
+        FRT_ZEROSET_N(stack + offset, char, FRT_BUFFER_SIZE);
+    } while(fread(stack + offset, 1, FRT_BUFFER_SIZE, stream) == FRT_BUFFER_SIZE);
+
+    pclose(stream);
+
+ cleanup:
+    if (gdb_filename) free(gdb_filename);
+    if (buf) free(buf);
+    return stack;
+#else
+    return NULL;
+#endif
+}
+
+void frt_print_stacktrace()
+{
+    char *stack = frt_get_stacktrace();
+
+    if (stack) {
+        fprintf(EXCEPTION_STREAM, "Stack trace:\n%s", stack);
+        free(stack);
+    } else {
+        fprintf(EXCEPTION_STREAM, "Stack trace not avaialble\n");
+    }
+}
+
+typedef struct FreeMe
+{
+    void *p;
+    frt_free_ft free_func;
+} FreeMe;
+
+static FreeMe *free_mes = NULL;
+static int free_mes_size = 0;
+static int free_mes_capa = 0;
+
+void frt_register_for_cleanup(void *p, frt_free_ft free_func)
+{
+    FreeMe *free_me;
+    if (free_mes_capa == 0) {
+        free_mes_capa = 16;
+        free_mes = FRT_ALLOC_N(FreeMe, free_mes_capa);
+    }
+    else if (free_mes_capa <= free_mes_size) {
+        free_mes_capa *= 2;
+        FRT_REALLOC_N(free_mes, FreeMe, free_mes_capa);
+    }
+    free_me = free_mes + free_mes_size++;
+    free_me->p = p;
+    free_me->free_func = free_func;
+}
+
+#define MAX_PROG_NAME 200
+static char name[MAX_PROG_NAME]; /* program name for error msgs */
+
+/* frt_setprogname: set stored name of program */
+void frt_setprogname(const char *str)
+{
+    strncpy(name, str, sizeof(name) - 1);
+}
+
+const char *frt_progname()
+{
+    return name;
+}
+
+static const char *signal_to_string(int signum)
+{
+    switch (signum)
+    {
+        case SIGILL:  return "SIGILL";
+        case SIGABRT: return "SIGABRT";
+        case SIGFPE:  return "SIGFPE";
+#if !defined POSH_OS_WIN32 && !defined POSH_OS_WIN64
+        case SIGBUS:  return "SIGBUS";
+#endif
+        case SIGSEGV: return "SIGSEGV";
+    }
+
+    return "Unknown Signal";
+}
+
+static void sighandler_crash(int signum)
+{
+    frt_print_stacktrace();
+    FRT_XEXIT("Signal", "Exiting on signal %s (%d)", signal_to_string(signum), signum);
+}
+
+#define SETSIG_IF_UNSET(sig, handler) do { \
+    signal(sig, handler);                  \
+} while(0)
+
+void frt_init(int argc, const char *const argv[])
+{
+    if (argc > 0) {
+        frt_setprogname(argv[0]);
+    }
+
+    SETSIG_IF_UNSET(SIGILL , sighandler_crash);
+    SETSIG_IF_UNSET(SIGABRT, sighandler_crash);
+    SETSIG_IF_UNSET(SIGFPE , sighandler_crash);
+#if !defined POSH_OS_WIN32 && !defined POSH_OS_WIN64
+    SETSIG_IF_UNSET(SIGBUS , sighandler_crash);
+#endif
+    SETSIG_IF_UNSET(SIGSEGV, sighandler_crash);
+
+    atexit(&frt_hash_finalize);
+}
+
+/**
+ * For general use when testing
+ *
+ * TODO wrap in #ifdef
+ */
+
+static bool p_switch = false;
+static bool p_switch_tmp = false;
+
+void p(const char *format, ...)
+{
+    va_list args;
+
+    if (!p_switch) return;
+
+    va_start(args, format);
+    vfprintf(stderr, format, args);
+    va_end(args);
+}
+
+void p_on()
+{
+    fprintf(stderr, "> > > > > STARTING PRINT\n");
+    p_switch = true;
+}
+
+void p_off()
+{
+    fprintf(stderr, "< < < < < STOPPING PRINT\n");
+    p_switch = false;
+}
+
+void frt_p_pause()
+{
+    p_switch_tmp = p_switch;
+    p_switch = false;
+}
+
+void frt_p_resume()
+{
+    p_switch = p_switch_tmp;
+}

data/ext/isomorfeus_ferret_ext/frt_global.h

@@ -0,0 +1,290 @@
+#ifndef FRT_GLOBAL_H
+#define FRT_GLOBAL_H
+
+#include "frt_config.h"
+#include "frt_except.h"
+#include "frt_lang.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <string.h>
+#include <ruby.h>
+
+typedef ID FrtSymbol;
+
+#define FRT_MAX_WORD_SIZE 255
+#define FRT_MAX_FILE_PATH 1024
+#define FRT_BUFFER_SIZE 1024
+
+#define FRT_DBL2S "%#.7g"
+
+#if __GNUC__ >= 3
+#  define FRT_ATTR_ALWAYS_INLINE inline __attribute__ ((always_inline))
+#  define FRT_ATTR_MALLOC               __attribute__ ((malloc))
+#  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_CONST
+#  define likely(x)   (x)
+#  define unlikely(x) (x)
+#endif
+
+typedef void (*frt_free_ft)(void *key);
+
+#define FRT_NELEMS(array) ((int)(sizeof(array)/sizeof(array[0])))
+
+
+#define FRT_ZEROSET(ptr, type) memset(ptr, 0, sizeof(type))
+#define FRT_ZEROSET_N(ptr, type, n) memset(ptr, 0, 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 FRT_REF(a) (a)->ref_cnt++
+#define FRT_DEREF(a) (a)->ref_cnt--
+
+#define FRT_NEXT_NUM(index, size) (((index) + 1) % (size))
+#define FRT_PREV_NUM(index, size) (((index) + (size) - 1) % (size))
+
+#define FRT_MIN(a, b) ((a) < (b) ? (a) : (b))
+#define FRT_MAX(a, b) ((a) > (b) ? (a) : (b))
+
+#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 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) {\
+        self->capa <<= 1;\
+      } else {\
+        self->capa = 4;\
+      }\
+      self->ptr = (type *)frt_erealloc(self->ptr, sizeof(type) * self->capa);\
+    }\
+  } while (0)
+
+#if defined POSH_OS_WIN32 || defined POSH_OS_WIN64
+# define Jx fprintf(stderr,"%s, %d\n", __FILE__, __LINE__);
+# define Xj fprintf(stdout,"%s, %d\n", __FILE__, __LINE__);
+#else
+# define Jx fprintf(stderr,"%s, %d: %s\n", __FILE__, __LINE__, __func__);
+# define Xj fprintf(stdout,"%s, %d: %s\n", __FILE__, __LINE__, __func__);
+#endif
+
+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 char *frt_estrdup(const char *s);
+extern char *frt_estrcat(char *str, char *str_cat);
+extern char *frt_epstrdup(const char *fmt, int len, ...);
+
+extern char *frt_strapp(char *dst, const char *src);
+
+extern const char *FRT_EMPTY_STRING;
+
+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 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 char *frt_get_stacktrace();
+extern void  frt_print_stacktrace();
+
+extern void frt_register_for_cleanup(void *p, frt_free_ft free_func);
+
+/**
+ * A dummy function which can be passed to functions which expect a free
+ * function such as frt_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 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 2
+#define EXCEPTION_STREAM (frt_x_exception_stream ? frt_x_exception_stream : stderr)
+
+#ifdef DEBUG
+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);
+
+/**
+ * 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 frt_p_pause();
+extern void frt_p_resume();
+
+#endif