qcvm -trace now shows the current function name and nest-depth

[xonotic/gmqcc.git] / gmqcc.h

diff --git a/gmqcc.h b/gmqcc.h
index 787fb1dfab9ec7d49507808204093b8a44e5facf..ef1841f713f73948bad62a805dfbb80618a4831e 100644 (file)
--- a/gmqcc.h
+++ b/gmqcc.h
@@ -210,7 +210,8 @@ void  util_endianswap    (void *,  int, int);
 size_t util_strtocmd    (const char *, char *, size_t);
 size_t util_strtononcmd (const char *, char *, size_t);
 
-uint32_t util_crc32(const char *, int, register const short);
+uint16_t util_crc16(uint16_t crc, const char *data, size_t len);
+uint32_t util_crc32(uint32_t crc, const char *data, size_t len);
 
 #ifdef NOTRACK
 #    define mem_a(x) malloc(x)
@@ -289,6 +290,9 @@ enum {
     TYPE_POINTER  ,
     TYPE_INTEGER  ,
     TYPE_VARIANT  ,
+    TYPE_STRUCT   ,
+    TYPE_UNION    ,
+    TYPE_ARRAY    ,
 
     TYPE_COUNT
 };
@@ -297,6 +301,7 @@ extern const char *type_name[TYPE_COUNT];
 
 extern size_t type_sizeof[TYPE_COUNT];
 extern uint16_t type_store_instr[TYPE_COUNT];
+extern uint16_t field_store_instr[TYPE_COUNT];
 /* could use type_store_instr + INSTR_STOREP_F - INSTR_STORE_F
  * but this breaks when TYPE_INTEGER is added, since with the enhanced
  * instruction set, the old ones are left untouched, thus the _I instructions
@@ -390,6 +395,10 @@ typedef struct {
 typedef prog_section_both prog_section_def;
 typedef prog_section_both prog_section_field;
 
+/* this is ORed to the type */
+#define DEF_SAVEGLOBAL (1<<15)
+#define DEF_TYPEMASK   ((1<<15)-1)
+
 typedef struct {
     int32_t   entry;      /* in statement table for instructions  */
     uint32_t  firstlocal; /* First local in local table           */
@@ -410,8 +419,8 @@ enum {
     INSTR_DONE,
     INSTR_MUL_F,
     INSTR_MUL_V,
-    INSTR_MUL_FV,
-    INSTR_MUL_VF,
+    INSTR_MUL_FV, /* NOTE: the float operands must NOT be at the same locations: A != C */
+    INSTR_MUL_VF, /* and here: B != C */
     INSTR_DIV_F,
     INSTR_ADD_F,
     INSTR_ADD_V,
@@ -508,6 +517,7 @@ VECTOR_PROT(prog_section_field,     code_fields    );
 VECTOR_PROT(prog_section_function,  code_functions );
 VECTOR_PROT(int,                    code_globals   );
 VECTOR_PROT(char,                   code_chars     );
+extern uint16_t code_crc;
 
 typedef float   qcfloat;
 typedef int32_t qcint;
@@ -686,22 +696,26 @@ bool GMQCC_WARN Tself##_##mem##_find(Tself *self, Twhat obj, size_t *idx) \
 bool GMQCC_WARN Tself##_##mem##_append(Tself *s, Twhat *p, size_t c) \
 {                                                                    \
     Twhat *reall;                                                    \
-    if (s->mem##_count+c >= s->mem##_alloc) {                        \
+    size_t oldalloc;                                                 \
+    if (s->mem##_count+c > s->mem##_alloc) {                         \
         if (!s->mem##_alloc) {                                       \
             s->mem##_alloc = c < 16 ? 16 : c;                        \
+            s->mem = (Twhat*)mem_a(sizeof(Twhat) * s->mem##_alloc);  \
         } else {                                                     \
+            oldalloc = s->mem##_alloc;                               \
             s->mem##_alloc *= 2;                                     \
             if (s->mem##_count+c >= s->mem##_alloc) {                \
                 s->mem##_alloc = s->mem##_count+c;                   \
             }                                                        \
+            reall = (Twhat*)mem_a(sizeof(Twhat) * s->mem##_alloc);   \
+            if (!reall) {                                            \
+                s->mem##_alloc = oldalloc;                           \
+                return false;                                        \
+            }                                                        \
+            memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count);   \
+            mem_d(s->mem);                                           \
+            s->mem = reall;                                          \
         }                                                            \
-        reall = (Twhat*)mem_a(sizeof(Twhat) * s->mem##_alloc);       \
-        if (!reall) {                                                \
-            return false;                                            \
-        }                                                            \
-        memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count);       \
-        mem_d(s->mem);                                               \
-        s->mem = reall;                                              \
     }                                                                \
     memcpy(&s->mem[s->mem##_count], p, c*sizeof(*p));                \
     s->mem##_count += c;                                             \
@@ -729,6 +743,7 @@ bool GMQCC_WARN Tself##_##mem##_resize(Tself *s, size_t c)       \
         memcpy(reall, s->mem, sizeof(Twhat) * c);                \
         mem_d(s->mem);                                           \
         s->mem = reall;                                          \
+        s->mem##_alloc = c;                                      \
     }                                                            \
     return true;                                                 \
 }
@@ -861,6 +876,8 @@ typedef struct qc_program_s {
     MEM_VECTOR_MAKE(qcint,                  entitydata);
     MEM_VECTOR_MAKE(bool,                   entitypool);
 
+    MEM_VECTOR_MAKE(const char*,            function_stack);
+
     uint16_t crc16;
 
     size_t tempstring_start;
@@ -960,28 +977,28 @@ typedef struct {
 /*===================================================================*/
 /* list of -f flags, like -fdarkplaces-string-table-bug */
 enum {
+# define GMQCC_TYPE_FLAGS
 # define GMQCC_DEFINE_FLAG(X) X,
-#  include "flags.def"
-# undef GMQCC_DEFINE_FLAG
+#  include "opts.def"
     COUNT_FLAGS
 };
 static const opts_flag_def opts_flag_list[] = {
+# define GMQCC_TYPE_FLAGS
 # define GMQCC_DEFINE_FLAG(X) { #X, LONGBIT(X) },
-#  include "flags.def"
-# undef GMQCC_DEFINE_FLAG
+#  include "opts.def"
     { NULL, LONGBIT(0) }
 };
 
 enum {
+# define GMQCC_TYPE_WARNS
 # define GMQCC_DEFINE_FLAG(X) WARN_##X,
-#  include "warns.def"
-# undef GMQCC_DEFINE_FLAG
+#  include "opts.def"
     COUNT_WARNINGS
 };
 static const opts_flag_def opts_warn_list[] = {
+# define GMQCC_TYPE_WARNS
 # define GMQCC_DEFINE_FLAG(X) { #X, LONGBIT(WARN_##X) },
-#  include "warns.def"
-# undef GMQCC_DEFINE_FLAG
+#  include "opts.def"
     { NULL, LONGBIT(0) }
 };
 
@@ -1001,6 +1018,8 @@ extern bool        opts_dump;
 extern bool        opts_werror;
 extern bool        opts_forcecrc;
 extern uint16_t    opts_forced_crc;
+extern bool        opts_pp_only;
+extern size_t      opts_max_array_size;
 
 /*===================================================================*/
 #define OPTS_FLAG(i) (!! (opts_flags[(i)/32] & (1<< ((i)%32))))