Cleanups
[xonotic/gmqcc.git] / util.c
diff --git a/util.c b/util.c
index 8b54251c76ed447e52c4b15f38b70b7888745c98..ecae50516514e45db673cd10966ac408a010b0d1 100644 (file)
--- a/util.c
+++ b/util.c
@@ -1,6 +1,7 @@
 /*
- * Copyright (C) 2012
+ * Copyright (C) 2012, 2013
  *     Dale Weiler
+ *     Wolfgang Bumiller
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  * this software and associated documentation files (the "Software"), to deal in
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#include <stdarg.h>
-#include <errno.h>
-#include "gmqcc.h"
-
-uint64_t mem_ab = 0;
-uint64_t mem_db = 0;
-uint64_t mem_at = 0;
-uint64_t mem_dt = 0;
-
-struct memblock_t {
-    const char  *file;
-    unsigned int line;
-    size_t       byte;
-    struct memblock_t *next;
-    struct memblock_t *prev;
-};
-
-static struct memblock_t *mem_start = NULL;
-
-void *util_memory_a(size_t byte, unsigned int line, const char *file) {
-    struct memblock_t *info = malloc(sizeof(struct memblock_t) + byte);
-    void              *data = (void*)(info+1);
-    if (!info) return NULL;
-    info->line = line;
-    info->byte = byte;
-    info->file = file;
-    info->prev = NULL;
-    info->next = mem_start;
-    if (mem_start)
-        mem_start->prev = info;
-    mem_start = info;
-
-    util_debug("MEM", "allocation:   % 8u (bytes) address 0x%08X @ %s:%u\n", byte, data, file, line);
-    mem_at++;
-    mem_ab += info->byte;
-
-    return data;
-}
-
-void util_memory_d(void *ptrn, unsigned int line, const char *file) {
-    struct memblock_t *info = NULL;
-
-    if (!ptrn) return;
-    info = ((struct memblock_t*)ptrn - 1);
-
-    util_debug("MEM", "released:     % 8u (bytes) address 0x%08X @ %s:%u\n", info->byte, ptrn, file, line);
-    mem_db += info->byte;
-    mem_dt++;
-
-    if (info->prev)
-        info->prev->next = info->next;
-    if (info->next)
-        info->next->prev = info->prev;
-    if (info == mem_start)
-        mem_start = info->next;
-
-    free(info);
-}
-
-void *util_memory_r(void *ptrn, size_t byte, unsigned int line, const char *file) {
-    struct memblock_t *oldinfo = NULL;
-
-    struct memblock_t *newinfo;
-
-    if (!ptrn)
-        return util_memory_a(byte, line, file);
-    if (!byte) {
-        util_memory_d(ptrn, line, file);
-        return NULL;
-    }
-
-    oldinfo = ((struct memblock_t*)ptrn - 1);
-    newinfo = ((struct memblock_t*)malloc(sizeof(struct memblock_t) + byte));
-
-    util_debug("MEM", "reallocation: % 8u -> %u (bytes) address 0x%08X -> 0x%08X @ %s:%u\n", oldinfo->byte, byte, ptrn, (void*)(newinfo+1), file, line);
-
-    /* new data */
-    if (!newinfo) {
-        util_memory_d(oldinfo+1, line, file);
-        return NULL;
-    }
-
-    /* copy old */
-    memcpy(newinfo+1, oldinfo+1, oldinfo->byte);
-
-    /* free old */
-    if (oldinfo->prev)
-        oldinfo->prev->next = oldinfo->next;
-    if (oldinfo->next)
-        oldinfo->next->prev = oldinfo->prev;
-    if (oldinfo == mem_start)
-        mem_start = oldinfo->next;
-
-    /* fill info */
-    newinfo->line = line;
-    newinfo->byte = byte;
-    newinfo->file = file;
-    newinfo->prev = NULL;
-    newinfo->next = mem_start;
-    if (mem_start)
-        mem_start->prev = newinfo;
-    mem_start = newinfo;
-
-    mem_ab -= oldinfo->byte;
-    mem_ab += newinfo->byte;
-
-    free(oldinfo);
-
-    return newinfo+1;
-}
-
-void util_meminfo() {
-    struct memblock_t *info;
-
-    if (!opts_memchk)
-        return;
-
-    for (info = mem_start; info; info = info->next) {
-        util_debug("MEM", "lost:       % 8u (bytes) at %s:%u\n",
-            info->byte,
-            info->file,
-            info->line);
-    }
-
-    util_debug("MEM", "Memory information:\n\
-        Total allocations:   %llu\n\
-        Total deallocations: %llu\n\
-        Total allocated:     %llu (bytes)\n\
-        Total deallocated:   %llu (bytes)\n\
-        Leaks found:         lost %llu (bytes) in %d allocations\n",
-            mem_at,   mem_dt,
-            mem_ab,   mem_db,
-           (mem_ab -  mem_db),
-           (mem_at -  mem_dt)
-    );
-}
-
-/*
- * Some string utility functions, because strdup uses malloc, and we want
- * to track all memory (without replacing malloc).
- */
-char *util_strdup(const char *s) {
-    size_t  len = 0;
-    char   *ptr = NULL;
-
-    if (!s)
-        return NULL;
-
-    if ((len = strlen(s)) && (ptr = mem_a(len+1))) {
-        memcpy(ptr, s, len);
-        ptr[len] = '\0';
-    }
-    return ptr;
-}
-
-/*
- * Remove quotes from a string, escapes from \ in string
- * as well.  This function shouldn't be used to create a
- * char array that is later freed (it uses pointer arith)
- */
-char *util_strrq(const char *s) {
-    char *dst = (char*)s;
-    char *src = (char*)s;
-    char  chr;
-    while ((chr = *src++) != '\0') {
-        if (chr == '\\') {
-            *dst++ = chr;
-            if ((chr = *src++) == '\0')
-                break;
-            *dst++ = chr;
-        } else if (chr != '"')
-            *dst++ = chr;
-    }
-    *dst = '\0';
-    return dst;
-}
-
-/*
- * Chops a substring from an existing string by creating a
- * copy of it and null terminating it at the required position.
- */
-char *util_strchp(const char *s, const char *e) {
-    const char *c = NULL;
-    if (!s || !e)
-        return NULL;
-
-    c = s;
-    while (c != e)
-        c++;
+#include <string.h>
+#include <stdlib.h>
 
-    return util_strdup(s);
-}
-
-/*
- * Returns true if string is all uppercase, otherwise
- * it returns false.
- */
-bool util_strupper(const char *str) {
-    while (*str) {
-        if(!isupper(*str))
-            return false;
-        str++;
-    }
-    return true;
-}
+#include "gmqcc.h"
 
 /*
- * Returns true if string is all digits, otherwise
- * it returns false.
+ * Initially this was handled with a table in the gmqcc.h header, but 
+ * much to my surprise the contents of the table was duplicated for
+ * each translation unit, causing all these strings to be duplicated
+ * for every .c file it was included into. This method culls back on
+ * it. This is a 'utility' function because the executor also depends
+ * on this for dissasembled bytecode.
  */
-bool util_strdigit(const char *str) {
-    while (*str) {
-        if(!isdigit(*str))
-            return false;
-        str++;
-    }
-    return true;
-}
-
-bool util_strncmpexact(const char *src, const char *ned, size_t len) {
-    return (!strncmp(src, ned, len) && !src[len]);
-}
+const char *util_instr_str[VINSTR_END] = {
+    "DONE",       "MUL_F",      "MUL_V",      "MUL_FV",
+    "MUL_VF",     "DIV_F",      "ADD_F",      "ADD_V",
+    "SUB_F",      "SUB_V",      "EQ_F",       "EQ_V",
+    "EQ_S",       "EQ_E",       "EQ_FNC",     "NE_F",
+    "NE_V",       "NE_S",       "NE_E",       "NE_FNC",
+    "LE",         "GE",         "LT",         "GT",
+    "LOAD_F",     "LOAD_V",     "LOAD_S",     "LOAD_ENT",
+    "LOAD_FLD",   "LOAD_FNC",   "ADDRESS",    "STORE_F",
+    "STORE_V",    "STORE_S",    "STORE_ENT",  "STORE_FLD",
+    "STORE_FNC",  "STOREP_F",   "STOREP_V",   "STOREP_S",
+    "STOREP_ENT", "STOREP_FLD", "STOREP_FNC", "RETURN",
+    "NOT_F",      "NOT_V",      "NOT_S",      "NOT_ENT",
+    "NOT_FNC",    "IF",         "IFNOT",      "CALL0",
+    "CALL1",      "CALL2",      "CALL3",      "CALL4",
+    "CALL5",      "CALL6",      "CALL7",      "CALL8",
+    "STATE",      "GOTO",       "AND",        "OR",
+    "BITAND",     "BITOR"
+};
 
 void util_debug(const char *area, const char *ms, ...) {
     va_list  va;
-    if (!opts_debug)
+    if (!OPTS_OPTION_BOOL(OPTION_DEBUG))
         return;
 
-    if (!strcmp(area, "MEM") && !opts_memchk)
+    if (!strcmp(area, "MEM") && !OPTS_OPTION_BOOL(OPTION_MEMCHK))
         return;
 
     va_start(va, ms);
     con_out ("[%s] ", area);
-    con_vout(ms, va); 
+    con_vout(ms, va);
     va_end  (va);
 }
 
 /*
- * Endianess swapping, all data must be stored little-endian.  This
- * reorders by stride and length, much nicer than other functions for
- * certian-sized types like short or int.
+ * only required if big endian .. otherwise no need to swap
+ * data.
  */
-void util_endianswap(void *m, int s, int l) {
-    size_t w = 0;
-    size_t i = 0;
+#if PLATFORM_BYTE_ORDER == GMQCC_BYTE_ORDER_BIG
+    static GMQCC_INLINE void util_swap16(uint16_t *d, size_t l) {
+        while (l--) {
+            d[l] = (d[l] << 8) | (d[l] >> 8);
+        }
+    }
 
-    /* ignore if we're already LE */
-    if(*((char *)&s))
-        return;
+    static GMQCC_INLINE void util_swap32(uint32_t *d, size_t l) {
+        while (l--) {
+            uint32_t v;
+            v = ((d[l] << 8) & 0xFF00FF00) | ((d[l] >> 8) & 0x00FF00FF);
+            d[l] = (v << 16) | (v >> 16);
+        }
+    }
 
-    for(; w < (size_t)l; w++) {
-        for(;  i < (size_t)(s << 1); i++) {
-            unsigned char *p = (unsigned char *)m+w*s;
-            unsigned char  t = p[i];
-            p[i]             = p[s-i-1];
-            p[s-i-1]         = t;
+    /* Some strange system doesn't like constants that big, AND doesn't recognize an ULL suffix
+     * so let's go the safe way
+     */
+    static GMQCC_INLINE void util_swap64(uint32_t *d, size_t l) {
+        /*
+        while (l--) {
+            uint64_t v;
+            v = ((d[l] << 8) & 0xFF00FF00FF00FF00) | ((d[l] >> 8) & 0x00FF00FF00FF00FF);
+            v = ((v << 16) & 0xFFFF0000FFFF0000) | ((v >> 16) & 0x0000FFFF0000FFFF);
+            d[l] = (v << 32) | (v >> 32);
+        }
+        */
+        size_t i;
+        for (i = 0; i < l; i += 2) {
+            uint32_t v1 = d[i];
+            d[i] = d[i+1];
+            d[i+1] = v1;
+            util_swap32(d+i, 2);
         }
     }
+#endif
+
+void util_endianswap(void *_data, size_t length, unsigned int typesize) {
+#   if PLATFORM_BYTE_ORDER == -1 /* runtime check */
+    if (*((char*)&typesize))
+        return;
+#else
+    /* prevent unused warnings */
+    (void) _data;
+    (void) length;
+    (void) typesize;
+
+#   if PLATFORM_BYTE_ORDER == GMQCC_BYTE_ORDER_LITTLE
+        return;
+#   else
+        switch (typesize) {
+            case 1: return;
+            case 2:
+                util_swap16((uint16_t*)_data, length>>1);
+                return;
+            case 4:
+                util_swap32((uint32_t*)_data, length>>2);
+                return;
+            case 8:
+                util_swap64((uint32_t*)_data, length>>3);
+                return;
+
+            default: exit(EXIT_FAILURE); /* please blow the fuck up! */
+        }
+#   endif
+#endif
 }
 
 /*
@@ -294,7 +154,7 @@ void util_endianswap(void *m, int s, int l) {
  * In most traditional CRC algorithms on uses a reflected table driven method where a value
  * or register is reflected if it's bits are swapped around it's center.  For example:
  * take the bits 0101 is the 4-bit reflection of 1010, and respectfully 0011 would be the
- * reflection of 1100. Quakle however expects a NON-Reflected CRC on the output, but still
+ * reflection of 1100. Quake however expects a NON-Reflected CRC on the output, but still
  * requires a final XOR on the values (0xFFFF and 0x0000) this is a standard CCITT CRC-16
  * which I respectfully as a programmer don't agree with.
  *
@@ -302,58 +162,6 @@ void util_endianswap(void *m, int s, int l) {
  * but those are what Quake seems to request.
  */
 
-/*
- * This is an implementation of CRC32 & CRC16. The polynomials have been
- * offline computed for faster generation at the cost of larger code size.
- *
- * CRC32 Polynomial: 0xEDB88320
- * CRC16 Polynomial: 0x00001021
- */
-static const uint32_t util_crc32_table[] = {
-    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
-    0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
-    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
-    0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
-    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
-    0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
-    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
-    0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
-    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
-    0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
-    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
-    0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
-    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
-    0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
-    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
-    0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
-    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
-    0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
-    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
-    0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
-    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
-    0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
-    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
-    0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
-    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
-    0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
-    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
-    0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
-    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
-    0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
-    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
-    0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
-    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
-    0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
-    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
-    0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
-    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
-    0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
-    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
-    0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
-    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
-    0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
-    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
-};
 static const uint16_t util_crc16_table[] = {
     0x0000,     0x1021,     0x2042,     0x3063,     0x4084,     0x50A5,
     0x60C6,     0x70E7,     0x8108,     0x9129,     0xA14A,     0xB16B,
@@ -400,141 +208,374 @@ static const uint16_t util_crc16_table[] = {
     0x2E93,     0x3EB2,     0x0ED1,     0x1EF0
 };
 
-/*
- * Implements a CRC function for X worth bits using (uint[X]_t)
- * as type. and util_crc[X]_table.
+/* Non - Reflected */
+uint16_t util_crc16(uint16_t current, const char *k, size_t len) {
+    register uint16_t h = current;
+    for (; len; --len, ++k)
+        h = util_crc16_table[(h>>8)^((unsigned char)*k)]^(h<<8);
+    return h;
+}
+/* Reflective Varation (for reference) */
+#if 0
+uint16_t util_crc16(const char *k, int len, const short clamp) {
+    register uint16_t h= (uint16_t)0xFFFFFFFF;
+    for (; len; --len, ++k)
+        h = util_crc16_table[(h^((unsigned char)*k))&0xFF]^(h>>8);
+    return (~h)%clamp;
+}
+#endif
 
- * Quake expects a non-reflective CRC.
+/* 
+ * modifier is the match to make and the transpsition from it, while add is the upper-value that determines the
+ * transposion from uppercase to lower case.
  */
-#define CRC(X) \
-uint##X##_t util_crc##X(uint##X##_t current, const char *k, size_t len) {  \
-    register uint##X##_t h= current;                                  \
-    for (; len; --len, ++k)                                           \
-        h = util_crc##X##_table[(h>>8)^((unsigned char)*k)]^(h<<8);   \
-    return h;                                                         \
-}
-CRC(32)
-CRC(16)
-#undef CRC
-/*
-#define CRC(X) \
-uint##X##_t util_crc##X(const char *k, int len, const short clamp) {  \
-    register uint##X##_t h= (uint##X##_t)0xFFFFFFFF;                  \
-    for (; len; --len, ++k)                                           \
-        h = util_crc##X##_table[(h^((unsigned char)*k))&0xFF]^(h>>8); \
-    return (~h)%clamp;                                                \
+static GMQCC_INLINE size_t util_strtransform(const char *in, char *out, size_t outsz, const char *mod, int add) {
+    size_t sz = 1;
+    for (; *in && sz < outsz; ++in, ++out, ++sz) {
+        *out = (*in == mod[0])
+                    ? mod[1]
+                    : (util_isalpha(*in) && util_isupper(*in + add))
+                        ? *in + add
+                        : *in;
+    }
+    *out = 0;
+    return sz-1;
 }
-*/
 
+size_t util_strtocmd(const char *in, char *out, size_t outsz) {
+    return util_strtransform(in, out, outsz, "-_", 'A'-'a');
+}
+size_t util_strtononcmd(const char *in, char *out, size_t outsz) {
+    return util_strtransform(in, out, outsz, "_-", 'a'-'A');
+}
+size_t util_optimizationtostr(const char *in, char *out, size_t outsz) {
+    return util_strtransform(in, out, outsz, "_ ", 'a'-'A');
+}
 
 /*
- * Implements libc getline for systems that don't have it, which is
- * assmed all.  This works the same as getline().
+ * Portable implementation of vasprintf/asprintf. Assumes vsnprintf
+ * exists, otherwise compiler error.
+ *
+ * TODO: fix for MSVC ....
  */
-int util_getline(char **lineptr, size_t *n, FILE *stream) {
-    int   chr;
+int util_vasprintf(char **dat, const char *fmt, va_list args) {
     int   ret;
-    char *pos;
+    int   len;
+    char *tmp = NULL;
+
+    /*
+     * For visuals tido _vsnprintf doesn't tell you the length of a
+     * formatted string if it overflows. However there is a MSVC
+     * intrinsic (which is documented wrong) called _vcsprintf which
+     * will return the required amount to allocate.
+     */
+    #ifdef _MSC_VER
+        if ((len = _vscprintf(fmt, args)) < 0) {
+            *dat = NULL;
+            return -1;
+        }
 
-    if (!lineptr || !n || !stream)
-        return -1;
-    if (!*lineptr) {
-        if (!(*lineptr = (char*)mem_a((*n=64))))
+        tmp = (char*)mem_a(len + 1);
+        if ((ret = _vsnprintf_s(tmp, len+1, len+1, fmt, args)) != len) {
+            mem_d(tmp);
+            *dat = NULL;
             return -1;
+        }
+        *dat = tmp;
+        return len;
+    #else
+        /*
+         * For everything else we have a decent conformint vsnprintf that
+         * returns the number of bytes needed.  We give it a try though on
+         * a short buffer, since efficently speaking, it could be nice to
+         * above a second vsnprintf call.
+         */
+        char    buf[128];
+        va_list cpy;
+        va_copy(cpy, args);
+        len = vsnprintf(buf, sizeof(buf), fmt, cpy);
+        va_end (cpy);
+
+        if (len < (int)sizeof(buf)) {
+            *dat = util_strdup(buf);
+            return len;
+        }
+
+        /* not large enough ... */
+        tmp = (char*)mem_a(len + 1);
+        if ((ret = vsnprintf(tmp, len + 1, fmt, args)) != len) {
+            mem_d(tmp);
+            *dat = NULL;
+            return -1;
+        }
+
+        *dat = tmp;
+        return len;
+    #endif
+}
+int util_asprintf(char **ret, const char *fmt, ...) {
+    va_list  args;
+    int      read;
+    va_start(args, fmt);
+    read = util_vasprintf(ret, fmt, args);
+    va_end  (args);
+
+    return read;
+}
+
+/*
+ * These are various re-implementations (wrapping the real ones) of
+ * string functions that MSVC consideres unsafe. We wrap these up and
+ * use the safe varations on MSVC.
+ */
+#ifdef _MSC_VER
+    static char **util_strerror_allocated() {
+        static char **data = NULL;
+        return data;
     }
 
-    chr = *n;
-    pos = *lineptr;
+    static void util_strerror_cleanup(void) {
+        size_t i;
+        char  **data = util_strerror_allocated();
+        for (i = 0; i < vec_size(data); i++)
+            mem_d(data[i]);
+        vec_free(data);
+    }
 
-    for (;;) {
-        int c = getc(stream);
+    const char *util_strerror(int num) {
+        char         *allocated = NULL;
+        static bool   install   = false;
+        static size_t tries     = 0;
+        char        **vector    = util_strerror_allocated();
 
-        if (chr < 2) {
-            char *tmp = (char*)mem_a((*n+=(*n>16)?*n:64));
-            if  (!tmp)
-                return -1;
+        /* try installing cleanup handler */
+        while (!install) {
+            if (tries == 32)
+                return "(unknown)";
 
-            memcpy(tmp, *lineptr, pos - *lineptr);
-            chr = *n + *lineptr - pos;
-            if (!(*lineptr = tmp)) {
-                mem_d (tmp);
-                return -1;
-            }
-            pos = *n - chr + *lineptr;
+            install = !atexit(&util_strerror_cleanup);
+            tries ++;
         }
 
-        if (ferror(stream))
-            return -1;
-        if (c == EOF) {
-            if (pos == *lineptr)
-                return -1;
-            else
-                break;
-        }
+        allocated = (char*)mem_a(4096); /* A page must be enough */
+        strerror_s(allocated, 4096, num);
 
-        *pos++ = c;
-        chr--;
-        if (c == '\n')
-            break;
+        vec_push(vector, allocated);
+        return (const char *)allocated;
     }
-    *pos = '\0';
-    return (ret = pos - *lineptr);
-}
 
-size_t util_strtocmd(const char *in, char *out, size_t outsz) {
-    size_t sz = 1;
-    for (; *in && sz < outsz; ++in, ++out, ++sz) {
-        if (*in == '-')
-            *out = '_';
-        else if (isalpha(*in) && !isupper(*in))
-            *out = *in + 'A' - 'a';
-        else
-            *out = *in;
+    int util_snprintf(char *src, size_t bytes, const char *format, ...) {
+        int      rt;
+        va_list  va;
+        va_start(va, format);
+
+        rt = vsprintf_s(src, bytes, format, va);
+        va_end  (va);
+
+        return rt;
     }
-    *out = 0;
-    return sz-1;
-}
 
-size_t util_strtononcmd(const char *in, char *out, size_t outsz) {
-    size_t sz = 1;
-    for (; *in && sz < outsz; ++in, ++out, ++sz) {
-        if (*in == '_')
-            *out = '-';
-        else if (isalpha(*in) && isupper(*in))
-            *out = *in + 'a' - 'A';
-        else
-            *out = *in;
+    char *util_strcat(char *dest, const char *src) {
+        strcat_s(dest, strlen(src), src);
+        return dest;
     }
-    *out = 0;
-    return sz-1;
-}
 
-FILE *util_fopen(const char *filename, const char *mode)
-{
-#ifdef WIN32
-    FILE *out;
-    if (fopen_s(&out, filename, mode) != 0)
-        return NULL;
-    return out;
+    char *util_strncpy(char *dest, const char *src, size_t num) {
+        strncpy_s(dest, num, src, num);
+        return dest;
+    }
 #else
-    return fopen(filename, mode);
-#endif
+    const char *util_strerror(int num) {
+        return strerror(num);
+    }
+
+    int util_snprintf(char *src, size_t bytes, const char *format, ...) {
+        int      rt;
+        va_list  va;
+        va_start(va, format);
+        rt = vsnprintf(src, bytes, format, va);
+        va_end  (va);
+
+        return rt;
+    }
+
+    char *util_strcat(char *dest, const char *src) {
+        return strcat(dest, src);
+    }
+
+    char *util_strncpy(char *dest, const char *src, size_t num) {
+        return strncpy(dest, src, num);
+    }
+
+#endif /*! _MSC_VER */
+
+/*
+ * Implementation of the Mersenne twister PRNG (pseudo random numer
+ * generator).  Implementation of MT19937.  Has a period of 2^19937-1
+ * which is a Mersenne Prime (hence the name).
+ *
+ * Implemented from specification and original paper:
+ * http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/mt.pdf
+ *
+ * This code is placed in the public domain by me personally
+ * (Dale Weiler, a.k.a graphitemaster).
+ */
+
+#define MT_SIZE    624
+#define MT_PERIOD  397
+#define MT_SPACE   (MT_SIZE - MT_PERIOD)
+
+static uint32_t mt_state[MT_SIZE];
+static size_t   mt_index = 0;
+
+static GMQCC_INLINE void mt_generate(void) {
+    /*
+     * The loop has been unrolled here: the original paper and implemenation
+     * Called for the following code:
+     * for (register unsigned i = 0; i < MT_SIZE; ++i) {
+     *     register uint32_t load;
+     *     load  = (0x80000000 & mt_state[i])                 // most  significant 32nd bit
+     *     load |= (0x7FFFFFFF & mt_state[(i + 1) % MT_SIZE]) // least significant 31nd bit
+     *
+     *     mt_state[i] = mt_state[(i + MT_PERIOD) % MT_SIZE] ^ (load >> 1);
+     *
+     *     if (load & 1) mt_state[i] ^= 0x9908B0DF;
+     * }
+     *
+     * This essentially is a waste: we have two modulus operations, and
+     * a branch that is executed every iteration from [0, MT_SIZE).
+     *
+     * Please see: http://www.quadibloc.com/crypto/co4814.htm for more
+     * information on how this clever trick works.
+     */
+    static const uint32_t matrix[2] = {
+        0x00000000,
+        0x9908B0Df
+    };
+    /*
+     * This register gives up a little more speed by instructing the compiler
+     * to force these into CPU registers (they're counters for indexing mt_state
+     * which we can force the compiler to generate prefetch instructions for)
+     */
+    register uint32_t y;
+    register uint32_t i;
+
+    /*
+     * Said loop has been unrolled for MT_SPACE (226 iterations), opposed
+     * to [0, MT_SIZE)  (634 iterations).
+     */
+    for (i = 0; i < MT_SPACE-1; ++i) {
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i + MT_PERIOD] ^ (y >> 1) ^ matrix[y & 1];
+
+        i ++; /* loop unroll */
+
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i + MT_PERIOD] ^ (y >> 1) ^ matrix[y & 1];
+    }
+
+    /*
+     * collapsing the walls unrolled (evenly dividing 396 [632-227 = 396
+     * = 2*2*3*3*11])
+     */
+    i = MT_SPACE;
+    while (i < MT_SIZE-2) {
+        /*
+         * We expand this 11 times .. manually, no macros are required
+         * here. This all fits in the CPU cache.
+         */
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+        y           = (0x80000000 & mt_state[i]) | (0x7FFFFFFF & mt_state[i + 1]);
+        mt_state[i] = mt_state[i - MT_SPACE] ^ (y >> 1) ^ matrix[y & 1];
+        ++i;
+    }
+
+    /* i = mt_state[623] */
+    y                     = (0x80000000 & mt_state[MT_SIZE - 1]) | (0x7FFFFFFF & mt_state[MT_SIZE - 1]);
+    mt_state[MT_SIZE - 1] = mt_state[MT_PERIOD - 1] ^ (y >> 1) ^ matrix[y & 1];
 }
 
-bool util_filexists(const char *file) {
-    FILE *fp = fopen(file, "rb");
-    if  (!fp) return false;
-    
-    /* it exists */
-    fclose(fp);
-    return true;
+void util_seed(uint32_t value) {
+    /*
+     * We seed the mt_state with a LCG (linear congruential generator)
+     * We're operating exactly on exactly m=32, so there is no need to
+     * use modulus.
+     *
+     * The multipler of choice is 0x6C07865, also knows as the Borosh-
+     * Niederreiter multipler used for modulus 2^32.  More can be read
+     * about this in Knuth's TAOCP Volume 2, page 106.
+     *
+     * If you don't own TAOCP something is wrong with you :-) .. so I
+     * also provided a link to the original paper by Borosh and
+     * Niederreiter.  It's called "Optional Multipliers for PRNG by The
+     * Linear Congruential Method" (1983).
+     * http://en.wikipedia.org/wiki/Linear_congruential_generator
+     *
+     * From said page, it says the following:
+     * "A common Mersenne twister implementation, interestingly enough
+     *  used an LCG to generate seed data."
+     *
+     * Remarks:
+     * The data we're operating on is 32-bits for the mt_state array, so
+     * there is no masking required with 0xFFFFFFFF
+     */
+    register size_t i;
+
+    mt_state[0] = value;
+    for (i = 1; i < MT_SIZE; ++i)
+        mt_state[i] = 0x6C078965 * (mt_state[i - 1] ^ mt_state[i - 1] >> 30) + i;
 }
 
-void _util_vec_grow(void **a, size_t i, size_t s) {
-    size_t m = *a ? 2*_vec_beg(*a)+i : i+1;
-    void  *p = mem_r((*a ? _vec_raw(*a) : NULL), s * m + sizeof(size_t)*2);
-    if (!*a)
-        ((size_t*)p)[1] = 0;
-    *a = (void*)((size_t*)p + 2);
-    _vec_beg(*a) = m;
+uint32_t util_rand() {
+    register uint32_t y;
+
+    /*
+     * This is inlined with any sane compiler (I checked)
+     * for some reason though, SubC seems to be generating invalid
+     * code when it inlines this.
+     */
+    if (!mt_index)
+        mt_generate();
+
+    y = mt_state[mt_index];
+
+    /* Standard tempering */
+    y ^= y >> 11;              /* +7 */
+    y ^= y << 7  & 0x9D2C5680; /* +4 */
+    y ^= y << 15 & 0xEFC60000; /* -4 */
+    y ^= y >> 18;              /* -7 */
+
+    if(++mt_index == MT_SIZE)
+         mt_index = 0;
+
+    return y;
 }