util.cpp

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include "gmqcc.h"
   4
   5 const char *util_instr_str[VINSTR_END] = {
   6     "DONE",       "MUL_F",      "MUL_V",      "MUL_FV",
   7     "MUL_VF",     "DIV_F",      "ADD_F",      "ADD_V",
   8     "SUB_F",      "SUB_V",      "EQ_F",       "EQ_V",
   9     "EQ_S",       "EQ_E",       "EQ_FNC",     "NE_F",
  10     "NE_V",       "NE_S",       "NE_E",       "NE_FNC",
  11     "LE",         "GE",         "LT",         "GT",
  12     "LOAD_F",     "LOAD_V",     "LOAD_S",     "LOAD_ENT",
  13     "LOAD_FLD",   "LOAD_FNC",   "ADDRESS",    "STORE_F",
  14     "STORE_V",    "STORE_S",    "STORE_ENT",  "STORE_FLD",
  15     "STORE_FNC",  "STOREP_F",   "STOREP_V",   "STOREP_S",
  16     "STOREP_ENT", "STOREP_FLD", "STOREP_FNC", "RETURN",
  17     "NOT_F",      "NOT_V",      "NOT_S",      "NOT_ENT",
  18     "NOT_FNC",    "IF",         "IFNOT",      "CALL0",
  19     "CALL1",      "CALL2",      "CALL3",      "CALL4",
  20     "CALL5",      "CALL6",      "CALL7",      "CALL8",
  21     "STATE",      "GOTO",       "AND",        "OR",
  22     "BITAND",     "BITOR"
  23 };
  24
  25 /*
  26  * only required if big endian .. otherwise no need to swap
  27  * data.
  28  */
  29 #if PLATFORM_BYTE_ORDER == GMQCC_BYTE_ORDER_BIG || PLATFORM_BYTE_ORDER == -1
  30     static GMQCC_INLINE void util_swap16(uint16_t *d, size_t l) {
  31         while (l--) {
  32             d[l] = (d[l] << 8) | (d[l] >> 8);
  33         }
  34     }
  35
  36     static GMQCC_INLINE void util_swap32(uint32_t *d, size_t l) {
  37         while (l--) {
  38             uint32_t v;
  39             v = ((d[l] << 8) & 0xFF00FF00) | ((d[l] >> 8) & 0x00FF00FF);
  40             d[l] = (v << 16) | (v >> 16);
  41         }
  42     }
  43
  44     /* Some strange system doesn't like constants that big, AND doesn't recognize an ULL suffix
  45      * so let's go the safe way
  46      */
  47     static GMQCC_INLINE void util_swap64(uint32_t *d, size_t l) {
  48         while (l--) {
  49             uint64_t v;
  50             v = ((d[l] << 8) & 0xFF00FF00FF00FF00) | ((d[l] >> 8) & 0x00FF00FF00FF00FF);
  51             v = ((v << 16) & 0xFFFF0000FFFF0000) | ((v >> 16) & 0x0000FFFF0000FFFF);
  52             d[l] = (v << 32) | (v >> 32);
  53         }
  54     }
  55 #endif
  56
  57 void util_endianswap(void *_data, size_t count, unsigned int typesize) {
  58 #   if PLATFORM_BYTE_ORDER == -1 /* runtime check */
  59     if (*((char*)&typesize))
  60         return;
  61 #else
  62
  63 #   if PLATFORM_BYTE_ORDER == GMQCC_BYTE_ORDER_LITTLE
  64         /* prevent unused warnings */
  65         (void) _data;
  66         (void) count;
  67         (void) typesize;
  68         return;
  69 #   else
  70         switch (typesize) {
  71             case 1: return;
  72             case 2:
  73                 util_swap16((uint16_t*)_data, count);
  74                 return;
  75             case 4:
  76                 util_swap32((uint32_t*)_data, count);
  77                 return;
  78             case 8:
  79                 util_swap64((uint32_t*)_data, count);
  80                 return;
  81
  82             default:
  83                 con_err ("util_endianswap: I don't know how to swap a %u byte structure!\n", typesize);
  84                 exit(EXIT_FAILURE); /* please blow the fuck up! */
  85         }
  86 #   endif
  87 #endif
  88 }
  89
  90 void util_swap_header(prog_header_t *code_header) {
  91     util_endianswap(&code_header->version,              1, sizeof(code_header->version));
  92     util_endianswap(&code_header->crc16,                1, sizeof(code_header->crc16));
  93     util_endianswap(&code_header->statements.offset,    1, sizeof(code_header->statements.offset));
  94     util_endianswap(&code_header->statements.length,    1, sizeof(code_header->statements.length));
  95     util_endianswap(&code_header->defs.offset,          1, sizeof(code_header->defs.offset));
  96     util_endianswap(&code_header->defs.length,          1, sizeof(code_header->defs.length));
  97     util_endianswap(&code_header->fields.offset,        1, sizeof(code_header->fields.offset));
  98     util_endianswap(&code_header->fields.length,        1, sizeof(code_header->fields.length));
  99     util_endianswap(&code_header->functions.offset,     1, sizeof(code_header->functions.offset));
 100     util_endianswap(&code_header->functions.length,     1, sizeof(code_header->functions.length));
 101     util_endianswap(&code_header->strings.offset,       1, sizeof(code_header->strings.offset));
 102     util_endianswap(&code_header->strings.length,       1, sizeof(code_header->strings.length));
 103     util_endianswap(&code_header->globals.offset,       1, sizeof(code_header->globals.offset));
 104     util_endianswap(&code_header->globals.length,       1, sizeof(code_header->globals.length));
 105     util_endianswap(&code_header->entfield,             1, sizeof(code_header->entfield));
 106 }
 107
 108 void util_swap_statements(prog_section_statement_t *statements) {
 109     size_t i;
 110
 111     for (i = 0; i < vec_size(statements); ++i) {
 112         util_endianswap(&statements[i].opcode,  1, sizeof(statements[i].opcode));
 113         util_endianswap(&statements[i].o1,      1, sizeof(statements[i].o1));
 114         util_endianswap(&statements[i].o2,      1, sizeof(statements[i].o2));
 115         util_endianswap(&statements[i].o3,      1, sizeof(statements[i].o3));
 116     }
 117 }
 118
 119 void util_swap_defs_fields(prog_section_both_t *section) {
 120     size_t i;
 121
 122     for (i = 0; i < vec_size(section); ++i) {
 123         util_endianswap(&section[i].type,   1, sizeof(section[i].type));
 124         util_endianswap(&section[i].offset, 1, sizeof(section[i].offset));
 125         util_endianswap(&section[i].name,   1, sizeof(section[i].name));
 126     }
 127 }
 128
 129 void util_swap_functions(prog_section_function_t *functions) {
 130     size_t i;
 131
 132     for (i = 0; i < vec_size(functions); ++i) {
 133         util_endianswap(&functions[i].entry,        1, sizeof(functions[i].entry));
 134         util_endianswap(&functions[i].firstlocal,   1, sizeof(functions[i].firstlocal));
 135         util_endianswap(&functions[i].locals,       1, sizeof(functions[i].locals));
 136         util_endianswap(&functions[i].profile,      1, sizeof(functions[i].profile));
 137         util_endianswap(&functions[i].name,         1, sizeof(functions[i].name));
 138         util_endianswap(&functions[i].file,         1, sizeof(functions[i].file));
 139         util_endianswap(&functions[i].nargs,        1, sizeof(functions[i].nargs));
 140         /* Don't swap argsize[] - it's just a byte array, which Quake uses only as such. */
 141     }
 142 }
 143
 144 void util_swap_globals(int32_t *globals) {
 145     util_endianswap(globals, vec_size(globals), sizeof(int32_t));
 146 }
 147
 148 /*
 149 * Based On:
 150 *   Slicing-by-8 algorithms by Michael E.
 151 *       Kounavis and Frank L. Berry from Intel Corp.
 152 *       http://www.intel.com/technology/comms/perfnet/download/CRC_generators.pdf
 153 *
 154 *   This code was made to be slightly less confusing with macros, which
 155 *   I suppose is somewhat ironic.
 156 *
 157 *   The code had to be changed for non reflected on the output register
 158 *   since that's the method Quake uses.
 159 *
 160 *   The code also had to be changed for CRC16, which is slightly harder
 161 *   since the CRC32 method in the original Intel paper used a different
 162 *   bit order convention.
 163 *
 164 * Notes about the table:
 165 *   - It's exactly 4K in size
 166 *   - 64 elements fit in a cache line
 167 *   - can do 8 iterations unrolled 8 times for free
 168 *   - The first 256 elements of the table are standard CRC16 table
 169 *
 170 * Table can be generated with the following utility:
 171 */
 172 #if 0
 173 #include <stdio.h>
 174 #include <stdint.h>
 175 int main(void) {
 176     for (unsigned i = 0; i < 0x100; ++i) {
 177         uint16_t x = i << 8;
 178         for (int j = 0; j < 8; ++j)
 179             x = (x << 1) ^ ((x & 0x8000) ? 0x1021 : 0);
 180         tab[0][i] = x;
 181     }
 182     for (unsigned i = 0; i < 0x100; ++i) {
 183         uint16_t c = tab[0][i];
 184         for (unsigned j = 1; j < 8; ++j) {
 185             c = tab[0][c >> 8] ^ (c << 8);
 186             tab[j][i] = c;
 187         }
 188     }
 189     printf("static const uint16_t util_crc16_table[8][256] = {");
 190     for (int i = 0; i < 8; ++i) {
 191         printf("{\n");
 192         for (int j = 0; j < 0x100; ++j) {
 193             printf((j & 7) ? " " : "    ");
 194             printf((j != 0x100-1) ? "0x%04X," : "0x%04X", tab[i][j]);
 195             if ((j & 7) == 7)
 196                 printf("\n");
 197         }
 198         printf((i != 7) ? "}," : "}");
 199     }
 200     printf("};\n");
 201     return 0;
 202 }
 203 #endif
 204 /*
 205  * Non-Reflective version is present as well as a reference.
 206  *
 207  * TODO:
 208  *  combine the crc16 into u32s and mask off low high for byte order
 209  *  to make the arrays smaller.
 210  */
 211
 212 static const uint16_t util_crc16_table[8][256] = {{
 213     0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
 214     0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
 215     0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
 216     0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
 217     0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
 218     0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
 219     0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
 220     0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
 221     0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
 222     0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
 223     0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
 224     0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
 225     0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
 226     0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
 227     0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
 228     0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
 229     0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
 230     0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
 231     0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
 232     0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
 233     0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
 234     0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
 235     0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
 236     0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
 237     0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
 238     0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
 239     0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
 240     0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
 241     0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
 242     0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
 243     0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
 244     0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
 245 },{
 246     0x0000, 0x3331, 0x6662, 0x5553, 0xCCC4, 0xFFF5, 0xAAA6, 0x9997,
 247     0x89A9, 0xBA98, 0xEFCB, 0xDCFA, 0x456D, 0x765C, 0x230F, 0x103E,
 248     0x0373, 0x3042, 0x6511, 0x5620, 0xCFB7, 0xFC86, 0xA9D5, 0x9AE4,
 249     0x8ADA, 0xB9EB, 0xECB8, 0xDF89, 0x461E, 0x752F, 0x207C, 0x134D,
 250     0x06E6, 0x35D7, 0x6084, 0x53B5, 0xCA22, 0xF913, 0xAC40, 0x9F71,
 251     0x8F4F, 0xBC7E, 0xE92D, 0xDA1C, 0x438B, 0x70BA, 0x25E9, 0x16D8,
 252     0x0595, 0x36A4, 0x63F7, 0x50C6, 0xC951, 0xFA60, 0xAF33, 0x9C02,
 253     0x8C3C, 0xBF0D, 0xEA5E, 0xD96F, 0x40F8, 0x73C9, 0x269A, 0x15AB,
 254     0x0DCC, 0x3EFD, 0x6BAE, 0x589F, 0xC108, 0xF239, 0xA76A, 0x945B,
 255     0x8465, 0xB754, 0xE207, 0xD136, 0x48A1, 0x7B90, 0x2EC3, 0x1DF2,
 256     0x0EBF, 0x3D8E, 0x68DD, 0x5BEC, 0xC27B, 0xF14A, 0xA419, 0x9728,
 257     0x8716, 0xB427, 0xE174, 0xD245, 0x4BD2, 0x78E3, 0x2DB0, 0x1E81,
 258     0x0B2A, 0x381B, 0x6D48, 0x5E79, 0xC7EE, 0xF4DF, 0xA18C, 0x92BD,
 259     0x8283, 0xB1B2, 0xE4E1, 0xD7D0, 0x4E47, 0x7D76, 0x2825, 0x1B14,
 260     0x0859, 0x3B68, 0x6E3B, 0x5D0A, 0xC49D, 0xF7AC, 0xA2FF, 0x91CE,
 261     0x81F0, 0xB2C1, 0xE792, 0xD4A3, 0x4D34, 0x7E05, 0x2B56, 0x1867,
 262     0x1B98, 0x28A9, 0x7DFA, 0x4ECB, 0xD75C, 0xE46D, 0xB13E, 0x820F,
 263     0x9231, 0xA100, 0xF453, 0xC762, 0x5EF5, 0x6DC4, 0x3897, 0x0BA6,
 264     0x18EB, 0x2BDA, 0x7E89, 0x4DB8, 0xD42F, 0xE71E, 0xB24D, 0x817C,
 265     0x9142, 0xA273, 0xF720, 0xC411, 0x5D86, 0x6EB7, 0x3BE4, 0x08D5,
 266     0x1D7E, 0x2E4F, 0x7B1C, 0x482D, 0xD1BA, 0xE28B, 0xB7D8, 0x84E9,
 267     0x94D7, 0xA7E6, 0xF2B5, 0xC184, 0x5813, 0x6B22, 0x3E71, 0x0D40,
 268     0x1E0D, 0x2D3C, 0x786F, 0x4B5E, 0xD2C9, 0xE1F8, 0xB4AB, 0x879A,
 269     0x97A4, 0xA495, 0xF1C6, 0xC2F7, 0x5B60, 0x6851, 0x3D02, 0x0E33,
 270     0x1654, 0x2565, 0x7036, 0x4307, 0xDA90, 0xE9A1, 0xBCF2, 0x8FC3,
 271     0x9FFD, 0xACCC, 0xF99F, 0xCAAE, 0x5339, 0x6008, 0x355B, 0x066A,
 272     0x1527, 0x2616, 0x7345, 0x4074, 0xD9E3, 0xEAD2, 0xBF81, 0x8CB0,
 273     0x9C8E, 0xAFBF, 0xFAEC, 0xC9DD, 0x504A, 0x637B, 0x3628, 0x0519,
 274     0x10B2, 0x2383, 0x76D0, 0x45E1, 0xDC76, 0xEF47, 0xBA14, 0x8925,
 275     0x991B, 0xAA2A, 0xFF79, 0xCC48, 0x55DF, 0x66EE, 0x33BD, 0x008C,
 276     0x13C1, 0x20F0, 0x75A3, 0x4692, 0xDF05, 0xEC34, 0xB967, 0x8A56,
 277     0x9A68, 0xA959, 0xFC0A, 0xCF3B, 0x56AC, 0x659D, 0x30CE, 0x03FF
 278 },{
 279     0x0000, 0x3730, 0x6E60, 0x5950, 0xDCC0, 0xEBF0, 0xB2A0, 0x8590,
 280     0xA9A1, 0x9E91, 0xC7C1, 0xF0F1, 0x7561, 0x4251, 0x1B01, 0x2C31,
 281     0x4363, 0x7453, 0x2D03, 0x1A33, 0x9FA3, 0xA893, 0xF1C3, 0xC6F3,
 282     0xEAC2, 0xDDF2, 0x84A2, 0xB392, 0x3602, 0x0132, 0x5862, 0x6F52,
 283     0x86C6, 0xB1F6, 0xE8A6, 0xDF96, 0x5A06, 0x6D36, 0x3466, 0x0356,
 284     0x2F67, 0x1857, 0x4107, 0x7637, 0xF3A7, 0xC497, 0x9DC7, 0xAAF7,
 285     0xC5A5, 0xF295, 0xABC5, 0x9CF5, 0x1965, 0x2E55, 0x7705, 0x4035,
 286     0x6C04, 0x5B34, 0x0264, 0x3554, 0xB0C4, 0x87F4, 0xDEA4, 0xE994,
 287     0x1DAD, 0x2A9D, 0x73CD, 0x44FD, 0xC16D, 0xF65D, 0xAF0D, 0x983D,
 288     0xB40C, 0x833C, 0xDA6C, 0xED5C, 0x68CC, 0x5FFC, 0x06AC, 0x319C,
 289     0x5ECE, 0x69FE, 0x30AE, 0x079E, 0x820E, 0xB53E, 0xEC6E, 0xDB5E,
 290     0xF76F, 0xC05F, 0x990F, 0xAE3F, 0x2BAF, 0x1C9F, 0x45CF, 0x72FF,
 291     0x9B6B, 0xAC5B, 0xF50B, 0xC23B, 0x47AB, 0x709B, 0x29CB, 0x1EFB,
 292     0x32CA, 0x05FA, 0x5CAA, 0x6B9A, 0xEE0A, 0xD93A, 0x806A, 0xB75A,
 293     0xD808, 0xEF38, 0xB668, 0x8158, 0x04C8, 0x33F8, 0x6AA8, 0x5D98,
 294     0x71A9, 0x4699, 0x1FC9, 0x28F9, 0xAD69, 0x9A59, 0xC309, 0xF439,
 295     0x3B5A, 0x0C6A, 0x553A, 0x620A, 0xE79A, 0xD0AA, 0x89FA, 0xBECA,
 296     0x92FB, 0xA5CB, 0xFC9B, 0xCBAB, 0x4E3B, 0x790B, 0x205B, 0x176B,
 297     0x7839, 0x4F09, 0x1659, 0x2169, 0xA4F9, 0x93C9, 0xCA99, 0xFDA9,
 298     0xD198, 0xE6A8, 0xBFF8, 0x88C8, 0x0D58, 0x3A68, 0x6338, 0x5408,
 299     0xBD9C, 0x8AAC, 0xD3FC, 0xE4CC, 0x615C, 0x566C, 0x0F3C, 0x380C,
 300     0x143D, 0x230D, 0x7A5D, 0x4D6D, 0xC8FD, 0xFFCD, 0xA69D, 0x91AD,
 301     0xFEFF, 0xC9CF, 0x909F, 0xA7AF, 0x223F, 0x150F, 0x4C5F, 0x7B6F,
 302     0x575E, 0x606E, 0x393E, 0x0E0E, 0x8B9E, 0xBCAE, 0xE5FE, 0xD2CE,
 303     0x26F7, 0x11C7, 0x4897, 0x7FA7, 0xFA37, 0xCD07, 0x9457, 0xA367,
 304     0x8F56, 0xB866, 0xE136, 0xD606, 0x5396, 0x64A6, 0x3DF6, 0x0AC6,
 305     0x6594, 0x52A4, 0x0BF4, 0x3CC4, 0xB954, 0x8E64, 0xD734, 0xE004,
 306     0xCC35, 0xFB05, 0xA255, 0x9565, 0x10F5, 0x27C5, 0x7E95, 0x49A5,
 307     0xA031, 0x9701, 0xCE51, 0xF961, 0x7CF1, 0x4BC1, 0x1291, 0x25A1,
 308     0x0990, 0x3EA0, 0x67F0, 0x50C0, 0xD550, 0xE260, 0xBB30, 0x8C00,
 309     0xE352, 0xD462, 0x8D32, 0xBA02, 0x3F92, 0x08A2, 0x51F2, 0x66C2,
 310     0x4AF3, 0x7DC3, 0x2493, 0x13A3, 0x9633, 0xA103, 0xF853, 0xCF63
 311 },{
 312     0x0000, 0x76B4, 0xED68, 0x9BDC, 0xCAF1, 0xBC45, 0x2799, 0x512D,
 313     0x85C3, 0xF377, 0x68AB, 0x1E1F, 0x4F32, 0x3986, 0xA25A, 0xD4EE,
 314     0x1BA7, 0x6D13, 0xF6CF, 0x807B, 0xD156, 0xA7E2, 0x3C3E, 0x4A8A,
 315     0x9E64, 0xE8D0, 0x730C, 0x05B8, 0x5495, 0x2221, 0xB9FD, 0xCF49,
 316     0x374E, 0x41FA, 0xDA26, 0xAC92, 0xFDBF, 0x8B0B, 0x10D7, 0x6663,
 317     0xB28D, 0xC439, 0x5FE5, 0x2951, 0x787C, 0x0EC8, 0x9514, 0xE3A0,
 318     0x2CE9, 0x5A5D, 0xC181, 0xB735, 0xE618, 0x90AC, 0x0B70, 0x7DC4,
 319     0xA92A, 0xDF9E, 0x4442, 0x32F6, 0x63DB, 0x156F, 0x8EB3, 0xF807,
 320     0x6E9C, 0x1828, 0x83F4, 0xF540, 0xA46D, 0xD2D9, 0x4905, 0x3FB1,
 321     0xEB5F, 0x9DEB, 0x0637, 0x7083, 0x21AE, 0x571A, 0xCCC6, 0xBA72,
 322     0x753B, 0x038F, 0x9853, 0xEEE7, 0xBFCA, 0xC97E, 0x52A2, 0x2416,
 323     0xF0F8, 0x864C, 0x1D90, 0x6B24, 0x3A09, 0x4CBD, 0xD761, 0xA1D5,
 324     0x59D2, 0x2F66, 0xB4BA, 0xC20E, 0x9323, 0xE597, 0x7E4B, 0x08FF,
 325     0xDC11, 0xAAA5, 0x3179, 0x47CD, 0x16E0, 0x6054, 0xFB88, 0x8D3C,
 326     0x4275, 0x34C1, 0xAF1D, 0xD9A9, 0x8884, 0xFE30, 0x65EC, 0x1358,
 327     0xC7B6, 0xB102, 0x2ADE, 0x5C6A, 0x0D47, 0x7BF3, 0xE02F, 0x969B,
 328     0xDD38, 0xAB8C, 0x3050, 0x46E4, 0x17C9, 0x617D, 0xFAA1, 0x8C15,
 329     0x58FB, 0x2E4F, 0xB593, 0xC327, 0x920A, 0xE4BE, 0x7F62, 0x09D6,
 330     0xC69F, 0xB02B, 0x2BF7, 0x5D43, 0x0C6E, 0x7ADA, 0xE106, 0x97B2,
 331     0x435C, 0x35E8, 0xAE34, 0xD880, 0x89AD, 0xFF19, 0x64C5, 0x1271,
 332     0xEA76, 0x9CC2, 0x071E, 0x71AA, 0x2087, 0x5633, 0xCDEF, 0xBB5B,
 333     0x6FB5, 0x1901, 0x82DD, 0xF469, 0xA544, 0xD3F0, 0x482C, 0x3E98,
 334     0xF1D1, 0x8765, 0x1CB9, 0x6A0D, 0x3B20, 0x4D94, 0xD648, 0xA0FC,
 335     0x7412, 0x02A6, 0x997A, 0xEFCE, 0xBEE3, 0xC857, 0x538B, 0x253F,
 336     0xB3A4, 0xC510, 0x5ECC, 0x2878, 0x7955, 0x0FE1, 0x943D, 0xE289,
 337     0x3667, 0x40D3, 0xDB0F, 0xADBB, 0xFC96, 0x8A22, 0x11FE, 0x674A,
 338     0xA803, 0xDEB7, 0x456B, 0x33DF, 0x62F2, 0x1446, 0x8F9A, 0xF92E,
 339     0x2DC0, 0x5B74, 0xC0A8, 0xB61C, 0xE731, 0x9185, 0x0A59, 0x7CED,
 340     0x84EA, 0xF25E, 0x6982, 0x1F36, 0x4E1B, 0x38AF, 0xA373, 0xD5C7,
 341     0x0129, 0x779D, 0xEC41, 0x9AF5, 0xCBD8, 0xBD6C, 0x26B0, 0x5004,
 342     0x9F4D, 0xE9F9, 0x7225, 0x0491, 0x55BC, 0x2308, 0xB8D4, 0xCE60,
 343     0x1A8E, 0x6C3A, 0xF7E6, 0x8152, 0xD07F, 0xA6CB, 0x3D17, 0x4BA3
 344 },{
 345     0x0000, 0xAA51, 0x4483, 0xEED2, 0x8906, 0x2357, 0xCD85, 0x67D4,
 346     0x022D, 0xA87C, 0x46AE, 0xECFF, 0x8B2B, 0x217A, 0xCFA8, 0x65F9,
 347     0x045A, 0xAE0B, 0x40D9, 0xEA88, 0x8D5C, 0x270D, 0xC9DF, 0x638E,
 348     0x0677, 0xAC26, 0x42F4, 0xE8A5, 0x8F71, 0x2520, 0xCBF2, 0x61A3,
 349     0x08B4, 0xA2E5, 0x4C37, 0xE666, 0x81B2, 0x2BE3, 0xC531, 0x6F60,
 350     0x0A99, 0xA0C8, 0x4E1A, 0xE44B, 0x839F, 0x29CE, 0xC71C, 0x6D4D,
 351     0x0CEE, 0xA6BF, 0x486D, 0xE23C, 0x85E8, 0x2FB9, 0xC16B, 0x6B3A,
 352     0x0EC3, 0xA492, 0x4A40, 0xE011, 0x87C5, 0x2D94, 0xC346, 0x6917,
 353     0x1168, 0xBB39, 0x55EB, 0xFFBA, 0x986E, 0x323F, 0xDCED, 0x76BC,
 354     0x1345, 0xB914, 0x57C6, 0xFD97, 0x9A43, 0x3012, 0xDEC0, 0x7491,
 355     0x1532, 0xBF63, 0x51B1, 0xFBE0, 0x9C34, 0x3665, 0xD8B7, 0x72E6,
 356     0x171F, 0xBD4E, 0x539C, 0xF9CD, 0x9E19, 0x3448, 0xDA9A, 0x70CB,
 357     0x19DC, 0xB38D, 0x5D5F, 0xF70E, 0x90DA, 0x3A8B, 0xD459, 0x7E08,
 358     0x1BF1, 0xB1A0, 0x5F72, 0xF523, 0x92F7, 0x38A6, 0xD674, 0x7C25,
 359     0x1D86, 0xB7D7, 0x5905, 0xF354, 0x9480, 0x3ED1, 0xD003, 0x7A52,
 360     0x1FAB, 0xB5FA, 0x5B28, 0xF179, 0x96AD, 0x3CFC, 0xD22E, 0x787F,
 361     0x22D0, 0x8881, 0x6653, 0xCC02, 0xABD6, 0x0187, 0xEF55, 0x4504,
 362     0x20FD, 0x8AAC, 0x647E, 0xCE2F, 0xA9FB, 0x03AA, 0xED78, 0x4729,
 363     0x268A, 0x8CDB, 0x6209, 0xC858, 0xAF8C, 0x05DD, 0xEB0F, 0x415E,
 364     0x24A7, 0x8EF6, 0x6024, 0xCA75, 0xADA1, 0x07F0, 0xE922, 0x4373,
 365     0x2A64, 0x8035, 0x6EE7, 0xC4B6, 0xA362, 0x0933, 0xE7E1, 0x4DB0,
 366     0x2849, 0x8218, 0x6CCA, 0xC69B, 0xA14F, 0x0B1E, 0xE5CC, 0x4F9D,
 367     0x2E3E, 0x846F, 0x6ABD, 0xC0EC, 0xA738, 0x0D69, 0xE3BB, 0x49EA,
 368     0x2C13, 0x8642, 0x6890, 0xC2C1, 0xA515, 0x0F44, 0xE196, 0x4BC7,
 369     0x33B8, 0x99E9, 0x773B, 0xDD6A, 0xBABE, 0x10EF, 0xFE3D, 0x546C,
 370     0x3195, 0x9BC4, 0x7516, 0xDF47, 0xB893, 0x12C2, 0xFC10, 0x5641,
 371     0x37E2, 0x9DB3, 0x7361, 0xD930, 0xBEE4, 0x14B5, 0xFA67, 0x5036,
 372     0x35CF, 0x9F9E, 0x714C, 0xDB1D, 0xBCC9, 0x1698, 0xF84A, 0x521B,
 373     0x3B0C, 0x915D, 0x7F8F, 0xD5DE, 0xB20A, 0x185B, 0xF689, 0x5CD8,
 374     0x3921, 0x9370, 0x7DA2, 0xD7F3, 0xB027, 0x1A76, 0xF4A4, 0x5EF5,
 375     0x3F56, 0x9507, 0x7BD5, 0xD184, 0xB650, 0x1C01, 0xF2D3, 0x5882,
 376     0x3D7B, 0x972A, 0x79F8, 0xD3A9, 0xB47D, 0x1E2C, 0xF0FE, 0x5AAF
 377 },{
 378     0x0000, 0x45A0, 0x8B40, 0xCEE0, 0x06A1, 0x4301, 0x8DE1, 0xC841,
 379     0x0D42, 0x48E2, 0x8602, 0xC3A2, 0x0BE3, 0x4E43, 0x80A3, 0xC503,
 380     0x1A84, 0x5F24, 0x91C4, 0xD464, 0x1C25, 0x5985, 0x9765, 0xD2C5,
 381     0x17C6, 0x5266, 0x9C86, 0xD926, 0x1167, 0x54C7, 0x9A27, 0xDF87,
 382     0x3508, 0x70A8, 0xBE48, 0xFBE8, 0x33A9, 0x7609, 0xB8E9, 0xFD49,
 383     0x384A, 0x7DEA, 0xB30A, 0xF6AA, 0x3EEB, 0x7B4B, 0xB5AB, 0xF00B,
 384     0x2F8C, 0x6A2C, 0xA4CC, 0xE16C, 0x292D, 0x6C8D, 0xA26D, 0xE7CD,
 385     0x22CE, 0x676E, 0xA98E, 0xEC2E, 0x246F, 0x61CF, 0xAF2F, 0xEA8F,
 386     0x6A10, 0x2FB0, 0xE150, 0xA4F0, 0x6CB1, 0x2911, 0xE7F1, 0xA251,
 387     0x6752, 0x22F2, 0xEC12, 0xA9B2, 0x61F3, 0x2453, 0xEAB3, 0xAF13,
 388     0x7094, 0x3534, 0xFBD4, 0xBE74, 0x7635, 0x3395, 0xFD75, 0xB8D5,
 389     0x7DD6, 0x3876, 0xF696, 0xB336, 0x7B77, 0x3ED7, 0xF037, 0xB597,
 390     0x5F18, 0x1AB8, 0xD458, 0x91F8, 0x59B9, 0x1C19, 0xD2F9, 0x9759,
 391     0x525A, 0x17FA, 0xD91A, 0x9CBA, 0x54FB, 0x115B, 0xDFBB, 0x9A1B,
 392     0x459C, 0x003C, 0xCEDC, 0x8B7C, 0x433D, 0x069D, 0xC87D, 0x8DDD,
 393     0x48DE, 0x0D7E, 0xC39E, 0x863E, 0x4E7F, 0x0BDF, 0xC53F, 0x809F,
 394     0xD420, 0x9180, 0x5F60, 0x1AC0, 0xD281, 0x9721, 0x59C1, 0x1C61,
 395     0xD962, 0x9CC2, 0x5222, 0x1782, 0xDFC3, 0x9A63, 0x5483, 0x1123,
 396     0xCEA4, 0x8B04, 0x45E4, 0x0044, 0xC805, 0x8DA5, 0x4345, 0x06E5,
 397     0xC3E6, 0x8646, 0x48A6, 0x0D06, 0xC547, 0x80E7, 0x4E07, 0x0BA7,
 398     0xE128, 0xA488, 0x6A68, 0x2FC8, 0xE789, 0xA229, 0x6CC9, 0x2969,
 399     0xEC6A, 0xA9CA, 0x672A, 0x228A, 0xEACB, 0xAF6B, 0x618B, 0x242B,
 400     0xFBAC, 0xBE0C, 0x70EC, 0x354C, 0xFD0D, 0xB8AD, 0x764D, 0x33ED,
 401     0xF6EE, 0xB34E, 0x7DAE, 0x380E, 0xF04F, 0xB5EF, 0x7B0F, 0x3EAF,
 402     0xBE30, 0xFB90, 0x3570, 0x70D0, 0xB891, 0xFD31, 0x33D1, 0x7671,
 403     0xB372, 0xF6D2, 0x3832, 0x7D92, 0xB5D3, 0xF073, 0x3E93, 0x7B33,
 404     0xA4B4, 0xE114, 0x2FF4, 0x6A54, 0xA215, 0xE7B5, 0x2955, 0x6CF5,
 405     0xA9F6, 0xEC56, 0x22B6, 0x6716, 0xAF57, 0xEAF7, 0x2417, 0x61B7,
 406     0x8B38, 0xCE98, 0x0078, 0x45D8, 0x8D99, 0xC839, 0x06D9, 0x4379,
 407     0x867A, 0xC3DA, 0x0D3A, 0x489A, 0x80DB, 0xC57B, 0x0B9B, 0x4E3B,
 408     0x91BC, 0xD41C, 0x1AFC, 0x5F5C, 0x971D, 0xD2BD, 0x1C5D, 0x59FD,
 409     0x9CFE, 0xD95E, 0x17BE, 0x521E, 0x9A5F, 0xDFFF, 0x111F, 0x54BF
 410 },{
 411     0x0000, 0xB861, 0x60E3, 0xD882, 0xC1C6, 0x79A7, 0xA125, 0x1944,
 412     0x93AD, 0x2BCC, 0xF34E, 0x4B2F, 0x526B, 0xEA0A, 0x3288, 0x8AE9,
 413     0x377B, 0x8F1A, 0x5798, 0xEFF9, 0xF6BD, 0x4EDC, 0x965E, 0x2E3F,
 414     0xA4D6, 0x1CB7, 0xC435, 0x7C54, 0x6510, 0xDD71, 0x05F3, 0xBD92,
 415     0x6EF6, 0xD697, 0x0E15, 0xB674, 0xAF30, 0x1751, 0xCFD3, 0x77B2,
 416     0xFD5B, 0x453A, 0x9DB8, 0x25D9, 0x3C9D, 0x84FC, 0x5C7E, 0xE41F,
 417     0x598D, 0xE1EC, 0x396E, 0x810F, 0x984B, 0x202A, 0xF8A8, 0x40C9,
 418     0xCA20, 0x7241, 0xAAC3, 0x12A2, 0x0BE6, 0xB387, 0x6B05, 0xD364,
 419     0xDDEC, 0x658D, 0xBD0F, 0x056E, 0x1C2A, 0xA44B, 0x7CC9, 0xC4A8,
 420     0x4E41, 0xF620, 0x2EA2, 0x96C3, 0x8F87, 0x37E6, 0xEF64, 0x5705,
 421     0xEA97, 0x52F6, 0x8A74, 0x3215, 0x2B51, 0x9330, 0x4BB2, 0xF3D3,
 422     0x793A, 0xC15B, 0x19D9, 0xA1B8, 0xB8FC, 0x009D, 0xD81F, 0x607E,
 423     0xB31A, 0x0B7B, 0xD3F9, 0x6B98, 0x72DC, 0xCABD, 0x123F, 0xAA5E,
 424     0x20B7, 0x98D6, 0x4054, 0xF835, 0xE171, 0x5910, 0x8192, 0x39F3,
 425     0x8461, 0x3C00, 0xE482, 0x5CE3, 0x45A7, 0xFDC6, 0x2544, 0x9D25,
 426     0x17CC, 0xAFAD, 0x772F, 0xCF4E, 0xD60A, 0x6E6B, 0xB6E9, 0x0E88,
 427     0xABF9, 0x1398, 0xCB1A, 0x737B, 0x6A3F, 0xD25E, 0x0ADC, 0xB2BD,
 428     0x3854, 0x8035, 0x58B7, 0xE0D6, 0xF992, 0x41F3, 0x9971, 0x2110,
 429     0x9C82, 0x24E3, 0xFC61, 0x4400, 0x5D44, 0xE525, 0x3DA7, 0x85C6,
 430     0x0F2F, 0xB74E, 0x6FCC, 0xD7AD, 0xCEE9, 0x7688, 0xAE0A, 0x166B,
 431     0xC50F, 0x7D6E, 0xA5EC, 0x1D8D, 0x04C9, 0xBCA8, 0x642A, 0xDC4B,
 432     0x56A2, 0xEEC3, 0x3641, 0x8E20, 0x9764, 0x2F05, 0xF787, 0x4FE6,
 433     0xF274, 0x4A15, 0x9297, 0x2AF6, 0x33B2, 0x8BD3, 0x5351, 0xEB30,
 434     0x61D9, 0xD9B8, 0x013A, 0xB95B, 0xA01F, 0x187E, 0xC0FC, 0x789D,
 435     0x7615, 0xCE74, 0x16F6, 0xAE97, 0xB7D3, 0x0FB2, 0xD730, 0x6F51,
 436     0xE5B8, 0x5DD9, 0x855B, 0x3D3A, 0x247E, 0x9C1F, 0x449D, 0xFCFC,
 437     0x416E, 0xF90F, 0x218D, 0x99EC, 0x80A8, 0x38C9, 0xE04B, 0x582A,
 438     0xD2C3, 0x6AA2, 0xB220, 0x0A41, 0x1305, 0xAB64, 0x73E6, 0xCB87,
 439     0x18E3, 0xA082, 0x7800, 0xC061, 0xD925, 0x6144, 0xB9C6, 0x01A7,
 440     0x8B4E, 0x332F, 0xEBAD, 0x53CC, 0x4A88, 0xF2E9, 0x2A6B, 0x920A,
 441     0x2F98, 0x97F9, 0x4F7B, 0xF71A, 0xEE5E, 0x563F, 0x8EBD, 0x36DC,
 442     0xBC35, 0x0454, 0xDCD6, 0x64B7, 0x7DF3, 0xC592, 0x1D10, 0xA571
 443 },{
 444     0x0000, 0x47D3, 0x8FA6, 0xC875, 0x0F6D, 0x48BE, 0x80CB, 0xC718,
 445     0x1EDA, 0x5909, 0x917C, 0xD6AF, 0x11B7, 0x5664, 0x9E11, 0xD9C2,
 446     0x3DB4, 0x7A67, 0xB212, 0xF5C1, 0x32D9, 0x750A, 0xBD7F, 0xFAAC,
 447     0x236E, 0x64BD, 0xACC8, 0xEB1B, 0x2C03, 0x6BD0, 0xA3A5, 0xE476,
 448     0x7B68, 0x3CBB, 0xF4CE, 0xB31D, 0x7405, 0x33D6, 0xFBA3, 0xBC70,
 449     0x65B2, 0x2261, 0xEA14, 0xADC7, 0x6ADF, 0x2D0C, 0xE579, 0xA2AA,
 450     0x46DC, 0x010F, 0xC97A, 0x8EA9, 0x49B1, 0x0E62, 0xC617, 0x81C4,
 451     0x5806, 0x1FD5, 0xD7A0, 0x9073, 0x576B, 0x10B8, 0xD8CD, 0x9F1E,
 452     0xF6D0, 0xB103, 0x7976, 0x3EA5, 0xF9BD, 0xBE6E, 0x761B, 0x31C8,
 453     0xE80A, 0xAFD9, 0x67AC, 0x207F, 0xE767, 0xA0B4, 0x68C1, 0x2F12,
 454     0xCB64, 0x8CB7, 0x44C2, 0x0311, 0xC409, 0x83DA, 0x4BAF, 0x0C7C,
 455     0xD5BE, 0x926D, 0x5A18, 0x1DCB, 0xDAD3, 0x9D00, 0x5575, 0x12A6,
 456     0x8DB8, 0xCA6B, 0x021E, 0x45CD, 0x82D5, 0xC506, 0x0D73, 0x4AA0,
 457     0x9362, 0xD4B1, 0x1CC4, 0x5B17, 0x9C0F, 0xDBDC, 0x13A9, 0x547A,
 458     0xB00C, 0xF7DF, 0x3FAA, 0x7879, 0xBF61, 0xF8B2, 0x30C7, 0x7714,
 459     0xAED6, 0xE905, 0x2170, 0x66A3, 0xA1BB, 0xE668, 0x2E1D, 0x69CE,
 460     0xFD81, 0xBA52, 0x7227, 0x35F4, 0xF2EC, 0xB53F, 0x7D4A, 0x3A99,
 461     0xE35B, 0xA488, 0x6CFD, 0x2B2E, 0xEC36, 0xABE5, 0x6390, 0x2443,
 462     0xC035, 0x87E6, 0x4F93, 0x0840, 0xCF58, 0x888B, 0x40FE, 0x072D,
 463     0xDEEF, 0x993C, 0x5149, 0x169A, 0xD182, 0x9651, 0x5E24, 0x19F7,
 464     0x86E9, 0xC13A, 0x094F, 0x4E9C, 0x8984, 0xCE57, 0x0622, 0x41F1,
 465     0x9833, 0xDFE0, 0x1795, 0x5046, 0x975E, 0xD08D, 0x18F8, 0x5F2B,
 466     0xBB5D, 0xFC8E, 0x34FB, 0x7328, 0xB430, 0xF3E3, 0x3B96, 0x7C45,
 467     0xA587, 0xE254, 0x2A21, 0x6DF2, 0xAAEA, 0xED39, 0x254C, 0x629F,
 468     0x0B51, 0x4C82, 0x84F7, 0xC324, 0x043C, 0x43EF, 0x8B9A, 0xCC49,
 469     0x158B, 0x5258, 0x9A2D, 0xDDFE, 0x1AE6, 0x5D35, 0x9540, 0xD293,
 470     0x36E5, 0x7136, 0xB943, 0xFE90, 0x3988, 0x7E5B, 0xB62E, 0xF1FD,
 471     0x283F, 0x6FEC, 0xA799, 0xE04A, 0x2752, 0x6081, 0xA8F4, 0xEF27,
 472     0x7039, 0x37EA, 0xFF9F, 0xB84C, 0x7F54, 0x3887, 0xF0F2, 0xB721,
 473     0x6EE3, 0x2930, 0xE145, 0xA696, 0x618E, 0x265D, 0xEE28, 0xA9FB,
 474     0x4D8D, 0x0A5E, 0xC22B, 0x85F8, 0x42E0, 0x0533, 0xCD46, 0x8A95,
 475     0x5357, 0x1484, 0xDCF1, 0x9B22, 0x5C3A, 0x1BE9, 0xD39C, 0x944F
 476 }};
 477
 478 /* Non - Reflected */
 479 uint16_t util_crc16(uint16_t current, const char *GMQCC_RESTRICT k, size_t len) {
 480     uint16_t h = current;
 481
 482     /* don't load twice */
 483     const uint8_t *GMQCC_RESTRICT data = (const uint8_t *GMQCC_RESTRICT)k;
 484     size_t n;
 485
 486     /* deal with the first bytes as bytes until we reach an 8 byte boundary */
 487     while (len & 7) {
 488         h = (uint16_t)(h << 8) ^ (*util_crc16_table)[(h >> 8) ^ *data++];
 489         --len;
 490     }
 491
 492     #define SELECT_BULK(X, MOD) util_crc16_table[(X)][data[7-(X)] ^ (MOD)]
 493     #define SELECT_DATA(X)      util_crc16_table[(X)][data[7-(X)]]
 494
 495     for (n = len / 8; n; --n) {
 496         h = SELECT_BULK(7, (h >> 8))   ^
 497             SELECT_BULK(6, (h & 0xFF)) ^
 498             SELECT_DATA(5) ^
 499             SELECT_DATA(4) ^
 500             SELECT_DATA(3) ^
 501             SELECT_DATA(2) ^
 502             SELECT_DATA(1) ^
 503             SELECT_DATA(0);
 504         data += 8;
 505         len  -= 8;
 506     }
 507
 508     #undef SELECT_BULK
 509     #undef SELECT_DATA
 510
 511     /* deal with the rest with the byte method */
 512     for (n = len & 7; n; --n)
 513         h = (uint16_t)(h << 8) ^ (*util_crc16_table)[(h >> 8) ^ *data++];
 514
 515     return h;
 516 }
 517
 518 /*
 519  * modifier is the match to make and the transposition from it, while add is the upper-value that determines the
 520  * transposition from uppercase to lower case.
 521  */
 522 static size_t util_strtransform(const char *in, char *out, size_t outsz, const char *mod, int add) {
 523     size_t sz = 1;
 524     for (; *in && sz < outsz; ++in, ++out, ++sz) {
 525         *out = (*in == mod[0])
 526                     ? mod[1]
 527                     : (util_isalpha(*in) && ((add > 0) ? util_isupper(*in) : !util_isupper(*in)))
 528                         ? *in + add
 529                         : *in;
 530     }
 531     *out = 0;
 532     return sz-1;
 533 }
 534
 535 size_t util_strtocmd(const char *in, char *out, size_t outsz) {
 536     return util_strtransform(in, out, outsz, "-_", 'A'-'a');
 537 }
 538 size_t util_strtononcmd(const char *in, char *out, size_t outsz) {
 539     return util_strtransform(in, out, outsz, "_-", 'a'-'A');
 540 }
 541 size_t util_optimizationtostr(const char *in, char *out, size_t outsz) {
 542     return util_strtransform(in, out, outsz, "_ ", 'a'-'A');
 543 }
 544
 545 static int util_vasprintf(char **dat, const char *fmt, va_list args) {
 546     int     ret;
 547     int     len;
 548     char   *tmp = NULL;
 549     char    buf[128];
 550     va_list cpy;
 551
 552     va_copy(cpy, args);
 553     len = vsnprintf(buf, sizeof(buf), fmt, cpy);
 554     va_end (cpy);
 555
 556     if (len < 0)
 557         return len;
 558
 559     if (len < (int)sizeof(buf)) {
 560         *dat = util_strdup(buf);
 561         return len;
 562     }
 563
 564     tmp = (char*)mem_a(len + 1);
 565     if ((ret = vsnprintf(tmp, len + 1, fmt, args)) != len) {
 566         mem_d(tmp);
 567         *dat = NULL;
 568         return -1;
 569     }
 570
 571     *dat = tmp;
 572     return len;
 573 }
 574
 575 int util_snprintf(char *str, size_t size, const char *fmt, ...) {
 576     va_list  arg;
 577     int ret;
 578     va_start(arg, fmt);
 579     ret = vsnprintf(str, size, fmt, arg);
 580     va_end(arg);
 581     return ret;
 582 }
 583
 584 int util_asprintf(char **ret, const char *fmt, ...) {
 585     va_list  args;
 586     int read;
 587     va_start(args, fmt);
 588     read = util_vasprintf(ret, fmt, args);
 589     va_end(args);
 590     return read;
 591 }
 592
 593 int util_sscanf(const char *str, const char *format, ...) {
 594     va_list  args;
 595     int read;
 596     va_start(args, format);
 597     read = vsscanf(str, format, args);
 598     va_end(args);
 599     return read;
 600 }
 601
 602 char *util_strncpy(char *dest, const char *src, size_t n) {
 603     return strncpy(dest, src, n);
 604 }
 605
 606 char *util_strncat(char *dest, const char *src, size_t n) {
 607     return strncat(dest, src, n);
 608 }
 609
 610 char *util_strcat(char *dest, const char *src) {
 611     return strcat(dest, src);
 612 }
 613
 614 const char *util_strerror(int err) {
 615     return strerror(err);
 616 }
 617
 618 const struct tm *util_localtime(const time_t *timer) {
 619     return localtime(timer);
 620 }
 621
 622 const char *util_ctime(const time_t *timer) {
 623     return ctime(timer);
 624 }
 625
 626 int util_getline(char **lineptr, size_t *n, FILE *stream) {
 627     int   chr;
 628     int   ret;
 629     char *pos;
 630
 631     if (!lineptr || !n || !stream)
 632         return -1;
 633     if (!*lineptr) {
 634         if (!(*lineptr = (char*)mem_a((*n=64))))
 635             return -1;
 636     }
 637
 638     chr = *n;
 639     pos = *lineptr;
 640
 641     for (;;) {
 642         int c = getc(stream);
 643
 644         if (chr < 2) {
 645             *n += (*n > 16) ? *n : 64;
 646             chr = *n + *lineptr - pos;
 647             if (!(*lineptr = (char*)mem_r(*lineptr,*n)))
 648                 return -1;
 649             pos = *n - chr + *lineptr;
 650         }
 651
 652         if (ferror(stream))
 653             return -1;
 654         if (c == EOF) {
 655             if (pos == *lineptr)
 656                 return -1;
 657             else
 658                 break;
 659         }
 660
 661         *pos++ = c;
 662         chr--;
 663         if (c == '\n')
 664             break;
 665     }
 666     *pos = '\0';
 667     return (ret = pos - *lineptr);
 668 }
 669
 670 #ifndef _WIN32
 671 #include <unistd.h>
 672 bool util_isatty(FILE *file) {
 673     if (file == stdout) return !!isatty(STDOUT_FILENO);
 674     if (file == stderr) return !!isatty(STDERR_FILENO);
 675     return false;
 676 }
 677 #else
 678 bool util_isatty(FILE *file) {
 679     return false;
 680 }
 681 #endif
 682
 683 /*
 684  * A small noncryptographic PRNG based on:
 685  * http://burtleburtle.net/bob/rand/smallprng.html
 686  */
 687 static uint32_t util_rand_state[4] = {
 688     0xF1EA5EED, 0x00000000,
 689     0x00000000, 0x00000000
 690 };
 691
 692 #define util_rand_rot(X, Y) (((X)<<(Y))|((X)>>(32-(Y))))
 693
 694 uint32_t util_rand() {
 695     uint32_t last;
 696
 697     last               = util_rand_state[0] - util_rand_rot(util_rand_state[1], 27);
 698     util_rand_state[0] = util_rand_state[1] ^ util_rand_rot(util_rand_state[2], 17);
 699     util_rand_state[1] = util_rand_state[2] + util_rand_state[3];
 700     util_rand_state[2] = util_rand_state[3] + last;
 701     util_rand_state[3] = util_rand_state[0] + last;
 702
 703     return util_rand_state[3];
 704 }
 705
 706 #undef util_rand_rot
 707
 708 void util_seed(uint32_t value) {
 709     size_t i;
 710
 711     util_rand_state[0] = 0xF1EA5EED;
 712     util_rand_state[1] = value;
 713     util_rand_state[2] = value;
 714     util_rand_state[3] = value;
 715
 716     for (i = 0; i < 20; ++i)
 717         (void)util_rand();
 718 }
 719
 720 size_t hash(const char *string) {
 721     size_t hash = 0;
 722     for(; *string; ++string) {
 723         hash += *string;
 724         hash += (hash << 10);
 725         hash ^= (hash >> 6);
 726     }
 727     hash += hash << 3;
 728     hash ^= hash >> 11;
 729     hash += hash << 15;
 730     return hash;
 731 }
 732