util.c

   1 /*
   2  * Copyright (C) 2012, 2013
   3  *     Dale Weiler
   4  *     Wolfgang Bumiller
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   7  * this software and associated documentation files (the "Software"), to deal in
   8  * the Software without restriction, including without limitation the rights to
   9  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  10  * of the Software, and to permit persons to whom the Software is furnished to do
  11  * so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all
  14  * copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24 #define GMQCC_PLATFORM_HEADER
  25 #include "gmqcc.h"
  26 #include "platform.h"
  27
  28 /*
  29  * Initially this was handled with a table in the gmqcc.h header, but
  30  * much to my surprise the contents of the table was duplicated for
  31  * each translation unit, causing all these strings to be duplicated
  32  * for every .c file it was included into. This method culls back on
  33  * it. This is a 'utility' function because the executor also depends
  34  * on this for disassembled byte-code.
  35  */
  36 const char *util_instr_str[VINSTR_END] = {
  37     "DONE",       "MUL_F",      "MUL_V",      "MUL_FV",
  38     "MUL_VF",     "DIV_F",      "ADD_F",      "ADD_V",
  39     "SUB_F",      "SUB_V",      "EQ_F",       "EQ_V",
  40     "EQ_S",       "EQ_E",       "EQ_FNC",     "NE_F",
  41     "NE_V",       "NE_S",       "NE_E",       "NE_FNC",
  42     "LE",         "GE",         "LT",         "GT",
  43     "LOAD_F",     "LOAD_V",     "LOAD_S",     "LOAD_ENT",
  44     "LOAD_FLD",   "LOAD_FNC",   "ADDRESS",    "STORE_F",
  45     "STORE_V",    "STORE_S",    "STORE_ENT",  "STORE_FLD",
  46     "STORE_FNC",  "STOREP_F",   "STOREP_V",   "STOREP_S",
  47     "STOREP_ENT", "STOREP_FLD", "STOREP_FNC", "RETURN",
  48     "NOT_F",      "NOT_V",      "NOT_S",      "NOT_ENT",
  49     "NOT_FNC",    "IF",         "IFNOT",      "CALL0",
  50     "CALL1",      "CALL2",      "CALL3",      "CALL4",
  51     "CALL5",      "CALL6",      "CALL7",      "CALL8",
  52     "STATE",      "GOTO",       "AND",        "OR",
  53     "BITAND",     "BITOR"
  54 };
  55
  56 /*
  57  * only required if big endian .. otherwise no need to swap
  58  * data.
  59  */
  60 #if PLATFORM_BYTE_ORDER == GMQCC_BYTE_ORDER_BIG
  61     static GMQCC_INLINE void util_swap16(uint16_t *d, size_t l) {
  62         while (l--) {
  63             d[l] = (d[l] << 8) | (d[l] >> 8);
  64         }
  65     }
  66
  67     static GMQCC_INLINE void util_swap32(uint32_t *d, size_t l) {
  68         while (l--) {
  69             uint32_t v;
  70             v = ((d[l] << 8) & 0xFF00FF00) | ((d[l] >> 8) & 0x00FF00FF);
  71             d[l] = (v << 16) | (v >> 16);
  72         }
  73     }
  74
  75     /* Some strange system doesn't like constants that big, AND doesn't recognize an ULL suffix
  76      * so let's go the safe way
  77      */
  78     static GMQCC_INLINE void util_swap64(uint32_t *d, size_t l) {
  79         /*
  80         while (l--) {
  81             uint64_t v;
  82             v = ((d[l] << 8) & 0xFF00FF00FF00FF00) | ((d[l] >> 8) & 0x00FF00FF00FF00FF);
  83             v = ((v << 16) & 0xFFFF0000FFFF0000) | ((v >> 16) & 0x0000FFFF0000FFFF);
  84             d[l] = (v << 32) | (v >> 32);
  85         }
  86         */
  87         size_t i;
  88         for (i = 0; i < l; i += 2) {
  89             uint32_t v1 = d[i];
  90             d[i] = d[i+1];
  91             d[i+1] = v1;
  92             util_swap32(d+i, 2);
  93         }
  94     }
  95 #endif
  96
  97 void util_endianswap(void *_data, size_t length, unsigned int typesize) {
  98 #   if PLATFORM_BYTE_ORDER == -1 /* runtime check */
  99     if (*((char*)&typesize))
 100         return;
 101 #else
 102     /* prevent unused warnings */
 103     (void) _data;
 104     (void) length;
 105     (void) typesize;
 106
 107 #   if PLATFORM_BYTE_ORDER == GMQCC_BYTE_ORDER_LITTLE
 108         return;
 109 #   else
 110         switch (typesize) {
 111             case 1: return;
 112             case 2:
 113                 util_swap16((uint16_t*)_data, length>>1);
 114                 return;
 115             case 4:
 116                 util_swap32((uint32_t*)_data, length>>2);
 117                 return;
 118             case 8:
 119                 util_swap64((uint32_t*)_data, length>>3);
 120                 return;
 121
 122             default: exit(EXIT_FAILURE); /* please blow the fuck up! */
 123         }
 124 #   endif
 125 #endif
 126 }
 127
 128 /*
 129 * CRC algorithms vary in the width of the polynomial, the value of said polynomial,
 130 * the initial value used for the register, weather the bits of each byte are reflected
 131 * before being processed, weather the algorithm itself feeds input bytes through the
 132 * register or XORs them with a byte from one end and then straight into the table, as
 133 * well as (but not limited to the idea of reflected versions) where the final register
 134 * value becomes reversed, and finally weather the value itself is used to XOR the final
 135 * register value. AS such you can already imagine how painfully annoying CRCs are,
 136 * of course we stand to target Quake, which expects it's certain set of rules for proper
 137 * calculation of a CRC.
 138 *
 139 * In most traditional CRC algorithms on uses a reflected table driven method where a value
 140 * or register is reflected if it's bits are swapped around it's center. For example:
 141 * take the bits 0101 is the 4-bit reflection of 1010, and respectfully 0011 would be the
 142 * reflection of 1100. Quake however expects a NON-Reflected CRC on the output, but still
 143 * requires a final XOR on the values (0xFFFF and 0x0000) this is a standard CCITT CRC-16
 144 * which I respectfully as a programmer don't agree with.
 145 *
 146 * So now you know what we target, and why we target it, despite how unsettling it may seem
 147 * but those are what Quake seems to request.
 148 */
 149
 150 static const uint16_t util_crc16_table[] = {
 151     0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108,
 152     0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210,
 153     0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B,
 154     0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401,
 155     0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE,
 156     0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6,
 157     0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D,
 158     0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
 159     0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5,
 160     0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC,
 161     0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4,
 162     0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD,
 163     0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13,
 164     0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A,
 165     0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E,
 166     0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
 167     0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1,
 168     0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB,
 169     0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0,
 170     0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8,
 171     0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657,
 172     0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9,
 173     0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882,
 174     0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
 175     0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E,
 176     0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07,
 177     0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D,
 178     0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
 179     0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
 180 };
 181
 182 /* Non - Reflected */
 183 uint16_t util_crc16(uint16_t current, const char *k, size_t len) {
 184     register uint16_t h = current;
 185     for (; len; --len, ++k)
 186         h = util_crc16_table[(h>>8)^((unsigned char)*k)]^(h<<8);
 187     return h;
 188 }
 189 /* Reflective Variation (for reference) */
 190 #if 0
 191 uint16_t util_crc16(const char *k, int len, const short clamp) {
 192     register uint16_t h= (uint16_t)0xFFFFFFFF;
 193     for (; len; --len, ++k)
 194     h = util_crc16_table[(h^((unsigned char)*k))&0xFF]^(h>>8);
 195     return (~h)%clamp;
 196 }
 197 #endif
 198
 199 /*
 200  * modifier is the match to make and the transposition from it, while add is the upper-value that determines the
 201  * transposition from uppercase to lower case.
 202  */
 203 static GMQCC_INLINE size_t util_strtransform(const char *in, char *out, size_t outsz, const char *mod, int add) {
 204     size_t sz = 1;
 205     for (; *in && sz < outsz; ++in, ++out, ++sz) {
 206         *out = (*in == mod[0])
 207                     ? mod[1]
 208                     : (util_isalpha(*in) && ((add > 0) ? util_isupper(*in) : !util_isupper(*in)))
 209                         ? *in + add
 210                         : *in;
 211     }
 212     *out = 0;
 213     return sz-1;
 214 }
 215
 216 size_t util_strtocmd(const char *in, char *out, size_t outsz) {
 217     return util_strtransform(in, out, outsz, "-_", 'A'-'a');
 218 }
 219 size_t util_strtononcmd(const char *in, char *out, size_t outsz) {
 220     return util_strtransform(in, out, outsz, "_-", 'a'-'A');
 221 }
 222 size_t util_optimizationtostr(const char *in, char *out, size_t outsz) {
 223     return util_strtransform(in, out, outsz, "_ ", 'a'-'A');
 224 }
 225
 226 int util_snprintf(char *str, size_t size, const char *fmt, ...) {
 227     va_list  arg;
 228     int      ret;
 229
 230     va_start(arg, fmt);
 231     ret = platform_vsnprintf(str, size, fmt, arg);
 232     va_end(arg);
 233
 234     return ret;
 235 }
 236
 237 int util_asprintf(char **ret, const char *fmt, ...) {
 238     va_list  args;
 239     int      read;
 240
 241     va_start(args, fmt);
 242     read = platform_vasprintf(ret, fmt, args);
 243     va_end  (args);
 244
 245     return read;
 246 }
 247
 248 int util_sscanf(const char *str, const char *format, ...) {
 249     va_list  args;
 250     int      read;
 251
 252     va_start(args, format);
 253     read = platform_vsscanf(str, format, args);
 254     va_end(args);
 255
 256     return read;
 257 }
 258
 259 char *util_strncpy(char *dest, const char *src, size_t n) {
 260     return platform_strncpy(dest, src, n);
 261 }
 262 char *util_strncat(char *dest, const char *src, size_t n) {
 263     return platform_strncat(dest, src, n);
 264 }
 265 char *util_strcat(char *dest, const char *src) {
 266     return platform_strcat(dest, src);
 267 }
 268 const char *util_strerror(int err) {
 269     return platform_strerror(err);
 270 }
 271
 272 const struct tm *util_localtime(const time_t *timer) {
 273     return platform_localtime(timer);
 274 }
 275 const char *util_ctime(const time_t *timer) {
 276     return platform_ctime(timer);
 277 }
 278
 279 bool util_isatty(fs_file_t *file) {
 280     if (file == (fs_file_t*)stdout) return !!platform_isatty(STDOUT_FILENO);
 281     if (file == (fs_file_t*)stderr) return !!platform_isatty(STDERR_FILENO);
 282     return false;
 283 }
 284 /*
 285  * A small noncryptographic PRNG based on:
 286  * http://burtleburtle.net/bob/rand/smallprng.html
 287  */
 288 static uint32_t util_rand_state[4] = {
 289     0xF1EA5EED, 0x00000000,
 290     0x00000000, 0x00000000
 291 };
 292
 293 #define util_rand_rot(X, Y) (((X)<<(Y))|((X)>>(32-(Y))))
 294
 295 uint32_t util_rand() {
 296     uint32_t last;
 297
 298     last               = util_rand_state[0] - util_rand_rot(util_rand_state[1], 27);
 299     util_rand_state[0] = util_rand_state[1] ^ util_rand_rot(util_rand_state[2], 17);
 300     util_rand_state[1] = util_rand_state[2] + util_rand_state[3];
 301     util_rand_state[2] = util_rand_state[3] + last;
 302     util_rand_state[3] = util_rand_state[0] + last;
 303
 304     return util_rand_state[3];
 305 }
 306
 307 #undef util_rand_rot
 308
 309 void util_seed(uint32_t value) {
 310     size_t i;
 311
 312     util_rand_state[0] = 0xF1EA5EED;
 313     util_rand_state[1] = value;
 314     util_rand_state[2] = value;
 315     util_rand_state[3] = value;
 316
 317     for (i = 0; i < 20; ++i)
 318         (void)util_rand();
 319 }
 320