Merge branch 'master' of github.com:graphitemaster/gmqcc
[xonotic/gmqcc.git] / gmqcc.h
1 /*
2  * Copyright (C) 2012
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 #ifndef GMQCC_HDR
25 #define GMQCC_HDR
26 #include <limits.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <stdio.h>
30 #include <stdarg.h>
31 #include <ctype.h>
32
33 /*
34  * Disable some over protective warnings in visual studio because fixing them is a waste
35  * of my time.
36  */
37 #ifdef _MSC_VER
38 #       pragma warning(disable : 4244 ) /* conversion from 'int' to 'float', possible loss of data */
39 #       pragma warning(disable : 4018 ) /* signed/unsigned mismatch                                */
40 #       pragma warning(disable : 4996 ) /* This function or variable may be unsafe                 */
41 #       pragma warning(disable : 4700 ) /* uninitialized local variable used                       */
42 #endif
43
44 #define GMQCC_VERSION_MAJOR 0
45 #define GMQCC_VERSION_MINOR 2
46 #define GMQCC_VERSION_PATCH 0
47 #define GMQCC_VERSION_BUILD(J,N,P) (((J)<<16)|((N)<<8)|(P))
48 #define GMQCC_VERSION \
49     GMQCC_VERSION_BUILD(GMQCC_VERSION_MAJOR, GMQCC_VERSION_MINOR, GMQCC_VERSION_PATCH)
50
51 /*
52  * We cannoy rely on C99 at all, since compilers like MSVC
53  * simply don't support it.  We define our own boolean type
54  * as a result (since we cannot include <stdbool.h>). For
55  * compilers that are in 1999 mode (C99 compliant) we can use
56  * the language keyword _Bool which can allow for better code
57  * on GCC and GCC-like compilers, opposed to `int`.
58  */
59 #ifndef __cplusplus
60 #   ifdef  false
61 #       undef  false
62 #   endif /* !false */
63 #   ifdef  true
64 #       undef true
65 #   endif /* !true  */
66 #   define false (0)
67 #   define true  (1)
68 #   ifdef __STDC_VERSION__
69 #       if __STDC_VERSION__ < 199901L && __GNUC__ < 3
70             typedef int  bool;
71 #       else
72             typedef _Bool bool;
73 #       endif
74 #   else
75         typedef int bool;
76 #   endif /* !__STDC_VERSION__ */
77 #endif    /* !__cplusplus      */
78
79 /*
80  * Of some functions which are generated we want to make sure
81  * that the result isn't ignored. To find such function calls,
82  * we use this macro.
83  */
84 #if defined(__GNUC__) || defined(__CLANG__)
85 #   define GMQCC_WARN __attribute__((warn_unused_result))
86 #else
87 #   define GMQCC_WARN
88 #endif
89 /*
90  * This is a hack to silent clang regarding empty
91  * body if statements.
92  */
93 #define GMQCC_SUPPRESS_EMPTY_BODY do { } while (0)
94
95 /*
96  * Inline is not supported in < C90, however some compilers
97  * like gcc and clang might have an inline attribute we can
98  * use if present.
99  */
100 #ifdef __STDC_VERSION__
101 #    if __STDC_VERSION__ < 199901L
102 #       if defined(__GNUC__) || defined (__CLANG__)
103 #           if __GNUC__ < 2
104 #               define GMQCC_INLINE
105 #           else
106 #               define GMQCC_INLINE __attribute__ ((always_inline))
107 #           endif
108 #       else
109 #           define GMQCC_INLINE
110 #       endif
111 #    else
112 #       define GMQCC_INLINE inline
113 #    endif
114 /*
115  * Visual studio has __forcinline we can use.  So lets use that
116  * I suspect it also has just __inline of some sort, but our use
117  * of inline is correct (not guessed), WE WANT IT TO BE INLINE
118  */
119 #elif defined(_MSC_VER)
120 #    define GMQCC_INLINE __forceinline
121 #else
122 #    define GMQCC_INLINE
123 #endif /* !__STDC_VERSION__ */
124
125 /*
126  * noreturn is present in GCC and clang
127  * it's required for _ast_node_destory otherwise -Wmissing-noreturn
128  * in clang complains about there being no return since abort() is
129  * called.
130  */
131 #if (defined(__GNUC__) && __GNUC__ >= 2) || defined(__CLANG__)
132 #    define GMQCC_NORETURN __attribute__ ((noreturn))
133 #else
134 #    define GMQCC_NORETURN
135 #endif
136
137 /* TODO: visual studiblows work around */
138 #ifndef _MSC_VER
139 #   include <stdint.h>
140 #endif
141
142 /*
143  * Very roboust way at determining endianess at compile time: this handles
144  * almost every possible situation.  Otherwise a runtime check has to be
145  * performed.
146  */
147 #define GMQCC_BYTE_ORDER_LITTLE 1234
148 #define GMQCC_BYTE_ORDER_BIG    4321
149
150 #if defined (__GNUC__) || defined (__GNU_LIBRARY__)
151 #   if defined (__FreeBSD__) || defined (__OpenBSD__)
152 #       include <sys/endian.h>
153 #   elif defined (BSD) && (BSD >= 199103) || defined (__DJGPP__) || defined (__CYGWIN32__)
154 #       include <machine/endiane.h>
155 #   elif defined (__APPLE__)
156 #       if defined (__BIG_ENDIAN__) && !defined(BIG_ENDIAN)
157 #           define BIG_ENDIAN
158 #       elif defined (__LITTLE_ENDIAN__) && !defined (LITTLE_ENDIAN)
159 #           define LITTLE_ENDIAN
160 #       endif
161 #   elif !defined (__MINGW32__)
162 #       include <endian.h>
163 #       if !defined (__BEOS__)
164 #           include <byteswap.h>
165 #       endif
166 #   endif
167 #endif
168 #if !defined(PLATFORM_BYTE_ORDER)
169 #   if defined (LITTLE_ENDIAN) || defined (BIG_ENDIAN)
170 #       if defined (LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
171 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_LITTLE
172 #       elif !defined (LITTLE_ENDIAN) && defined (BIG_ENDIAN)
173 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_BIG
174 #       elif defined (BYTE_ORDER) && (BYTE_ORDER == LITTLE_ENDIAN)
175 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_LITTLE
176 #       elif defined (BYTE_ORDER) && (BYTE_ORDER == BIG_ENDIAN)
177 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_BIG
178 #       endif
179 #   elif defined (_LITTLE_ENDIAN) || defined (_BIG_ENDIAN)
180 #       if defined (_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)
181 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_LITTLE
182 #       elif !defined (_LITTLE_ENDIAN) && defined (_BIG_ENDIAN)
183 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_BIG
184 #       elif defined (_BYTE_ORDER) && (_BYTE_ORDER == _LITTLE_ENDIAN)
185 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_LITTLE
186 #       elif defined (_BYTE_ORDER) && (_BYTE_ORDER == _BIG_ENDIAN)
187 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_BIG
188 #       endif
189 #   elif defined (__LITTLE_ENDIAN__) || defined (__BIG_ENDIAN__)
190 #       if defined (__LITTLE_ENDIAN__) && !defined (__BIG_ENDIAN__)
191 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_LITTLE
192 #       elif !defined (__LITTLE_ENDIAN__) && defined (__BIG_ENDIAN__)
193 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_BIG
194 #       elif defined (__BYTE_ORDER__) && (__BYTE_ORDER__ == __LITTLE_ENDIAN__)
195 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_LITTLE
196 #       elif defined (__BYTE_ORDER__) && (__BYTE_ORDER__ == __BIG_ENDIAN__)
197 #           define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_BIG
198 #       endif
199 #   endif
200 #endif
201 #if !defined (PLATFORM_BYTE_ORDER)
202 #   if   defined (__aplha__) || defined (__aplha)    || defined (i386)       || \
203          defined (__i386__)  || defined (_M_I86)     || defined (_M_IX86)    || \
204          defined (__OS2__)   || defined (sun386)     || defined (__TURBOC__) || \
205          defined (vax)       || defined (vms)        || defined (VMS)        || \
206          defined (__VMS)     || defined (__x86_64__) || defined (_M_IA64)    || \
207          defined (_M_X64)    || defined (__i386)     || defined (__x86_64)
208 #       define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_LITTLE
209 #   elif defined (AMIGA)     || defined (applec)     || defined (__AS400__)  || \
210          defined (_CRAY)     || defined (__hppa)     || defined (__hp9000)   || \
211          defined (ibm370)    || defined (mc68000)    || defined (m68k)       || \
212          defined (__MRC__)   || defined (__MVS__)    || defined (__MWERKS__) || \
213          defined (sparc)     || defined (__sparc)    || defined (SYMANTEC_C) || \
214          defined (__TANDEM)  || defined (THINK_C)    || defined (__VMCMS__)  || \
215          defined (__PPC__)   || defined (__PPC)      || defined (PPC)
216 #       define PLATFORM_BYTE_ORDER GMQCC_BYTE_ORDER_BIG
217 #   else
218 #       define PLATFORM_BYTE_ORDER -1
219 #   endif
220 #endif
221
222
223
224 /*===================================================================*/
225 /*=========================== util.c ================================*/
226 /*===================================================================*/
227 FILE *util_fopen(const char *filename, const char *mode);
228
229 void *util_memory_a      (size_t,       unsigned int, const char *);
230 void  util_memory_d      (void       *, unsigned int, const char *);
231 void *util_memory_r      (void       *, size_t,       unsigned int, const char *);
232 void  util_meminfo       ();
233
234 bool  util_filexists     (const char *);
235 bool  util_strupper      (const char *);
236 bool  util_strdigit      (const char *);
237 bool  util_strncmpexact  (const char *, const char *, size_t);
238 char *util_strdup        (const char *);
239 char *util_strrq         (const char *);
240 char *util_strrnl        (const char *);
241 char *util_strsws        (const char *);
242 char *util_strchp        (const char *, const char *);
243 void  util_debug         (const char *, const char *, ...);
244 int   util_getline       (char **, size_t *, FILE *);
245 void  util_endianswap    (void *,  size_t, unsigned int);
246
247 size_t util_strtocmd    (const char *, char *, size_t);
248 size_t util_strtononcmd (const char *, char *, size_t);
249
250 uint16_t util_crc16(uint16_t crc, const char *data, size_t len);
251 uint32_t util_crc32(uint32_t crc, const char *data, size_t len);
252
253 #ifdef NOTRACK
254 #    define mem_a(x)    malloc (x)
255 #    define mem_d(x)    free   (x)
256 #    define mem_r(x, n) realloc(x, n)
257 #else
258 #    define mem_a(x)    util_memory_a((x), __LINE__, __FILE__)
259 #    define mem_d(x)    util_memory_d((x), __LINE__, __FILE__)
260 #    define mem_r(x, n) util_memory_r((x), (n), __LINE__, __FILE__)
261 #endif
262
263 /*
264  * TODO: make these safer to use.  Currently this only works on
265  * x86 and x86_64, some systems will likely not like this. Such
266  * as BE systems.
267  */
268 #define FLT2INT(Y) *((int32_t*)&(Y))
269 #define INT2FLT(Y) *((float  *)&(Y))
270
271 /* New flexible vector implementation from Dale */
272 #define _vec_raw(A) (((size_t*)(void*)(A)) - 2)
273 #define _vec_beg(A) (_vec_raw(A)[0])
274 #define _vec_end(A) (_vec_raw(A)[1])
275 #define _vec_needsgrow(A,N) ((!(A)) || (_vec_end(A) + (N) >= _vec_beg(A)))
276 #define _vec_mightgrow(A,N) (_vec_needsgrow((A), (N)) ? (void)_vec_forcegrow((A),(N)) : (void)0)
277 #define _vec_forcegrow(A,N) _util_vec_grow(((void**)&(A)), (N), sizeof(*(A)))
278 #define _vec_remove(A,S,I,N) (memmove((char*)(A)+(I)*(S),(char*)(A)+((I)+(N))*(S),(S)*(_vec_end(A)-(I)-(N))), _vec_end(A)-=(N))
279 void _util_vec_grow(void **a, size_t i, size_t s);
280 /* exposed interface */
281 #define vec_free(A)          ((A) ? (mem_d((void*)_vec_raw(A)), (A) = NULL) : 0)
282 #define vec_push(A,V)        (_vec_mightgrow((A),1), (A)[_vec_end(A)++] = (V))
283 #define vec_size(A)          ((A) ? _vec_end(A) : 0)
284 #define vec_add(A,N)         (_vec_mightgrow((A),(N)), _vec_end(A)+=(N), &(A)[_vec_end(A)-(N)])
285 #define vec_last(A)          ((A)[_vec_end(A)-1])
286 #define vec_append(A,N,S)    memcpy(vec_add((A), (N)), (S), N * sizeof(*(S)))
287 #define vec_remove(A,I,N)    _vec_remove((A), sizeof(*(A)), (I), (N))
288 #define vec_pop(A)           (_vec_end(A)-=1)
289 /* these are supposed to NOT reallocate */
290 #define vec_shrinkto(A,N)    (_vec_end(A) = (N))
291 #define vec_shrinkby(A,N)    (_vec_end(A) -= (N))
292
293 #define vec_upload(X,Y,S)      \
294     do {                       \
295         size_t E = 0;          \
296         while (E < S) {        \
297             vec_push(X, Y[E]); \
298             E ++;              \
299         }                      \
300     } while(0)
301
302 typedef struct hash_table_t {
303     size_t                size;
304     struct hash_node_t **table;
305 } hash_table_t, *ht;
306
307 /*
308  * hashtable implementation:
309  *
310  * Note:
311  *      This was designed for pointers:  you manage the life of the object yourself
312  *      if you do use this for non-pointers please be warned that the object may not
313  *      be valid if the duration of it exceeds (i.e on stack).  So you need to allocate
314  *      yourself, or put those in global scope to ensure duration is for the whole
315  *      runtime.
316  *
317  * util_htnew(size)                             -- to make a new hashtable
318  * util_htset(table, key, value, sizeof(value)) -- to set something in the table
319  * util_htget(table, key)                       -- to get something from the table
320  * util_htdel(table)                            -- to delete the table
321  *
322  * example of use:
323  *
324  * ht    foo  = util_htnew(1024);
325  * int   data = 100;
326  * char *test = "hello world\n";
327  * util_htset(foo, "foo", (void*)&data);
328  * util_gtset(foo, "bar", (void*)test);
329  *
330  * printf("foo: %d, bar %s",
331  *     *((int *)util_htget(foo, "foo")),
332  *      ((char*)util_htget(foo, "bar"))
333  * );
334  *
335  * util_htdel(foo);
336  */
337 hash_table_t *util_htnew (size_t size);
338 void          util_htset (hash_table_t *ht, const char *key, void *value);
339 void         *util_htget (hash_table_t *ht, const char *key);
340 void          util_htdel (hash_table_t *ht);
341 size_t        util_hthash(hash_table_t *ht, const char *key);
342 void         *util_htgeth(hash_table_t *ht, const char *key, size_t hash);
343 void          util_htseth(hash_table_t *ht, const char *key, size_t hash, void *value);
344 /*===================================================================*/
345 /*=========================== code.c ================================*/
346 /*===================================================================*/
347
348 /* Note: if you change the order, fix type_sizeof in ir.c */
349 enum {
350     TYPE_VOID     ,
351     TYPE_STRING   ,
352     TYPE_FLOAT    ,
353     TYPE_VECTOR   ,
354     TYPE_ENTITY   ,
355     TYPE_FIELD    ,
356     TYPE_FUNCTION ,
357     TYPE_POINTER  ,
358     TYPE_INTEGER  ,
359     TYPE_VARIANT  ,
360     TYPE_STRUCT   ,
361     TYPE_UNION    ,
362     TYPE_ARRAY    ,
363
364     TYPE_COUNT
365 };
366
367 /* const/var qualifiers */
368 #define CV_NONE  0
369 #define CV_CONST 1
370 #define CV_VAR  -1
371 /* magic number to help parsing */
372 #define CV_WRONG  0x8000
373
374 extern const char *type_name        [TYPE_COUNT];
375 extern uint16_t    type_store_instr [TYPE_COUNT];
376 extern uint16_t    field_store_instr[TYPE_COUNT];
377
378 /*
379  * could use type_store_instr + INSTR_STOREP_F - INSTR_STORE_F
380  * but this breaks when TYPE_INTEGER is added, since with the enhanced
381  * instruction set, the old ones are left untouched, thus the _I instructions
382  * are at a seperate place.
383  */
384 extern uint16_t type_storep_instr[TYPE_COUNT];
385 extern uint16_t type_eq_instr    [TYPE_COUNT];
386 extern uint16_t type_ne_instr    [TYPE_COUNT];
387 extern uint16_t type_not_instr   [TYPE_COUNT];
388
389 typedef struct {
390     uint32_t offset;      /* Offset in file of where data begins  */
391     uint32_t length;      /* Length of section (how many of)      */
392 } prog_section;
393
394 typedef struct {
395     uint32_t     version;      /* Program version (6)     */
396     uint16_t     crc16;
397     uint16_t     skip;
398
399     prog_section statements;   /* prog_section_statement  */
400     prog_section defs;         /* prog_section_def        */
401     prog_section fields;       /* prog_section_field      */
402     prog_section functions;    /* prog_section_function   */
403     prog_section strings;
404     prog_section globals;
405     uint32_t     entfield;     /* Number of entity fields */
406 } prog_header;
407
408 /*
409  * Each paramater incerements by 3 since vector types hold
410  * 3 components (x,y,z).
411  */
412 #define OFS_NULL      0
413 #define OFS_RETURN    1
414 #define OFS_PARM0     (OFS_RETURN+3)
415 #define OFS_PARM1     (OFS_PARM0 +3)
416 #define OFS_PARM2     (OFS_PARM1 +3)
417 #define OFS_PARM3     (OFS_PARM2 +3)
418 #define OFS_PARM4     (OFS_PARM3 +3)
419 #define OFS_PARM5     (OFS_PARM4 +3)
420 #define OFS_PARM6     (OFS_PARM5 +3)
421 #define OFS_PARM7     (OFS_PARM6 +3)
422
423 typedef struct {
424     uint16_t opcode;
425
426     /* operand 1 */
427     union {
428         int16_t  s1; /* signed   */
429         uint16_t u1; /* unsigned */
430     } o1;
431     /* operand 2 */
432     union {
433         int16_t  s1; /* signed   */
434         uint16_t u1; /* unsigned */
435     } o2;
436     /* operand 3 */
437     union {
438         int16_t  s1; /* signed   */
439         uint16_t u1; /* unsigned */
440     } o3;
441
442     /*
443      * This is the same as the structure in darkplaces
444      * {
445      *     unsigned short op;
446      *     short          a,b,c;
447      * }
448      * But this one is more sane to work with, and the
449      * type sizes are guranteed.
450      */
451 } prog_section_statement;
452
453 typedef struct {
454     /*
455      * The types:
456      * 0 = ev_void
457      * 1 = ev_string
458      * 2 = ev_float
459      * 3 = ev_vector
460      * 4 = ev_entity
461      * 5 = ev_field
462      * 6 = ev_function
463      * 7 = ev_pointer -- engine only
464      * 8 = ev_bad     -- engine only
465      */
466     uint16_t type;
467     uint16_t offset;
468     uint32_t name;
469 } prog_section_both;
470
471 typedef prog_section_both prog_section_def;
472 typedef prog_section_both prog_section_field;
473
474 /* this is ORed to the type */
475 #define DEF_SAVEGLOBAL (1<<15)
476 #define DEF_TYPEMASK   ((1<<15)-1)
477
478 typedef struct {
479     int32_t   entry;      /* in statement table for instructions  */
480     uint32_t  firstlocal; /* First local in local table           */
481     uint32_t  locals;     /* Total ints of params + locals        */
482     uint32_t  profile;    /* Always zero (engine uses this)       */
483     uint32_t  name;       /* name of function in string table     */
484     uint32_t  file;       /* file of the source file              */
485     int32_t   nargs;      /* number of arguments                  */
486     uint8_t   argsize[8]; /* size of arguments (keep 8 always?)   */
487 } prog_section_function;
488
489 /*
490  * Instructions
491  * These are the external instructions supported by the interperter
492  * this is what things compile to (from the C code).
493  */
494 enum {
495     INSTR_DONE,
496     INSTR_MUL_F,
497     INSTR_MUL_V,
498     INSTR_MUL_FV, /* NOTE: the float operands must NOT be at the same locations: A != C */
499     INSTR_MUL_VF, /* and here: B != C */
500     INSTR_DIV_F,
501     INSTR_ADD_F,
502     INSTR_ADD_V,
503     INSTR_SUB_F,
504     INSTR_SUB_V,
505     INSTR_EQ_F,
506     INSTR_EQ_V,
507     INSTR_EQ_S,
508     INSTR_EQ_E,
509     INSTR_EQ_FNC,
510     INSTR_NE_F,
511     INSTR_NE_V,
512     INSTR_NE_S,
513     INSTR_NE_E,
514     INSTR_NE_FNC,
515     INSTR_LE,
516     INSTR_GE,
517     INSTR_LT,
518     INSTR_GT,
519     INSTR_LOAD_F,
520     INSTR_LOAD_V,
521     INSTR_LOAD_S,
522     INSTR_LOAD_ENT,
523     INSTR_LOAD_FLD,
524     INSTR_LOAD_FNC,
525     INSTR_ADDRESS,
526     INSTR_STORE_F,
527     INSTR_STORE_V,
528     INSTR_STORE_S,
529     INSTR_STORE_ENT,
530     INSTR_STORE_FLD,
531     INSTR_STORE_FNC,
532     INSTR_STOREP_F,
533     INSTR_STOREP_V,
534     INSTR_STOREP_S,
535     INSTR_STOREP_ENT,
536     INSTR_STOREP_FLD,
537     INSTR_STOREP_FNC,
538     INSTR_RETURN,
539     INSTR_NOT_F,
540     INSTR_NOT_V,
541     INSTR_NOT_S,
542     INSTR_NOT_ENT,
543     INSTR_NOT_FNC,
544     INSTR_IF,
545     INSTR_IFNOT,
546     INSTR_CALL0,
547     INSTR_CALL1,
548     INSTR_CALL2,
549     INSTR_CALL3,
550     INSTR_CALL4,
551     INSTR_CALL5,
552     INSTR_CALL6,
553     INSTR_CALL7,
554     INSTR_CALL8,
555     INSTR_STATE,
556     INSTR_GOTO,
557     INSTR_AND,
558     INSTR_OR,
559     INSTR_BITAND,
560     INSTR_BITOR,
561
562     /*
563      * Virtual instructions used by the assembler
564      * keep at the end but before virtual instructions
565      * for the IR below.
566      */
567     AINSTR_END,
568
569     /*
570      * Virtual instructions used by the IR
571      * Keep at the end!
572      */
573     VINSTR_PHI,
574     VINSTR_JUMP,
575     VINSTR_COND,
576     /* A never returning CALL.
577      * Creating this causes IR blocks to be marked as 'final'.
578      * No-Return-Call
579      */
580     VINSTR_NRCALL
581 };
582
583 extern prog_section_statement *code_statements;
584 extern int                    *code_linenums;
585 extern prog_section_def       *code_defs;
586 extern prog_section_field     *code_fields;
587 extern prog_section_function  *code_functions;
588 extern int                    *code_globals;
589 extern char                   *code_chars;
590 extern uint16_t code_crc;
591
592 typedef float   qcfloat;
593 typedef int32_t qcint;
594
595 /*
596  * code_write -- writes out the compiled file
597  * code_init  -- prepares the code file
598  */
599 bool     code_write       (const char *filename, const char *lno);
600 void     code_init        ();
601 uint32_t code_genstring   (const char *string);
602 uint32_t code_cachedstring(const char *string);
603 qcint    code_alloc_field (size_t qcsize);
604
605 /* this function is used to keep statements and linenumbers together */
606 void     code_push_statement(prog_section_statement *stmt, int linenum);
607 void     code_pop_statement();
608
609 /*
610  * A shallow copy of a lex_file to remember where which ast node
611  * came from.
612  */
613 typedef struct {
614     const char *file;
615     size_t      line;
616 } lex_ctx;
617
618 /*===================================================================*/
619 /*============================ con.c ================================*/
620 /*===================================================================*/
621 enum {
622     CON_BLACK   = 30,
623     CON_RED,
624     CON_GREEN,
625     CON_BROWN,
626     CON_BLUE,
627     CON_MAGENTA,
628     CON_CYAN ,
629     CON_WHITE
630 };
631
632 /* message level */
633 enum {
634     LVL_MSG,
635     LVL_WARNING,
636     LVL_ERROR
637 };
638
639 void con_vprintmsg (int level, const char *name, size_t line, const char *msgtype, const char *msg, va_list ap);
640 void con_printmsg  (int level, const char *name, size_t line, const char *msgtype, const char *msg, ...);
641 void con_cvprintmsg(void *ctx, int lvl, const char *msgtype, const char *msg, va_list ap);
642 void con_cprintmsg (void *ctx, int lvl, const char *msgtype, const char *msg, ...);
643
644 void con_close ();
645 void con_init  ();
646 void con_reset ();
647 void con_color (int);
648 int  con_change(const char *, const char *);
649 int  con_verr  (const char *, va_list);
650 int  con_vout  (const char *, va_list);
651 int  con_err   (const char *, ...);
652 int  con_out   (const char *, ...);
653
654 /* error/warning interface */
655 extern size_t compile_errors;
656 extern size_t compile_warnings;
657
658 void /********/ compile_error   (lex_ctx ctx, /*LVL_ERROR*/ const char *msg, ...);
659 void /********/ vcompile_error  (lex_ctx ctx, /*LVL_ERROR*/ const char *msg, va_list ap);
660 bool GMQCC_WARN compile_warning (lex_ctx ctx, int warntype, const char *fmt, ...);
661 bool GMQCC_WARN vcompile_warning(lex_ctx ctx, int warntype, const char *fmt, va_list ap);
662
663 /*===================================================================*/
664 /*========================= assembler.c =============================*/
665 /*===================================================================*/
666 static const struct {
667     const char  *m; /* menomic     */
668     const size_t o; /* operands    */
669     const size_t l; /* menomic len */
670 } asm_instr[] = {
671     { "DONE"      , 1, 4 },
672     { "MUL_F"     , 3, 5 },
673     { "MUL_V"     , 3, 5 },
674     { "MUL_FV"    , 3, 6 },
675     { "MUL_VF"    , 3, 6 },
676     { "DIV"       , 0, 3 },
677     { "ADD_F"     , 3, 5 },
678     { "ADD_V"     , 3, 5 },
679     { "SUB_F"     , 3, 5 },
680     { "SUB_V"     , 3, 5 },
681     { "EQ_F"      , 0, 4 },
682     { "EQ_V"      , 0, 4 },
683     { "EQ_S"      , 0, 4 },
684     { "EQ_E"      , 0, 4 },
685     { "EQ_FNC"    , 0, 6 },
686     { "NE_F"      , 0, 4 },
687     { "NE_V"      , 0, 4 },
688     { "NE_S"      , 0, 4 },
689     { "NE_E"      , 0, 4 },
690     { "NE_FNC"    , 0, 6 },
691     { "LE"        , 0, 2 },
692     { "GE"        , 0, 2 },
693     { "LT"        , 0, 2 },
694     { "GT"        , 0, 2 },
695     { "FIELD_F"   , 0, 7 },
696     { "FIELD_V"   , 0, 7 },
697     { "FIELD_S"   , 0, 7 },
698     { "FIELD_ENT" , 0, 9 },
699     { "FIELD_FLD" , 0, 9 },
700     { "FIELD_FNC" , 0, 9 },
701     { "ADDRESS"   , 0, 7 },
702     { "STORE_F"   , 0, 7 },
703     { "STORE_V"   , 0, 7 },
704     { "STORE_S"   , 0, 7 },
705     { "STORE_ENT" , 0, 9 },
706     { "STORE_FLD" , 0, 9 },
707     { "STORE_FNC" , 0, 9 },
708     { "STOREP_F"  , 0, 8 },
709     { "STOREP_V"  , 0, 8 },
710     { "STOREP_S"  , 0, 8 },
711     { "STOREP_ENT", 0, 10},
712     { "STOREP_FLD", 0, 10},
713     { "STOREP_FNC", 0, 10},
714     { "RETURN"    , 0, 6 },
715     { "NOT_F"     , 0, 5 },
716     { "NOT_V"     , 0, 5 },
717     { "NOT_S"     , 0, 5 },
718     { "NOT_ENT"   , 0, 7 },
719     { "NOT_FNC"   , 0, 7 },
720     { "IF"        , 0, 2 },
721     { "IFNOT"     , 0, 5 },
722     { "CALL0"     , 1, 5 },
723     { "CALL1"     , 2, 5 },
724     { "CALL2"     , 3, 5 },
725     { "CALL3"     , 4, 5 },
726     { "CALL4"     , 5, 5 },
727     { "CALL5"     , 6, 5 },
728     { "CALL6"     , 7, 5 },
729     { "CALL7"     , 8, 5 },
730     { "CALL8"     , 9, 5 },
731     { "STATE"     , 0, 5 },
732     { "GOTO"      , 0, 4 },
733     { "AND"       , 0, 3 },
734     { "OR"        , 0, 2 },
735     { "BITAND"    , 0, 6 },
736     { "BITOR"     , 0, 5 },
737
738     { "END"       , 0, 3 } /* virtual assembler instruction */
739 };
740 /*===================================================================*/
741 /*============================= ir.c ================================*/
742 /*===================================================================*/
743
744 enum store_types {
745     store_global,
746     store_local,  /* local, assignable for now, should get promoted later */
747     store_param,  /* parameters, they are locals with a fixed position */
748     store_value,  /* unassignable */
749     store_return  /* unassignable, at OFS_RETURN */
750 };
751
752 typedef struct {
753     qcfloat x, y, z;
754 } vector;
755
756 vector  vec3_add  (vector, vector);
757 vector  vec3_sub  (vector, vector);
758 qcfloat vec3_mulvv(vector, vector);
759 vector  vec3_mulvf(vector, float);
760
761 /*===================================================================*/
762 /*============================= exec.c ==============================*/
763 /*===================================================================*/
764
765 /*
766  * Darkplaces has (or will have) a 64 bit prog loader
767  * where the 32 bit qc program is autoconverted on load.
768  * Since we may want to support that as well, let's redefine
769  * float and int here.
770  */
771 typedef union {
772     qcint   _int;
773     qcint    string;
774     qcint    function;
775     qcint    edict;
776     qcfloat _float;
777     qcfloat vector[3];
778     qcint   ivector[3];
779 } qcany;
780
781 typedef char qcfloat_size_is_correct [sizeof(qcfloat) == 4 ?1:-1];
782 typedef char qcint_size_is_correct   [sizeof(qcint)   == 4 ?1:-1];
783
784 enum {
785     VMERR_OK,
786     VMERR_TEMPSTRING_ALLOC,
787
788     VMERR_END
789 };
790
791 #define VM_JUMPS_DEFAULT 1000000
792
793 /* execute-flags */
794 #define VMXF_DEFAULT 0x0000     /* default flags - nothing */
795 #define VMXF_TRACE   0x0001     /* trace: print statements before executing */
796 #define VMXF_PROFILE 0x0002     /* profile: increment the profile counters */
797
798 struct qc_program_s;
799
800 typedef int (*prog_builtin)(struct qc_program_s *prog);
801
802 typedef struct {
803     qcint                  stmt;
804     size_t                 localsp;
805     prog_section_function *function;
806 } qc_exec_stack;
807
808 typedef struct qc_program_s {
809     char           *filename;
810
811     prog_section_statement *code;
812     prog_section_def       *defs;
813     prog_section_def       *fields;
814     prog_section_function  *functions;
815     char                   *strings;
816     qcint                  *globals;
817     qcint                  *entitydata;
818     bool                   *entitypool;
819
820     const char*            *function_stack;
821
822     uint16_t crc16;
823
824     size_t tempstring_start;
825     size_t tempstring_at;
826
827     qcint  vmerror;
828
829     size_t *profile;
830
831     prog_builtin *builtins;
832     size_t        builtins_count;
833
834     /* size_t ip; */
835     qcint  entities;
836     size_t entityfields;
837     bool   allowworldwrites;
838
839     qcint         *localstack;
840     qc_exec_stack *stack;
841     size_t statement;
842
843     size_t xflags;
844
845     int    argc; /* current arg count for debugging */
846 } qc_program;
847
848 qc_program* prog_load(const char *filename);
849 void        prog_delete(qc_program *prog);
850
851 bool prog_exec(qc_program *prog, prog_section_function *func, size_t flags, long maxjumps);
852
853 char*             prog_getstring (qc_program *prog, qcint str);
854 prog_section_def* prog_entfield  (qc_program *prog, qcint off);
855 prog_section_def* prog_getdef    (qc_program *prog, qcint off);
856 qcany*            prog_getedict  (qc_program *prog, qcint e);
857 qcint             prog_tempstring(qc_program *prog, const char *_str);
858
859
860 /*===================================================================*/
861 /*===================== parser.c commandline ========================*/
862 /*===================================================================*/
863
864 bool parser_init          ();
865 bool parser_compile_file  (const char *filename);
866 bool parser_compile_string(const char *name, const char *str);
867 bool parser_finish        (const char *output);
868 void parser_cleanup       ();
869 /* There's really no need to strlen() preprocessed files */
870 bool parser_compile_string_len(const char *name, const char *str, size_t len);
871
872 /*===================================================================*/
873 /*====================== ftepp.c commandline ========================*/
874 /*===================================================================*/
875 bool ftepp_init             ();
876 bool ftepp_preprocess_file  (const char *filename);
877 bool ftepp_preprocess_string(const char *name, const char *str);
878 void ftepp_finish           ();
879 const char *ftepp_get       ();
880 void ftepp_flush            ();
881 void ftepp_add_define       (const char *source, const char *name);
882 void ftepp_add_macro        (const char *name,   const char *value);
883
884 /*===================================================================*/
885 /*======================= main.c commandline ========================*/
886 /*===================================================================*/
887
888 #if 0
889 /* Helpers to allow for a whole lot of flags. Otherwise we'd limit
890  * to 32 or 64 -f options...
891  */
892 typedef struct {
893     size_t  idx; /* index into an array of 32 bit words */
894     uint8_t bit; /* index _into_ the 32 bit word, thus just uint8 */
895 } longbit;
896 #define LONGBIT(bit) { ((bit)/32), ((bit)%32) }
897 #else
898 typedef uint32_t longbit;
899 #define LONGBIT(bit) (bit)
900 #endif
901
902 /*===================================================================*/
903 /*============================= opts.c ==============================*/
904 /*===================================================================*/
905 typedef struct {
906     const char *name;
907     longbit     bit;
908 } opts_flag_def;
909
910 bool opts_setflag  (const char *, bool);
911 bool opts_setwarn  (const char *, bool);
912 bool opts_setwerror(const char *, bool);
913 bool opts_setoptim (const char *, bool);
914
915 void opts_init         (const char *, int, size_t);
916 void opts_set          (uint32_t   *, size_t, bool);
917 void opts_setoptimlevel(unsigned int);
918 void opts_ini_init     (const char *);
919
920 enum {
921 # define GMQCC_TYPE_FLAGS
922 # define GMQCC_DEFINE_FLAG(X) X,
923 #  include "opts.def"
924     COUNT_FLAGS
925 };
926 static const opts_flag_def opts_flag_list[] = {
927 # define GMQCC_TYPE_FLAGS
928 # define GMQCC_DEFINE_FLAG(X) { #X, LONGBIT(X) },
929 #  include "opts.def"
930     { NULL, LONGBIT(0) }
931 };
932
933 enum {
934 # define GMQCC_TYPE_WARNS
935 # define GMQCC_DEFINE_FLAG(X) WARN_##X,
936 #  include "opts.def"
937     COUNT_WARNINGS
938 };
939 static const opts_flag_def opts_warn_list[] = {
940 # define GMQCC_TYPE_WARNS
941 # define GMQCC_DEFINE_FLAG(X) { #X, LONGBIT(WARN_##X) },
942 #  include "opts.def"
943     { NULL, LONGBIT(0) }
944 };
945
946 enum {
947 # define GMQCC_TYPE_OPTIMIZATIONS
948 # define GMQCC_DEFINE_FLAG(NAME, MIN_O) OPTIM_##NAME,
949 #  include "opts.def"
950     COUNT_OPTIMIZATIONS
951 };
952 static const opts_flag_def opts_opt_list[] = {
953 # define GMQCC_TYPE_OPTIMIZATIONS
954 # define GMQCC_DEFINE_FLAG(NAME, MIN_O) { #NAME, LONGBIT(OPTIM_##NAME) },
955 #  include "opts.def"
956     { NULL, LONGBIT(0) }
957 };
958 static const unsigned int opts_opt_oflag[] = {
959 # define GMQCC_TYPE_OPTIMIZATIONS
960 # define GMQCC_DEFINE_FLAG(NAME, MIN_O) MIN_O,
961 #  include "opts.def"
962     0
963 };
964 extern unsigned int opts_optimizationcount[COUNT_OPTIMIZATIONS];
965
966 /* other options: */
967 typedef enum {
968     COMPILER_QCC,     /* circa  QuakeC */
969     COMPILER_FTEQCC,  /* fteqcc QuakeC */
970     COMPILER_QCCX,    /* qccx   QuakeC */
971     COMPILER_GMQCC    /* this   QuakeC */
972 } opts_std_t;
973
974 typedef struct {
975     uint32_t    O;              /* -Ox           */
976     const char *output;         /* -o file       */
977     bool        g;              /* -g            */
978     opts_std_t  standard;       /* -std=         */
979     bool        debug;          /* -debug        */
980     bool        memchk;         /* -memchk       */
981     bool        dumpfin;        /* -dumpfin      */
982     bool        dump;           /* -dump         */
983     bool        forcecrc;       /* --force-crc=  */
984     uint16_t    forced_crc;     /* --force-crc=  */
985     bool        pp_only;        /* -E            */
986     size_t      max_array_size; /* --max-array=  */
987
988     uint32_t flags       [1 + (COUNT_FLAGS         / 32)];
989     uint32_t warn        [1 + (COUNT_WARNINGS      / 32)];
990     uint32_t werror      [1 + (COUNT_WARNINGS      / 32)];
991     uint32_t optimization[1 + (COUNT_OPTIMIZATIONS / 32)];
992 } opts_cmd_t;
993
994 extern opts_cmd_t opts;
995
996 /*===================================================================*/
997 #define OPTS_FLAG(i)         (!! (opts.flags       [(i)/32] & (1<< ((i)%32))))
998 #define OPTS_WARN(i)         (!! (opts.warn        [(i)/32] & (1<< ((i)%32))))
999 #define OPTS_WERROR(i)       (!! (opts.werror      [(i)/32] & (1<< ((i)%32))))
1000 #define OPTS_OPTIMIZATION(i) (!! (opts.optimization[(i)/32] & (1<< ((i)%32))))
1001
1002 #endif