/*===================================================================*/
FILE *util_fopen(const char *filename, const char *mode);
-void *util_memory_a (unsigned int, unsigned int, const char *);
+void *util_memory_a (size_t, unsigned int, const char *);
void util_memory_d (void *, unsigned int, const char *);
+void *util_memory_r (void *, size_t, unsigned int, const char *);
void util_meminfo ();
bool util_strupper (const char *);
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)
-# define mem_d(x) free (x)
+# define mem_a(x) malloc(x)
+# define mem_d(x) free (x)
+# define mem_r(x, n) free (x, n)
#else
-# define mem_a(x) util_memory_a((x), __LINE__, __FILE__)
-# define mem_d(x) util_memory_d((x), __LINE__, __FILE__)
+# define mem_a(x) util_memory_a((x), __LINE__, __FILE__)
+# define mem_d(x) util_memory_d((x), __LINE__, __FILE__)
+# define mem_r(x, n) util_memory_r((x), (n), __LINE__, __FILE__)
#endif
/*
#define FLT2INT(Y) *((int32_t*)&(Y))
#define INT2FLT(Y) *((float *)&(Y))
-/* Builds vector type (usefull for inside structures) */
-#define VECTOR_SNAP(X,Y) X ## Y
-#define VECTOR_FILL(X,Y) VECTOR_SNAP(X,Y)
-#define VECTOR_TYPE(T,N) \
- T* N##_data = NULL; \
- long N##_elements = 0; \
- long N##_allocated = 0
-/* Builds vector add */
-#define VECTOR_CORE(T,N) \
- int N##_add(T element) { \
- void *temp = NULL; \
- if (N##_elements == N##_allocated) { \
- if (N##_allocated == 0) { \
- N##_allocated = 12; \
- } else { \
- N##_allocated *= 2; \
- } \
- if (!(temp = mem_a(N##_allocated * sizeof(T)))) { \
- mem_d(temp); \
- return -1; \
- } \
- memcpy(temp, N##_data, (N##_elements * sizeof(T))); \
- mem_d(N##_data); \
- N##_data = (T*)temp; \
- } \
- N##_data[N##_elements] = element; \
- return N##_elements++; \
- } \
- int N##_put(T* elements, size_t len) { \
- len --; \
- elements--; \
- while (N##_add(*++elements) != -1 && len--); \
- return N##_elements; \
- } \
- typedef char VECTOR_FILL(extra_semicolon_##N,__COUNTER__)
-#define VECTOR_PROT(T,N) \
- extern T* N##_data ; \
- extern long N##_elements ; \
- extern long N##_allocated; \
- int N##_add(T); \
- int N##_put(T *, size_t)
-#define VECTOR_MAKE(T,N) \
- VECTOR_TYPE(T,N); \
- VECTOR_CORE(T,N)
+/* New flexible vector implementation from Dale */
+#define _vec_raw(A) (((size_t*)(A)) - 2)
+#define _vec_beg(A) (_vec_raw(A)[0])
+#define _vec_end(A) (_vec_raw(A)[1])
+#define _vec_needsgrow(A,N) ((!(A)) || (_vec_end(A) + (N) >= _vec_beg(A)))
+#define _vec_mightgrow(A,N) (_vec_needsgrow((A), (N)) ? _vec_forcegrow((A),(N)) : 0)
+#define _vec_forcegrow(A,N) _util_vec_grow((void**)&(A), (N), sizeof(*(A)))
+void _util_vec_grow(void **a, size_t i, size_t s);
+/* exposed interface */
+#define vec_free(A) ((A) ? (mem_d(_vec_raw(A)), (A) = NULL) : 0)
+#define vec_push(A,V) (_vec_mightgrow((A),1), (A)[_vec_end(A)++] = (V))
+#define vec_size(A) ((A) ? _vec_end(A) : 0)
+#define vec_add(A,N) (_vec_mightgrow((A),(N)), _vec_end(A)+=(N), &(A)[_vec_end(A)-(N)])
+#define vec_last(A) ((A)[_vec_end(A)-1])
+#define vec_append(A,N,S) memcpy(vec_add((A), (N)), (S), N * sizeof(*(S)))
+#define _vec_remove(A,S,I,N) (memmove((char*)(A)+(I)*(S),(char*)(A)+((I)+(N))*(S),(S)*(vec_size(A)-(I)-(N))), _vec_end(A)-=(N))
+#define vec_remove(A,I,N) _vec_remove((A), sizeof(*(A)), (I), (N))
+#define vec_pop(A) vec_remove((A), _vec_end(A)-1, 1)
+/* these are supposed to NOT reallocate */
+#define vec_shrinkto(A,N) (_vec_end(A) = (N))
+#define vec_shrinkby(A,N) (_vec_end(A) -= (N))
/*===================================================================*/
/*=========================== code.c ================================*/
TYPE_POINTER ,
TYPE_INTEGER ,
TYPE_VARIANT ,
+ TYPE_STRUCT ,
+ TYPE_UNION ,
+ TYPE_ARRAY ,
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
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 */
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,
VINSTR_COND
};
-/*
- * The symbols below are created by the following
- * expanded macros:
- *
- * VECTOR_MAKE(prog_section_statement, code_statements);
- * VECTOR_MAKE(prog_section_def, code_defs );
- * VECTOR_MAKE(prog_section_field, code_fields );
- * VECTOR_MAKE(prog_section_function, code_functions );
- * VECTOR_MAKE(int, code_globals );
- * VECTOR_MAKE(char, code_chars );
- */
-VECTOR_PROT(prog_section_statement, code_statements);
-VECTOR_PROT(prog_section_statement, code_statements);
-VECTOR_PROT(prog_section_def, code_defs );
-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 prog_section_statement *code_statements;
+extern prog_section_def *code_defs;
+extern prog_section_field *code_fields;
+extern prog_section_function *code_functions;
+extern int *code_globals;
+extern char *code_chars;
+extern uint16_t code_crc;
typedef float qcfloat;
typedef int32_t qcint;
uint32_t code_cachedstring(const char *string);
qcint code_alloc_field (size_t qcsize);
+/*===================================================================*/
+/*============================ con.c ================================*/
+/*===================================================================*/
+enum {
+ CON_BLACK = 30,
+ CON_RED,
+ CON_GREEN,
+ CON_BROWN,
+ CON_BLUE,
+ CON_MAGENTA,
+ CON_CYAN ,
+ CON_WHITE
+};
+
+/* message level */
+enum {
+ LVL_MSG,
+ LVL_WARNING,
+ LVL_ERROR
+};
+
+
+void con_vprintmsg (int level, const char *name, size_t line, const char *msgtype, const char *msg, va_list ap);
+void con_printmsg (int level, const char *name, size_t line, const char *msgtype, const char *msg, ...);
+void con_cvprintmsg(void *ctx, int lvl, const char *msgtype, const char *msg, va_list ap);
+void con_cprintmsg (void *ctx, int lvl, const char *msgtype, const char *msg, ...);
+
+void con_close();
+void con_color(int state);
+void con_init ();
+void con_reset();
+int con_change(const char *out, const char *err);
+int con_verr (const char *fmt, va_list va);
+int con_vout (const char *fmt, va_list va);
+int con_err (const char *fmt, ...);
+int con_out (const char *fmt, ...);
+
/*===================================================================*/
/*========================= assembler.c =============================*/
/*===================================================================*/
{ "END" , 0, 3 } /* virtual assembler instruction */
};
-
-void asm_init (const char *, FILE **);
-void asm_close(FILE *);
-void asm_parse(FILE *);
/*===================================================================*/
/*============================= ast.c ===============================*/
/*===================================================================*/
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; \
memcpy(reall, s->mem, sizeof(Twhat) * c); \
mem_d(s->mem); \
s->mem = reall; \
+ s->mem##_alloc = c; \
} \
return true; \
}
typedef struct qc_program_s {
char *filename;
- MEM_VECTOR_MAKE(prog_section_statement, code);
- MEM_VECTOR_MAKE(prog_section_def, defs);
- MEM_VECTOR_MAKE(prog_section_def, fields);
- MEM_VECTOR_MAKE(prog_section_function, functions);
- MEM_VECTOR_MAKE(char, strings);
- MEM_VECTOR_MAKE(qcint, globals);
- MEM_VECTOR_MAKE(qcint, entitydata);
- MEM_VECTOR_MAKE(bool, entitypool);
+ prog_section_statement *code;
+ prog_section_def *defs;
+ prog_section_def *fields;
+ prog_section_function *functions;
+ char *strings;
+ qcint *globals;
+ qcint *entitydata;
+ bool *entitypool;
+
+ const char* *function_stack;
uint16_t crc16;
qcint vmerror;
- MEM_VECTOR_MAKE(size_t, profile);
+ size_t *profile;
- MEM_VECTOR_MAKE(prog_builtin, builtins);
+ prog_builtin *builtins;
+ size_t builtins_count;
/* size_t ip; */
qcint entities;
size_t entityfields;
bool allowworldwrites;
- MEM_VECTOR_MAKE(qcint, localstack);
- MEM_VECTOR_MAKE(qc_exec_stack, stack);
+ qcint *localstack;
+ qc_exec_stack *stack;
size_t statement;
size_t xflags;
qcany* prog_getedict (qc_program *prog, qcint e);
qcint prog_tempstring(qc_program *prog, const char *_str);
-/*===================================================================*/
-/*===================== error.c message printer =====================*/
-/*===================================================================*/
-
-#ifndef WIN32
-enum {
- CON_BLACK = 30,
- CON_RED,
- CON_GREEN,
- CON_BROWN,
- CON_BLUE,
- CON_MAGENTA,
- CON_CYAN ,
- CON_WHITE
-};
-#endif
-enum {
- LVL_MSG,
- LVL_WARNING,
- LVL_ERROR
-};
-
-void vprintmsg (int level, const char *name, size_t line, const char *msgtype, const char *msg, va_list ap);
-void printmsg (int level, const char *name, size_t line, const char *msgtype, const char *msg, ...);
-void cvprintmsg(lex_ctx ctx, int lvl, const char *msgtype, const char *msg, va_list ap);
-void cprintmsg (lex_ctx ctx, int lvl, const char *msgtype, const char *msg, ...);
/*===================================================================*/
/*===================== parser.c commandline ========================*/
/*===================================================================*/
-bool parser_init ();
-bool parser_compile(const char *filename);
-bool parser_finish (const char *output);
-void parser_cleanup();
+bool parser_init ();
+bool parser_compile_file (const char *filename);
+bool parser_compile_string(const char *name, const char *str);
+bool parser_finish (const char *output);
+void parser_cleanup ();
/*===================================================================*/
/*======================= main.c commandline ========================*/
/*===================================================================*/
/* 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) }
};
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))))