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 int print_escaped_string(const char *str)
220 case '\a': len += 2; putchar('\\'); putchar('a'); break;
221 case '\b': len += 2; putchar('\\'); putchar('b'); break;
222 case '\r': len += 2; putchar('\\'); putchar('r'); break;
223 case '\n': len += 2; putchar('\\'); putchar('n'); break;
224 case '\t': len += 2; putchar('\\'); putchar('t'); break;
225 case '\f': len += 2; putchar('\\'); putchar('f'); break;
226 case '\v': len += 2; putchar('\\'); putchar('v'); break;
227 case '\\': len += 2; putchar('\\'); putchar('\\'); break;
228 case '"': len += 2; putchar('\\'); putchar('"'); break;
240 static void trace_print_global(qc_program *prog, unsigned int glob, int vtype)
242 static char spaces[16+1] = " ";
243 prog_section_def *def;
250 def = prog_getdef(prog, glob);
251 value = (qcany*)(&prog->globals[glob]);
254 len = printf("[%s] ", prog_getstring(prog, def->name));
258 len = printf("[#%u] ", glob);
266 len += printf("%i,", value->_int);
269 len += printf("'%g %g %g',", value->vector[0],
274 len += print_escaped_string(prog_getstring(prog, value->string));
275 /* len += printf("\"%s\",", prog_getstring(prog, value->string)); */
279 len += printf("%g,", value->_float);
285 spaces[16-len] = ' ';
289 static void prog_print_statement(qc_program *prog, prog_section_statement *st)
291 if (st->opcode >= (sizeof(asm_instr)/sizeof(asm_instr[0]))) {
292 printf("<illegal instruction %d>\n", st->opcode);
295 printf(" <> %-12s", asm_instr[st->opcode].m);
296 if (st->opcode >= INSTR_IF &&
297 st->opcode <= INSTR_IFNOT)
299 trace_print_global(prog, st->o1.u1, TYPE_FLOAT);
300 printf("%d\n", st->o2.s1);
302 else if (st->opcode >= INSTR_CALL0 &&
303 st->opcode <= INSTR_CALL8)
307 else if (st->opcode == INSTR_GOTO)
309 printf("%i\n", st->o1.s1);
313 int t[3] = { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT };
317 t[1] = t[2] = TYPE_VECTOR;
320 t[0] = t[2] = TYPE_VECTOR;
323 t[0] = t[1] = TYPE_VECTOR;
329 t[0] = t[1] = t[2] = TYPE_VECTOR;
333 t[0] = t[1] = TYPE_STRING;
336 t[0] = t[1] = TYPE_VECTOR; t[2] = -1;
339 t[0] = t[1] = TYPE_STRING; t[2] = -1;
342 if (t[0] >= 0) trace_print_global(prog, st->o1.u1, t[0]);
343 if (t[1] >= 0) trace_print_global(prog, st->o2.u1, t[1]);
344 if (t[2] >= 0) trace_print_global(prog, st->o3.u1, t[2]);
349 static qcint prog_enterfunction(qc_program *prog, prog_section_function *func)
355 st.localsp = prog->localstack_count;
356 st.stmt = prog->statement;
359 #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
360 if (prog->stack_count)
362 prog_section_function *cur;
363 cur = prog->stack[prog->stack_count-1].function;
366 qcint *globals = prog->globals + cur->firstlocal;
367 if (!qc_program_localstack_append(prog, globals, cur->locals))
369 printf("out of memory\n");
376 qcint *globals = prog->globals + func->firstlocal;
377 if (!qc_program_localstack_append(prog, globals, func->locals))
379 printf("out of memory\n");
385 /* copy parameters */
386 parampos = func->firstlocal;
387 for (p = 0; p < func->nargs; ++p)
390 for (s = 0; s < func->argsize[p]; ++s) {
391 prog->globals[parampos] = prog->globals[OFS_PARM0 + 3*p + s];
396 if (!qc_program_stack_add(prog, st)) {
397 printf("out of memory\n");
404 static qcint prog_leavefunction(qc_program *prog)
406 prog_section_function *prev = NULL;
409 qc_exec_stack st = prog->stack[prog->stack_count-1];
411 #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
412 if (prog->stack_count > 1) {
413 prev = prog->stack[prog->stack_count-2].function;
414 oldsp = prog->stack[prog->stack_count-2].localsp;
417 prev = prog->stack[prog->stack_count-1].function;
418 oldsp = prog->stack[prog->stack_count-1].localsp;
421 qcint *globals = prog->globals + prev->firstlocal;
422 memcpy(globals, prog->localstack + oldsp, prev->locals);
423 if (!qc_program_localstack_resize(prog, oldsp)) {
424 printf("out of memory\n");
429 if (!qc_program_stack_remove(prog, prog->stack_count-1)) {
430 printf("out of memory\n");
437 bool prog_exec(qc_program *prog, prog_section_function *func, size_t flags, long maxjumps)
440 prog_section_statement *st;
442 st = prog->code + prog_enterfunction(prog, func);
449 #define QCVM_PROFILE 0
451 # include "execloop.h"
456 #define QCVM_PROFILE 0
458 # include "execloop.h"
463 #define QCVM_PROFILE 1
465 # include "execloop.h"
468 case (VMXF_TRACE|VMXF_PROFILE):
470 #define QCVM_PROFILE 1
472 # include "execloop.h"
478 prog->localstack_count = 0;
479 prog->stack_count = 0;
483 /***********************************************************************
484 * main for when building the standalone executor
487 #if defined(QCVM_EXECUTOR)
488 bool opts_debug = false;
489 bool opts_memchk = false;
491 static int qc_print(qc_program *prog)
493 qcany *str = (qcany*)(prog->globals + OFS_PARM0);
494 printf("%s", prog_getstring(prog, str->string));
498 static prog_builtin qc_builtins[] = {
502 static size_t qc_builtins_count = sizeof(qc_builtins) / sizeof(qc_builtins[0]);
504 int main(int argc, char **argv)
511 printf("usage: %s file\n", argv[0]);
515 prog = prog_load(argv[1]);
517 printf("failed to load program '%s'\n", argv[1]);
521 prog->builtins = qc_builtins;
522 prog->builtins_count = qc_builtins_count;
523 prog->builtins_alloc = 0;
525 for (i = 1; i < prog->functions_count; ++i) {
526 const char *name = prog_getstring(prog, prog->functions[i].name);
527 printf("Found function: %s\n", name);
528 if (!strcmp(name, "main"))
533 prog_exec(prog, &prog->functions[fnmain], VMXF_TRACE, VM_JUMPS_DEFAULT);
536 printf("No main function found\n");