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 static void loaderror(const char *fmt, ...)
32 printf(": %s\n", strerror(err));
35 qc_program* prog_load(const char *filename)
41 file = fopen(filename, "rb");
45 if (fread(&header, sizeof(header), 1, file) != 1) {
46 loaderror("failed to read header from '%s'", filename);
51 if (header.version != 6) {
52 loaderror("header says this is a version %i progs, we need version 6\n", header.version);
57 prog = (qc_program*)mem_a(sizeof(qc_program));
60 printf("failed to allocate program data\n");
63 memset(prog, 0, sizeof(*prog));
65 prog->entityfields = header.entfield;
67 prog->filename = util_strdup(filename);
68 if (!prog->filename) {
69 loaderror("failed to store program name");
73 #define read_data(hdrvar, progvar, type) \
74 if (fseek(file, header.hdrvar.offset, SEEK_SET) != 0) { \
75 loaderror("seek failed"); \
78 prog->progvar##_alloc = header.hdrvar.length; \
79 prog->progvar##_count = header.hdrvar.length; \
80 prog->progvar = (type*)mem_a(header.hdrvar.length * sizeof(*prog->progvar)); \
83 if (fread(prog->progvar, sizeof(*prog->progvar), header.hdrvar.length, file) \
84 != header.hdrvar.length) { \
85 loaderror("read failed"); \
88 #define read_data1(x, y) read_data(x, x, y)
90 read_data (statements, code, prog_section_statement);
91 read_data1(defs, prog_section_def);
92 read_data1(fields, prog_section_def);
93 read_data1(functions, prog_section_function);
94 read_data1(strings, char);
95 read_data1(globals, qcint);
99 /* profile counters */
100 if (!qc_program_profile_resize(prog, prog->code_count))
103 /* Add tempstring area */
104 prog->tempstring_start = prog->strings_count;
105 prog->tempstring_at = prog->strings_count;
106 if (!qc_program_strings_resize(prog, prog->strings_count + 16*1024))
112 if (prog->filename) mem_d(prog->filename);
113 if (prog->code) mem_d(prog->code);
114 if (prog->defs) mem_d(prog->defs);
115 if (prog->fields) mem_d(prog->fields);
116 if (prog->functions) mem_d(prog->functions);
117 if (prog->strings) mem_d(prog->strings);
118 if (prog->globals) mem_d(prog->globals);
119 if (prog->entitydata) mem_d(prog->entitydata);
124 void prog_delete(qc_program *prog)
126 if (prog->filename) mem_d(prog->filename);
127 MEM_VECTOR_CLEAR(prog, code);
128 MEM_VECTOR_CLEAR(prog, defs);
129 MEM_VECTOR_CLEAR(prog, fields);
130 MEM_VECTOR_CLEAR(prog, functions);
131 MEM_VECTOR_CLEAR(prog, strings);
132 MEM_VECTOR_CLEAR(prog, globals);
133 MEM_VECTOR_CLEAR(prog, entitydata);
134 MEM_VECTOR_CLEAR(prog, localstack);
135 MEM_VECTOR_CLEAR(prog, stack);
136 MEM_VECTOR_CLEAR(prog, profile);
140 /***********************************************************************
144 char* prog_getstring(qc_program *prog, qcint str)
146 if (str < 0 || str >= prog->strings_count)
147 return "<<<invalid string>>>";
148 return prog->strings + str;
151 prog_section_def* prog_entfield(qc_program *prog, qcint off)
154 for (i = 0; i < prog->fields_count; ++i) {
155 if (prog->fields[i].offset == off)
156 return (prog->fields + i);
161 prog_section_def* prog_getdef(qc_program *prog, qcint off)
164 for (i = 0; i < prog->defs_count; ++i) {
165 if (prog->defs[i].offset == off)
166 return (prog->defs + i);
171 qcany* prog_getedict(qc_program *prog, qcint e)
173 return (qcany*)(prog->entitydata + (prog->entityfields + e));
176 qcint prog_tempstring(qc_program *prog, const char *_str)
178 /* we don't access it, but the macro-generated functions don't use
181 char *str = (char*)_str;
183 size_t len = strlen(str);
184 size_t at = prog->tempstring_at;
186 /* when we reach the end we start over */
187 if (at + len >= prog->strings_count)
188 at = prog->tempstring_start;
190 /* when it doesn't fit, reallocate */
191 if (at + len >= prog->strings_count)
193 prog->strings_count = at;
194 if (!qc_program_strings_append(prog, str, len+1)) {
195 prog->vmerror = VMERR_TEMPSTRING_ALLOC;
201 /* when it fits, just copy */
202 memcpy(prog->strings + at, str, len+1);
203 prog->tempstring_at += len+1;
207 static void trace_print_global(qc_program *prog, unsigned int glob, int vtype)
209 static char spaces[16+1] = " ";
210 prog_section_def *def;
217 def = prog_getdef(prog, glob);
218 value = (qcany*)(&prog->globals[glob]);
221 len = printf("[%s] ", prog_getstring(prog, def->name));
225 len = printf("[#%u] ", glob);
233 len += printf("%i,", value->_int);
236 len += printf("'%g %g %g',", value->vector[0],
241 len += printf("\"%s\",", prog_getstring(prog, value->string));
245 len += printf("%g,", value->_float);
251 spaces[16-len] = ' ';
255 static void prog_print_statement(qc_program *prog, prog_section_statement *st)
257 if (st->opcode >= (sizeof(asm_instr)/sizeof(asm_instr[0]))) {
258 printf("<illegal instruction %d>\n", st->opcode);
261 printf("%-12s", asm_instr[st->opcode].m);
262 if (st->opcode >= INSTR_IF &&
263 st->opcode <= INSTR_IFNOT)
265 trace_print_global(prog, st->o1.u1, TYPE_FLOAT);
266 printf("%d\n", st->o2.s1);
268 else if (st->opcode >= INSTR_CALL0 &&
269 st->opcode <= INSTR_CALL8)
273 else if (st->opcode == INSTR_GOTO)
275 printf("%i\n", st->o1.s1);
279 int t[3] = { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT };
283 t[1] = t[2] = TYPE_VECTOR;
286 t[0] = t[2] = TYPE_VECTOR;
289 t[0] = t[1] = TYPE_VECTOR;
295 t[0] = t[1] = t[2] = TYPE_VECTOR;
299 t[0] = t[1] = TYPE_STRING;
302 t[0] = t[1] = TYPE_VECTOR; t[2] = -1;
305 t[0] = t[1] = TYPE_STRING; t[2] = -1;
308 if (t[0] >= 0) trace_print_global(prog, st->o1.u1, t[0]);
309 if (t[1] >= 0) trace_print_global(prog, st->o2.u1, t[1]);
310 if (t[2] >= 0) trace_print_global(prog, st->o3.u1, t[2]);
315 static qcint prog_enterfunction(qc_program *prog, prog_section_function *func)
321 st.localsp = prog->localstack_count;
322 st.stmt = prog->statement;
325 #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
326 if (prog->stack_count)
328 prog_section_function *cur;
329 cur = prog->stack[prog->stack_count-1].function;
332 qcint *globals = prog->globals + cur->firstlocal;
333 if (!qc_program_localstack_append(prog, globals, cur->locals))
335 printf("out of memory\n");
342 qcint *globals = prog->globals + func->firstlocal;
343 if (!qc_program_localstack_append(prog, globals, func->locals))
345 printf("out of memory\n");
351 /* copy parameters */
352 parampos = func->firstlocal;
353 for (p = 0; p < func->nargs; ++p)
356 for (s = 0; s < func->argsize[p]; ++s) {
357 prog->globals[parampos] = prog->globals[OFS_PARM0 + 3*p + s];
362 if (!qc_program_stack_add(prog, st)) {
363 printf("out of memory\n");
370 static qcint prog_leavefunction(qc_program *prog)
372 prog_section_function *prev = NULL;
375 qc_exec_stack st = prog->stack[prog->stack_count-1];
377 #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
378 if (prog->stack_count > 1) {
379 prev = prog->stack[prog->stack_count-2].function;
380 oldsp = prog->stack[prog->stack_count-2].localsp;
383 prev = prog->stack[prog->stack_count-1].function;
384 oldsp = prog->stack[prog->stack_count-1].localsp;
387 qcint *globals = prog->globals + prev->firstlocal;
388 memcpy(globals, prog->localstack + oldsp, prev->locals);
389 if (!qc_program_localstack_resize(prog, oldsp)) {
390 printf("out of memory\n");
395 if (!qc_program_stack_remove(prog, prog->stack_count-1)) {
396 printf("out of memory\n");
403 bool prog_exec(qc_program *prog, prog_section_function *func, size_t flags, long maxjumps)
406 prog_section_statement *st;
408 st = prog->code + prog_enterfunction(prog, func);
415 #define QCVM_PROFILE 0
417 # include "execloop.h"
422 #define QCVM_PROFILE 0
424 # include "execloop.h"
429 #define QCVM_PROFILE 1
431 # include "execloop.h"
434 case (VMXF_TRACE|VMXF_PROFILE):
436 #define QCVM_PROFILE 1
438 # include "execloop.h"
444 prog->localstack_count = 0;
445 prog->stack_count = 0;
449 /***********************************************************************
450 * main for when building the standalone executor
453 #if defined(QCVM_EXECUTOR)
454 int main(int argc, char **argv)
461 printf("usage: %s file\n", argv[0]);
465 prog = prog_load(argv[1]);
467 printf("failed to load program '%s'\n", argv[1]);
471 for (i = 1; i < prog->functions_count; ++i) {
472 const char *name = prog_getstring(prog, prog->functions[i].name);
473 printf("Found function: %s\n", name);
474 if (!strcmp(name, "main"))
479 prog_exec(prog, &prog->functions[fnmain], VMXF_TRACE, VM_JUMPS_DEFAULT);
482 printf("No main function found\n");