Fix windows builds, add strip target for makefiles, update distro build makefiles...
[xonotic/gmqcc.git] / 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 const char *util_tmpnam(char *str) {
286     return platform_tmpnam(str);
287 }
288
289 /*
290  * A small noncryptographic PRNG based on:
291  * http://burtleburtle.net/bob/rand/smallprng.html
292  */
293 static uint32_t util_rand_state[4] = {
294     0xF1EA5EED, 0x00000000,
295     0x00000000, 0x00000000
296 };
297
298 #define util_rand_rot(X, Y) (((X)<<(Y))|((X)>>(32-(Y))))
299
300 uint32_t util_rand() {
301     uint32_t last;
302
303     last               = util_rand_state[0] - util_rand_rot(util_rand_state[1], 27);
304     util_rand_state[0] = util_rand_state[1] ^ util_rand_rot(util_rand_state[2], 17);
305     util_rand_state[1] = util_rand_state[2] + util_rand_state[3];
306     util_rand_state[2] = util_rand_state[3] + last;
307     util_rand_state[3] = util_rand_state[0] + last;
308
309     return util_rand_state[3];
310 }
311
312 #undef util_rand_rot
313
314 void util_seed(uint32_t value) {
315     size_t i;
316
317     util_rand_state[0] = 0xF1EA5EED;
318     util_rand_state[1] = value;
319     util_rand_state[2] = value;
320     util_rand_state[3] = value;
321
322     for (i = 0; i < 20; ++i)
323         (void)util_rand();
324 }
325