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 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #include "gmqcc.h"
  28
  29 /*
  30  * Initially this was handled with a table in the gmqcc.h header, but
  31  * much to my surprise the contents of the table was duplicated for
  32  * each translation unit, causing all these strings to be duplicated
  33  * for every .c file it was included into. This method culls back on
  34  * it. This is a 'utility' function because the executor also depends
  35  * on this for disassembled byte-code.
  36  */
  37 const char *util_instr_str[VINSTR_END] = {
  38     "DONE",       "MUL_F",      "MUL_V",      "MUL_FV",
  39     "MUL_VF",     "DIV_F",      "ADD_F",      "ADD_V",
  40     "SUB_F",      "SUB_V",      "EQ_F",       "EQ_V",
  41     "EQ_S",       "EQ_E",       "EQ_FNC",     "NE_F",
  42     "NE_V",       "NE_S",       "NE_E",       "NE_FNC",
  43     "LE",         "GE",         "LT",         "GT",
  44     "LOAD_F",     "LOAD_V",     "LOAD_S",     "LOAD_ENT",
  45     "LOAD_FLD",   "LOAD_FNC",   "ADDRESS",    "STORE_F",
  46     "STORE_V",    "STORE_S",    "STORE_ENT",  "STORE_FLD",
  47     "STORE_FNC",  "STOREP_F",   "STOREP_V",   "STOREP_S",
  48     "STOREP_ENT", "STOREP_FLD", "STOREP_FNC", "RETURN",
  49     "NOT_F",      "NOT_V",      "NOT_S",      "NOT_ENT",
  50     "NOT_FNC",    "IF",         "IFNOT",      "CALL0",
  51     "CALL1",      "CALL2",      "CALL3",      "CALL4",
  52     "CALL5",      "CALL6",      "CALL7",      "CALL8",
  53     "STATE",      "GOTO",       "AND",        "OR",
  54     "BITAND",     "BITOR"
  55 };
  56
  57 void util_debug(const char *area, const char *ms, ...) {
  58     va_list  va;
  59     if (!OPTS_OPTION_BOOL(OPTION_DEBUG))
  60         return;
  61
  62     if (!strcmp(area, "MEM") && !OPTS_OPTION_BOOL(OPTION_MEMCHK))
  63         return;
  64
  65     va_start(va, ms);
  66     con_out ("[%s] ", area);
  67     con_vout(ms, va);
  68     va_end  (va);
  69 }
  70
  71 /*
  72  * only required if big endian .. otherwise no need to swap
  73  * data.
  74  */
  75 #if PLATFORM_BYTE_ORDER == GMQCC_BYTE_ORDER_BIG
  76     static GMQCC_INLINE void util_swap16(uint16_t *d, size_t l) {
  77         while (l--) {
  78             d[l] = (d[l] << 8) | (d[l] >> 8);
  79         }
  80     }
  81
  82     static GMQCC_INLINE void util_swap32(uint32_t *d, size_t l) {
  83         while (l--) {
  84             uint32_t v;
  85             v = ((d[l] << 8) & 0xFF00FF00) | ((d[l] >> 8) & 0x00FF00FF);
  86             d[l] = (v << 16) | (v >> 16);
  87         }
  88     }
  89
  90     /* Some strange system doesn't like constants that big, AND doesn't recognize an ULL suffix
  91      * so let's go the safe way
  92      */
  93     static GMQCC_INLINE void util_swap64(uint32_t *d, size_t l) {
  94         /*
  95         while (l--) {
  96             uint64_t v;
  97             v = ((d[l] << 8) & 0xFF00FF00FF00FF00) | ((d[l] >> 8) & 0x00FF00FF00FF00FF);
  98             v = ((v << 16) & 0xFFFF0000FFFF0000) | ((v >> 16) & 0x0000FFFF0000FFFF);
  99             d[l] = (v << 32) | (v >> 32);
 100         }
 101         */
 102         size_t i;
 103         for (i = 0; i < l; i += 2) {
 104             uint32_t v1 = d[i];
 105             d[i] = d[i+1];
 106             d[i+1] = v1;
 107             util_swap32(d+i, 2);
 108         }
 109     }
 110 #endif
 111
 112 void util_endianswap(void *_data, size_t length, unsigned int typesize) {
 113 #   if PLATFORM_BYTE_ORDER == -1 /* runtime check */
 114     if (*((char*)&typesize))
 115         return;
 116 #else
 117     /* prevent unused warnings */
 118     (void) _data;
 119     (void) length;
 120     (void) typesize;
 121
 122 #   if PLATFORM_BYTE_ORDER == GMQCC_BYTE_ORDER_LITTLE
 123         return;
 124 #   else
 125         switch (typesize) {
 126             case 1: return;
 127             case 2:
 128                 util_swap16((uint16_t*)_data, length>>1);
 129                 return;
 130             case 4:
 131                 util_swap32((uint32_t*)_data, length>>2);
 132                 return;
 133             case 8:
 134                 util_swap64((uint32_t*)_data, length>>3);
 135                 return;
 136
 137             default: exit(EXIT_FAILURE); /* please blow the fuck up! */
 138         }
 139 #   endif
 140 #endif
 141 }
 142
 143 /*
 144  * CRC algorithms vary in the width of the polynomial, the value of said polynomial,
 145  * the initial value used for the register, weather the bits of each byte are reflected
 146  * before being processed, weather the algorithm itself feeds input bytes through the
 147  * register or XORs them with a byte from one end and then straight into the table, as
 148  * well as (but not limited to the idea of reflected versions) where the final register
 149  * value becomes reversed, and finally weather the value itself is used to XOR the final
 150  * register value.  AS such you can already imagine how painfully annoying CRCs are,
 151  * of course we stand to target Quake, which expects it's certain set of rules for proper
 152  * calculation of a CRC.
 153  *
 154  * In most traditional CRC algorithms on uses a reflected table driven method where a value
 155  * or register is reflected if it's bits are swapped around it's center.  For example:
 156  * take the bits 0101 is the 4-bit reflection of 1010, and respectfully 0011 would be the
 157  * reflection of 1100. Quake however expects a NON-Reflected CRC on the output, but still
 158  * requires a final XOR on the values (0xFFFF and 0x0000) this is a standard CCITT CRC-16
 159  * which I respectfully as a programmer don't agree with.
 160  *
 161  * So now you know what we target, and why we target it, despite how unsettling it may seem
 162  * but those are what Quake seems to request.
 163  */
 164
 165 static const uint16_t util_crc16_table[] = {
 166     0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108,
 167     0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210,
 168     0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B,
 169     0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401,
 170     0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE,
 171     0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6,
 172     0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D,
 173     0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
 174     0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5,
 175     0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC,
 176     0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4,
 177     0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD,
 178     0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13,
 179     0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A,
 180     0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E,
 181     0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
 182     0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1,
 183     0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB,
 184     0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0,
 185     0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8,
 186     0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657,
 187     0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9,
 188     0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882,
 189     0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
 190     0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E,
 191     0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07,
 192     0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D,
 193     0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
 194     0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
 195 };
 196
 197 /* Non - Reflected */
 198 uint16_t util_crc16(uint16_t current, const char *k, size_t len) {
 199     register uint16_t h = current;
 200     for (; len; --len, ++k)
 201         h = util_crc16_table[(h>>8)^((unsigned char)*k)]^(h<<8);
 202     return h;
 203 }
 204 /* Reflective Variation (for reference) */
 205 #if 0
 206 uint16_t util_crc16(const char *k, int len, const short clamp) {
 207     register uint16_t h= (uint16_t)0xFFFFFFFF;
 208     for (; len; --len, ++k)
 209         h = util_crc16_table[(h^((unsigned char)*k))&0xFF]^(h>>8);
 210     return (~h)%clamp;
 211 }
 212 #endif
 213
 214 /*
 215  * modifier is the match to make and the transposition from it, while add is the upper-value that determines the
 216  * transposition from uppercase to lower case.
 217  */
 218 static GMQCC_INLINE size_t util_strtransform(const char *in, char *out, size_t outsz, const char *mod, int add) {
 219     size_t sz = 1;
 220     for (; *in && sz < outsz; ++in, ++out, ++sz) {
 221         *out = (*in == mod[0])
 222                     ? mod[1]
 223                     : (util_isalpha(*in) && ((add > 0) ? util_isupper(*in) : !util_isupper(*in)))
 224                         ? *in + add
 225                         : *in;
 226     }
 227     *out = 0;
 228     return sz-1;
 229 }
 230
 231 size_t util_strtocmd(const char *in, char *out, size_t outsz) {
 232     return util_strtransform(in, out, outsz, "-_", 'A'-'a');
 233 }
 234 size_t util_strtononcmd(const char *in, char *out, size_t outsz) {
 235     return util_strtransform(in, out, outsz, "_-", 'a'-'A');
 236 }
 237 size_t util_optimizationtostr(const char *in, char *out, size_t outsz) {
 238     return util_strtransform(in, out, outsz, "_ ", 'a'-'A');
 239 }
 240
 241 /*
 242  * Portable implementation of vasprintf/asprintf. Assumes vsnprintf
 243  * exists, otherwise compiler error.
 244  *
 245  * TODO: fix for MSVC ....
 246  */
 247 int util_vasprintf(char **dat, const char *fmt, va_list args) {
 248     int   ret;
 249     int   len;
 250     char *tmp = NULL;
 251
 252     /*
 253      * For visual studio _vsnprintf doesn't tell you the length of a
 254      * formatted string if it overflows. However there is a MSVC
 255      * intrinsic (which is documented wrong) called _vcsprintf which
 256      * will return the required amount to allocate.
 257      */
 258     #ifdef _MSC_VER
 259         if ((len = _vscprintf(fmt, args)) < 0) {
 260             *dat = NULL;
 261             return -1;
 262         }
 263
 264         tmp = (char*)mem_a(len + 1);
 265         if ((ret = _vsnprintf_s(tmp, len+1, len+1, fmt, args)) != len) {
 266             mem_d(tmp);
 267             *dat = NULL;
 268             return -1;
 269         }
 270         *dat = tmp;
 271         return len;
 272     #else
 273         /*
 274          * For everything else we have a decent conforming vsnprintf that
 275          * returns the number of bytes needed.  We give it a try though on
 276          * a short buffer, since efficiently speaking, it could be nice to
 277          * above a second vsnprintf call.
 278          */
 279         char    buf[128];
 280         va_list cpy;
 281         va_copy(cpy, args);
 282         len = vsnprintf(buf, sizeof(buf), fmt, cpy);
 283         va_end (cpy);
 284
 285         if (len < (int)sizeof(buf)) {
 286             *dat = util_strdup(buf);
 287             return len;
 288         }
 289
 290         /* not large enough ... */
 291         tmp = (char*)mem_a(len + 1);
 292         if ((ret = vsnprintf(tmp, len + 1, fmt, args)) != len) {
 293             mem_d(tmp);
 294             *dat = NULL;
 295             return -1;
 296         }
 297
 298         *dat = tmp;
 299         return len;
 300     #endif
 301 }
 302 int util_asprintf(char **ret, const char *fmt, ...) {
 303     va_list  args;
 304     int      read;
 305     va_start(args, fmt);
 306     read = util_vasprintf(ret, fmt, args);
 307     va_end  (args);
 308
 309     return read;
 310 }
 311
 312 /*
 313  * These are various re-implementations (wrapping the real ones) of
 314  * string functions that MSVC considers unsafe. We wrap these up and
 315  * use the safe variations on MSVC.
 316  */
 317 #ifdef _MSC_VER
 318     static char **util_strerror_allocated() {
 319         static char **data = NULL;
 320         return data;
 321     }
 322
 323     static void util_strerror_cleanup(void) {
 324         size_t i;
 325         char  **data = util_strerror_allocated();
 326         for (i = 0; i < vec_size(data); i++)
 327             mem_d(data[i]);
 328         vec_free(data);
 329     }
 330
 331     const char *util_strerror(int num) {
 332         char         *allocated = NULL;
 333         static bool   install   = false;
 334         static size_t tries     = 0;
 335         char        **vector    = util_strerror_allocated();
 336
 337         /* try installing cleanup handler */
 338         while (!install) {
 339             if (tries == 32)
 340                 return "(unknown)";
 341
 342             install = !atexit(&util_strerror_cleanup);
 343             tries ++;
 344         }
 345
 346         allocated = (char*)mem_a(4096); /* A page must be enough */
 347         strerror_s(allocated, 4096, num);
 348
 349         vec_push(vector, allocated);
 350         return (const char *)allocated;
 351     }
 352
 353     int util_snprintf(char *src, size_t bytes, const char *format, ...) {
 354         int      rt;
 355         va_list  va;
 356         va_start(va, format);
 357
 358         rt = vsprintf_s(src, bytes, format, va);
 359         va_end  (va);
 360
 361         return rt;
 362     }
 363
 364     char *util_strcat(char *dest, const char *src) {
 365         strcat_s(dest, strlen(src), src);
 366         return dest;
 367     }
 368
 369     char *util_strncpy(char *dest, const char *src, size_t num) {
 370         strncpy_s(dest, num, src, num);
 371         return dest;
 372     }
 373 #else
 374     const char *util_strerror(int num) {
 375         return strerror(num);
 376     }
 377
 378     int util_snprintf(char *src, size_t bytes, const char *format, ...) {
 379         int      rt;
 380         va_list  va;
 381         va_start(va, format);
 382         rt = vsnprintf(src, bytes, format, va);
 383         va_end  (va);
 384
 385         return rt;
 386     }
 387
 388     char *util_strcat(char *dest, const char *src) {
 389         return strcat(dest, src);
 390     }
 391
 392     char *util_strncpy(char *dest, const char *src, size_t num) {
 393         return strncpy(dest, src, num);
 394     }
 395
 396 #endif /*! _MSC_VER */
 397
 398
 399 void util_seed(uint32_t value) {
 400     srand((int)value);
 401 }
 402 uint32_t util_rand() {
 403     return rand();
 404 }