5 #define _MEM_VEC_FUN_APPEND(Tself, Twhat, mem) \
6 bool GMQCC_WARN Tself##_##mem##_append(Tself *s, Twhat *p, size_t c) \
9 if (s->mem##_count+c >= s->mem##_alloc) { \
10 if (!s->mem##_alloc) { \
11 s->mem##_alloc = c < 16 ? 16 : c; \
13 s->mem##_alloc *= 2; \
14 if (s->mem##_count+c >= s->mem##_alloc) { \
15 s->mem##_alloc = s->mem##_count+c; \
18 reall = (Twhat*)mem_a(sizeof(Twhat) * s->mem##_alloc); \
22 memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count); \
26 memcpy(&s->mem[s->mem##_count], p, c*sizeof(*p)); \
27 s->mem##_count += c; \
31 #define _MEM_VEC_FUN_RESIZE(Tself, Twhat, mem) \
32 bool GMQCC_WARN Tself##_##mem##_resize(Tself *s, size_t c) \
35 reall = (Twhat*)mem_a(sizeof(Twhat) * c); \
36 if (c > s->mem##_count) { \
37 memcpy(reall, s->mem, sizeof(Twhat) * s->mem##_count); \
39 memcpy(reall, s->mem, sizeof(Twhat) * c); \
46 /* darkplaces has (or will have) a 64 bit prog loader
47 * where the 32 bit qc program is autoconverted on load.
48 * Since we may want to support that as well, let's redefine
51 typedef float qcfloat;
52 typedef int32_t qcint;
64 typedef char qcfloat_size_is_correct [sizeof(qcfloat) == 4 ?1:-1];
65 typedef char qcint_size_is_correct [sizeof(int) == 4 ?1:-1];
77 prog_section statements;
80 prog_section functions;
86 typedef prog_section_both prog_def;
87 typedef prog_section_function prog_function;
88 typedef prog_section_statement prog_statement;
92 VMERR_TEMPSTRING_ALLOC,
97 #define JUMPS_DEFAULT 1000000
99 #define VMXF_DEFAULT 0x0000
100 #define VMXF_TRACE 0x0001
101 #define VMXF_PROFILE 0x0002
105 typedef int (*prog_builtin)(struct qc_program_s *prog);
110 prog_function *function;
113 typedef struct qc_program_s {
116 MEM_VECTOR_MAKE(prog_statement, code);
117 MEM_VECTOR_MAKE(prog_def, defs);
118 MEM_VECTOR_MAKE(prog_def, fields);
119 MEM_VECTOR_MAKE(prog_function, functions);
120 MEM_VECTOR_MAKE(char, strings);
121 MEM_VECTOR_MAKE(qcint, globals);
122 MEM_VECTOR_MAKE(qcint, entitydata);
124 size_t tempstring_start;
125 size_t tempstring_at;
129 MEM_VECTOR_MAKE(size_t, profile);
131 MEM_VECTOR_MAKE(prog_builtin, builtins);
136 bool allowworldwrites;
138 MEM_VECTOR_MAKE(qcint, localstack);
139 MEM_VECTOR_MAKE(qc_exec_stack, stack);
142 int argc; /* current arg count for debugging */
144 MEM_VEC_FUNCTIONS(qc_program, prog_statement, code)
145 MEM_VEC_FUNCTIONS(qc_program, prog_def, defs)
146 MEM_VEC_FUNCTIONS(qc_program, prog_def, fields)
147 MEM_VEC_FUNCTIONS(qc_program, prog_function, functions)
148 MEM_VEC_FUNCTIONS(qc_program, char, strings)
149 _MEM_VEC_FUN_APPEND(qc_program, char, strings)
150 _MEM_VEC_FUN_RESIZE(qc_program, char, strings)
151 MEM_VEC_FUNCTIONS(qc_program, qcint, globals)
152 MEM_VEC_FUNCTIONS(qc_program, qcint, entitydata)
154 MEM_VEC_FUNCTIONS(qc_program, qcint, localstack)
155 _MEM_VEC_FUN_APPEND(qc_program, qcint, localstack)
156 _MEM_VEC_FUN_RESIZE(qc_program, qcint, localstack)
157 MEM_VEC_FUNCTIONS(qc_program, qc_exec_stack, stack)
159 MEM_VEC_FUNCTIONS(qc_program, size_t, profile)
160 _MEM_VEC_FUN_RESIZE(qc_program, size_t, profile)
162 qc_program* prog_load(const char *filename)
168 file = fopen(filename, "rb");
172 if (fread(&header, sizeof(header), 1, file) != 1) {
178 if (header.version != 6) {
179 printf("header says this is a version %i progs, we need version 6\n",
185 prog = (qc_program*)mem_a(sizeof(qc_program));
188 printf("failed to allocate program data\n");
191 memset(prog, 0, sizeof(*prog));
193 prog->entityfields = header.entfield;
195 prog->filename = util_strdup(filename);
198 #define read_data(hdrvar, progvar, type) \
199 if (fseek(file, header.hdrvar.offset, SEEK_SET) != 0) { \
203 prog->progvar##_alloc = header.hdrvar.length; \
204 prog->progvar##_count = header.hdrvar.length; \
205 prog->progvar = (type*)mem_a(header.hdrvar.length * sizeof(*prog->progvar)); \
206 if (!prog->progvar) \
208 if (fread(prog->progvar, sizeof(*prog->progvar), header.hdrvar.length, file) \
209 != header.hdrvar.length) { \
213 #define read_data1(x, y) read_data(x, x, y)
215 read_data (statements, code, prog_statement);
216 read_data1(defs, prog_def);
217 read_data1(fields, prog_def);
218 read_data1(functions, prog_function);
219 read_data1(strings, char);
220 read_data1(globals, qcint);
224 /* profile counters */
225 if (!qc_program_profile_resize(prog, prog->code_count))
228 /* Add tempstring area */
229 prog->tempstring_start = prog->strings_count;
230 prog->tempstring_at = prog->strings_count;
231 if (!qc_program_strings_resize(prog, prog->strings_count + 16*1024))
237 if (prog->filename) mem_d(prog->filename);
238 if (prog->code) mem_d(prog->code);
239 if (prog->defs) mem_d(prog->defs);
240 if (prog->fields) mem_d(prog->fields);
241 if (prog->functions) mem_d(prog->functions);
242 if (prog->strings) mem_d(prog->strings);
243 if (prog->globals) mem_d(prog->globals);
244 if (prog->entitydata) mem_d(prog->entitydata);
249 void prog_delete(qc_program *prog)
251 if (prog->filename) mem_d(prog->filename);
252 MEM_VECTOR_CLEAR(prog, code);
253 MEM_VECTOR_CLEAR(prog, defs);
254 MEM_VECTOR_CLEAR(prog, fields);
255 MEM_VECTOR_CLEAR(prog, functions);
256 MEM_VECTOR_CLEAR(prog, strings);
257 MEM_VECTOR_CLEAR(prog, globals);
258 MEM_VECTOR_CLEAR(prog, entitydata);
259 MEM_VECTOR_CLEAR(prog, localstack);
260 MEM_VECTOR_CLEAR(prog, stack);
261 MEM_VECTOR_CLEAR(prog, profile);
265 /***********************************************************************
269 char* prog_getstring(qc_program *prog, qcint str)
271 if (str < 0 || str >= prog->strings_count)
272 return "<<<invalid string>>>";
273 return prog->strings + str;
276 prog_def* prog_entfield(qc_program *prog, qcint off)
279 for (i = 0; i < prog->fields_count; ++i) {
280 if (prog->fields[i].offset == off)
281 return (prog->fields + i);
286 prog_def* prog_getdef(qc_program *prog, qcint off)
289 for (i = 0; i < prog->defs_count; ++i) {
290 if (prog->defs[i].offset == off)
291 return (prog->defs + i);
296 qcany* prog_getedict(qc_program *prog, qcint e)
298 return (qcany*)(prog->entitydata + (prog->entityfields + e));
301 qcint prog_tempstring(qc_program *prog, const char *_str)
303 /* we don't access it, but the macro-generated functions don't use
306 char *str = (char*)_str;
308 size_t len = strlen(str);
309 size_t at = prog->tempstring_at;
311 /* when we reach the end we start over */
312 if (at + len >= prog->strings_count)
313 at = prog->tempstring_start;
315 /* when it doesn't fit, reallocate */
316 if (at + len >= prog->strings_count)
318 prog->strings_count = at;
319 if (!qc_program_strings_append(prog, str, len+1)) {
320 prog->vmerror = VMERR_TEMPSTRING_ALLOC;
326 /* when it fits, just copy */
327 memcpy(prog->strings + at, str, len+1);
328 prog->tempstring_at += len+1;
332 static void trace_print_global(qc_program *prog, unsigned int glob, int vtype)
334 static char spaces[16+1] = " ";
342 def = prog_getdef(prog, glob);
343 value = (qcany*)(&prog->globals[glob]);
346 len = printf("[%s] ", prog_getstring(prog, def->name));
350 len = printf("[#%u] ", glob);
358 len += printf("%i,", value->_int);
361 len += printf("'%g %g %g',", value->vector[0],
366 len += printf("\"%s\",", prog_getstring(prog, value->string));
370 len += printf("%g,", value->_float);
376 spaces[16-len] = ' ';
380 static void prog_print_statement(qc_program *prog, prog_statement *st)
382 if (st->opcode >= (sizeof(asm_instr)/sizeof(asm_instr[0]))) {
383 printf("<illegal instruction %d>\n", st->opcode);
386 printf("%-12s", asm_instr[st->opcode].m);
387 if (st->opcode >= INSTR_IF &&
388 st->opcode <= INSTR_IFNOT)
390 trace_print_global(prog, st->o1.u1, TYPE_FLOAT);
391 printf("%d\n", st->o2.s1);
393 else if (st->opcode >= INSTR_CALL0 &&
394 st->opcode <= INSTR_CALL8)
398 else if (st->opcode == INSTR_GOTO)
400 printf("%i\n", st->o1.s1);
404 int t[3] = { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT };
408 t[1] = t[2] = TYPE_VECTOR;
411 t[0] = t[2] = TYPE_VECTOR;
414 t[0] = t[1] = TYPE_VECTOR;
420 t[0] = t[1] = t[2] = TYPE_VECTOR;
424 t[0] = t[1] = TYPE_STRING;
427 t[0] = t[1] = TYPE_VECTOR; t[2] = -1;
430 t[0] = t[1] = TYPE_STRING; t[2] = -1;
433 if (t[0] >= 0) trace_print_global(prog, st->o1.u1, t[0]);
434 if (t[1] >= 0) trace_print_global(prog, st->o2.u1, t[1]);
435 if (t[2] >= 0) trace_print_global(prog, st->o3.u1, t[2]);
440 qcint prog_enterfunction(qc_program *prog, prog_function *func)
443 prog_function *cur = NULL;
445 if (prog->stack_count)
446 cur = prog->stack[prog->stack_count-1].function;
449 st.localsp = prog->localstack_count;
450 st.stmt = prog->statement;
455 qcint *globals = prog->globals + cur->firstlocal;
456 if (!qc_program_localstack_append(prog, globals, cur->locals))
458 printf("out of memory\n");
463 if (!qc_program_stack_add(prog, st)) {
464 printf("out of memory\n");
471 qcint prog_leavefunction(qc_program *prog)
473 qc_exec_stack st = prog->stack[prog->stack_count-1];
474 if (!qc_program_stack_remove(prog, prog->stack_count-1)) {
475 printf("out of memory\n");
479 if (st.localsp != prog->localstack_count) {
480 if (!qc_program_localstack_resize(prog, st.localsp)) {
481 printf("out of memory\n");
489 bool prog_exec(qc_program *prog, prog_function *func, size_t flags, long maxjumps)
494 st = prog->code + prog_enterfunction(prog, func);
501 #define QCVM_PROFILE 0
503 # include "qcvm_execprogram.h"
508 #define QCVM_PROFILE 0
510 # include "qcvm_execprogram.h"
515 #define QCVM_PROFILE 1
517 # include "qcvm_execprogram.h"
520 case (VMXF_TRACE|VMXF_PROFILE):
522 #define QCVM_PROFILE 1
524 # include "qcvm_execprogram.h"
530 prog->localstack_count = 0;
531 prog->stack_count = 0;
535 /***********************************************************************
536 * main for when building the standalone executor
539 #if defined(QCVM_EXECUTOR)
540 int main(int argc, char **argv)
547 printf("usage: %s file\n", argv[0]);
551 prog = prog_load(argv[1]);
553 printf("failed to load program '%s'\n", argv[1]);
557 for (i = 1; i < prog->functions_count; ++i) {
558 const char *name = prog_getstring(prog, prog->functions[i].name);
559 printf("Found function: %s\n", name);
560 if (!strcmp(name, "main"))
565 prog_exec(prog, &prog->functions[fnmain], VMXF_TRACE, JUMPS_DEFAULT);
568 printf("No main function found\n");