7 MEM_VEC_FUNCTIONS(qc_program, prog_section_statement, code)
8 MEM_VEC_FUNCTIONS(qc_program, prog_section_def, defs)
9 MEM_VEC_FUNCTIONS(qc_program, prog_section_def, fields)
10 MEM_VEC_FUNCTIONS(qc_program, prog_section_function, functions)
11 MEM_VEC_FUNCTIONS(qc_program, char, strings)
12 MEM_VEC_FUN_APPEND(qc_program, char, strings)
13 MEM_VEC_FUN_RESIZE(qc_program, char, strings)
14 MEM_VEC_FUNCTIONS(qc_program, qcint, globals)
15 MEM_VEC_FUNCTIONS(qc_program, qcint, entitydata)
17 MEM_VEC_FUNCTIONS(qc_program, qcint, localstack)
18 MEM_VEC_FUN_APPEND(qc_program, qcint, localstack)
19 MEM_VEC_FUN_RESIZE(qc_program, qcint, localstack)
20 MEM_VEC_FUNCTIONS(qc_program, qc_exec_stack, stack)
22 MEM_VEC_FUNCTIONS(qc_program, size_t, profile)
23 MEM_VEC_FUN_RESIZE(qc_program, size_t, profile)
25 MEM_VEC_FUNCTIONS(qc_program, prog_builtin, builtins)
27 static void loaderror(const char *fmt, ...)
34 printf(": %s\n", strerror(err));
37 qc_program* prog_load(const char *filename)
43 file = fopen(filename, "rb");
47 if (fread(&header, sizeof(header), 1, file) != 1) {
48 loaderror("failed to read header from '%s'", filename);
53 if (header.version != 6) {
54 loaderror("header says this is a version %i progs, we need version 6\n", header.version);
59 prog = (qc_program*)mem_a(sizeof(qc_program));
62 printf("failed to allocate program data\n");
65 memset(prog, 0, sizeof(*prog));
67 prog->entityfields = header.entfield;
69 prog->filename = util_strdup(filename);
70 if (!prog->filename) {
71 loaderror("failed to store program name");
75 #define read_data(hdrvar, progvar, type) \
76 if (fseek(file, header.hdrvar.offset, SEEK_SET) != 0) { \
77 loaderror("seek failed"); \
80 prog->progvar##_alloc = header.hdrvar.length; \
81 prog->progvar##_count = header.hdrvar.length; \
82 prog->progvar = (type*)mem_a(header.hdrvar.length * sizeof(*prog->progvar)); \
85 if (fread(prog->progvar, sizeof(*prog->progvar), header.hdrvar.length, file) \
86 != header.hdrvar.length) { \
87 loaderror("read failed"); \
90 #define read_data1(x, y) read_data(x, x, y)
92 read_data (statements, code, prog_section_statement);
93 read_data1(defs, prog_section_def);
94 read_data1(fields, prog_section_def);
95 read_data1(functions, prog_section_function);
96 read_data1(strings, char);
97 read_data1(globals, qcint);
101 /* profile counters */
102 if (!qc_program_profile_resize(prog, prog->code_count))
105 /* Add tempstring area */
106 prog->tempstring_start = prog->strings_count;
107 prog->tempstring_at = prog->strings_count;
108 if (!qc_program_strings_resize(prog, prog->strings_count + 16*1024))
114 if (prog->filename) mem_d(prog->filename);
115 if (prog->code) mem_d(prog->code);
116 if (prog->defs) mem_d(prog->defs);
117 if (prog->fields) mem_d(prog->fields);
118 if (prog->functions) mem_d(prog->functions);
119 if (prog->strings) mem_d(prog->strings);
120 if (prog->globals) mem_d(prog->globals);
121 if (prog->entitydata) mem_d(prog->entitydata);
126 void prog_delete(qc_program *prog)
128 if (prog->filename) mem_d(prog->filename);
129 MEM_VECTOR_CLEAR(prog, code);
130 MEM_VECTOR_CLEAR(prog, defs);
131 MEM_VECTOR_CLEAR(prog, fields);
132 MEM_VECTOR_CLEAR(prog, functions);
133 MEM_VECTOR_CLEAR(prog, strings);
134 MEM_VECTOR_CLEAR(prog, globals);
135 MEM_VECTOR_CLEAR(prog, entitydata);
136 MEM_VECTOR_CLEAR(prog, localstack);
137 MEM_VECTOR_CLEAR(prog, stack);
138 MEM_VECTOR_CLEAR(prog, profile);
140 if (prog->builtins_alloc) {
141 MEM_VECTOR_CLEAR(prog, builtins);
143 /* otherwise the builtins were statically allocated */
147 /***********************************************************************
151 char* prog_getstring(qc_program *prog, qcint str)
153 if (str < 0 || str >= prog->strings_count)
154 return "<<<invalid string>>>";
155 return prog->strings + str;
158 prog_section_def* prog_entfield(qc_program *prog, qcint off)
161 for (i = 0; i < prog->fields_count; ++i) {
162 if (prog->fields[i].offset == off)
163 return (prog->fields + i);
168 prog_section_def* prog_getdef(qc_program *prog, qcint off)
171 for (i = 0; i < prog->defs_count; ++i) {
172 if (prog->defs[i].offset == off)
173 return (prog->defs + i);
178 qcany* prog_getedict(qc_program *prog, qcint e)
180 return (qcany*)(prog->entitydata + (prog->entityfields + e));
183 qcint prog_tempstring(qc_program *prog, const char *_str)
185 /* we don't access it, but the macro-generated functions don't use
188 char *str = (char*)_str;
190 size_t len = strlen(str);
191 size_t at = prog->tempstring_at;
193 /* when we reach the end we start over */
194 if (at + len >= prog->strings_count)
195 at = prog->tempstring_start;
197 /* when it doesn't fit, reallocate */
198 if (at + len >= prog->strings_count)
200 prog->strings_count = at;
201 if (!qc_program_strings_append(prog, str, len+1)) {
202 prog->vmerror = VMERR_TEMPSTRING_ALLOC;
208 /* when it fits, just copy */
209 memcpy(prog->strings + at, str, len+1);
210 prog->tempstring_at += len+1;
214 static void trace_print_global(qc_program *prog, unsigned int glob, int vtype)
216 static char spaces[16+1] = " ";
217 prog_section_def *def;
224 def = prog_getdef(prog, glob);
225 value = (qcany*)(&prog->globals[glob]);
228 len = printf("[%s] ", prog_getstring(prog, def->name));
232 len = printf("[#%u] ", glob);
240 len += printf("%i,", value->_int);
243 len += printf("'%g %g %g',", value->vector[0],
248 len += printf("\"%s\",", prog_getstring(prog, value->string));
252 len += printf("%g,", value->_float);
258 spaces[16-len] = ' ';
262 static void prog_print_statement(qc_program *prog, prog_section_statement *st)
264 if (st->opcode >= (sizeof(asm_instr)/sizeof(asm_instr[0]))) {
265 printf("<illegal instruction %d>\n", st->opcode);
268 printf("%-12s", asm_instr[st->opcode].m);
269 if (st->opcode >= INSTR_IF &&
270 st->opcode <= INSTR_IFNOT)
272 trace_print_global(prog, st->o1.u1, TYPE_FLOAT);
273 printf("%d\n", st->o2.s1);
275 else if (st->opcode >= INSTR_CALL0 &&
276 st->opcode <= INSTR_CALL8)
280 else if (st->opcode == INSTR_GOTO)
282 printf("%i\n", st->o1.s1);
286 int t[3] = { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT };
290 t[1] = t[2] = TYPE_VECTOR;
293 t[0] = t[2] = TYPE_VECTOR;
296 t[0] = t[1] = TYPE_VECTOR;
302 t[0] = t[1] = t[2] = TYPE_VECTOR;
306 t[0] = t[1] = TYPE_STRING;
309 t[0] = t[1] = TYPE_VECTOR; t[2] = -1;
312 t[0] = t[1] = TYPE_STRING; t[2] = -1;
315 if (t[0] >= 0) trace_print_global(prog, st->o1.u1, t[0]);
316 if (t[1] >= 0) trace_print_global(prog, st->o2.u1, t[1]);
317 if (t[2] >= 0) trace_print_global(prog, st->o3.u1, t[2]);
322 static qcint prog_enterfunction(qc_program *prog, prog_section_function *func)
328 st.localsp = prog->localstack_count;
329 st.stmt = prog->statement;
332 #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
333 if (prog->stack_count)
335 prog_section_function *cur;
336 cur = prog->stack[prog->stack_count-1].function;
339 qcint *globals = prog->globals + cur->firstlocal;
340 if (!qc_program_localstack_append(prog, globals, cur->locals))
342 printf("out of memory\n");
349 qcint *globals = prog->globals + func->firstlocal;
350 if (!qc_program_localstack_append(prog, globals, func->locals))
352 printf("out of memory\n");
358 /* copy parameters */
359 parampos = func->firstlocal;
360 for (p = 0; p < func->nargs; ++p)
363 for (s = 0; s < func->argsize[p]; ++s) {
364 prog->globals[parampos] = prog->globals[OFS_PARM0 + 3*p + s];
369 if (!qc_program_stack_add(prog, st)) {
370 printf("out of memory\n");
377 static qcint prog_leavefunction(qc_program *prog)
379 prog_section_function *prev = NULL;
382 qc_exec_stack st = prog->stack[prog->stack_count-1];
384 #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
385 if (prog->stack_count > 1) {
386 prev = prog->stack[prog->stack_count-2].function;
387 oldsp = prog->stack[prog->stack_count-2].localsp;
390 prev = prog->stack[prog->stack_count-1].function;
391 oldsp = prog->stack[prog->stack_count-1].localsp;
394 qcint *globals = prog->globals + prev->firstlocal;
395 memcpy(globals, prog->localstack + oldsp, prev->locals);
396 if (!qc_program_localstack_resize(prog, oldsp)) {
397 printf("out of memory\n");
402 if (!qc_program_stack_remove(prog, prog->stack_count-1)) {
403 printf("out of memory\n");
410 bool prog_exec(qc_program *prog, prog_section_function *func, size_t flags, long maxjumps)
413 prog_section_statement *st;
415 st = prog->code + prog_enterfunction(prog, func);
422 #define QCVM_PROFILE 0
424 # include "execloop.h"
429 #define QCVM_PROFILE 0
431 # include "execloop.h"
436 #define QCVM_PROFILE 1
438 # include "execloop.h"
441 case (VMXF_TRACE|VMXF_PROFILE):
443 #define QCVM_PROFILE 1
445 # include "execloop.h"
451 prog->localstack_count = 0;
452 prog->stack_count = 0;
456 /***********************************************************************
457 * main for when building the standalone executor
460 #if defined(QCVM_EXECUTOR)
461 static int qc_print(qc_program *prog)
463 qcany *str = (qcany*)(prog->globals + OFS_PARM0);
464 printf("%s", prog_getstring(prog, str->string));
468 static prog_builtin qc_builtins[] = {
472 static size_t qc_builtins_count = sizeof(qc_builtins) / sizeof(qc_builtins[0]);
474 int main(int argc, char **argv)
481 printf("usage: %s file\n", argv[0]);
485 prog = prog_load(argv[1]);
487 printf("failed to load program '%s'\n", argv[1]);
491 prog->builtins = qc_builtins;
492 prog->builtins_count = qc_builtins_count;
493 prog->builtins_alloc = 0;
495 for (i = 1; i < prog->functions_count; ++i) {
496 const char *name = prog_getstring(prog, prog->functions[i].name);
497 printf("Found function: %s\n", name);
498 if (!strcmp(name, "main"))
503 prog_exec(prog, &prog->functions[fnmain], VMXF_TRACE, VM_JUMPS_DEFAULT);
506 printf("No main function found\n");