8 MEM_VEC_FUNCTIONS(qc_program, prog_section_statement, code)
9 MEM_VEC_FUNCTIONS(qc_program, prog_section_def, defs)
10 MEM_VEC_FUNCTIONS(qc_program, prog_section_def, fields)
11 MEM_VEC_FUNCTIONS(qc_program, prog_section_function, functions)
12 MEM_VEC_FUNCTIONS(qc_program, char, strings)
13 MEM_VEC_FUN_APPEND(qc_program, char, strings)
14 MEM_VEC_FUN_RESIZE(qc_program, char, strings)
15 MEM_VEC_FUNCTIONS(qc_program, qcint, globals)
16 MEM_VEC_FUNCTIONS(qc_program, qcint, entitydata)
17 MEM_VEC_FUNCTIONS(qc_program, bool, entitypool)
19 MEM_VEC_FUNCTIONS(qc_program, qcint, localstack)
20 MEM_VEC_FUN_APPEND(qc_program, qcint, localstack)
21 MEM_VEC_FUN_RESIZE(qc_program, qcint, localstack)
22 MEM_VEC_FUNCTIONS(qc_program, qc_exec_stack, stack)
24 MEM_VEC_FUNCTIONS(qc_program, size_t, profile)
25 MEM_VEC_FUN_RESIZE(qc_program, size_t, profile)
27 MEM_VEC_FUNCTIONS(qc_program, prog_builtin, builtins)
29 static void loaderror(const char *fmt, ...)
36 printf(": %s\n", strerror(err));
39 static void qcvmerror(qc_program *prog, const char *fmt, ...)
51 qc_program* prog_load(const char *filename)
58 file = util_fopen(filename, "rb");
62 if (fread(&header, sizeof(header), 1, file) != 1) {
63 loaderror("failed to read header from '%s'", filename);
68 if (header.version != 6) {
69 loaderror("header says this is a version %i progs, we need version 6\n", header.version);
74 prog = (qc_program*)mem_a(sizeof(qc_program));
77 printf("failed to allocate program data\n");
80 memset(prog, 0, sizeof(*prog));
82 prog->entityfields = header.entfield;
83 prog->crc16 = header.crc16;
85 prog->filename = util_strdup(filename);
86 if (!prog->filename) {
87 loaderror("failed to store program name");
91 #define read_data(hdrvar, progvar, type) \
92 if (fseek(file, header.hdrvar.offset, SEEK_SET) != 0) { \
93 loaderror("seek failed"); \
96 prog->progvar##_alloc = header.hdrvar.length; \
97 prog->progvar##_count = header.hdrvar.length; \
98 prog->progvar = (type*)mem_a(header.hdrvar.length * sizeof(*prog->progvar)); \
101 if (fread(prog->progvar, sizeof(*prog->progvar), header.hdrvar.length, file) \
102 != header.hdrvar.length) { \
103 loaderror("read failed"); \
106 #define read_data1(x, y) read_data(x, x, y)
108 read_data (statements, code, prog_section_statement);
109 read_data1(defs, prog_section_def);
110 read_data1(fields, prog_section_def);
111 read_data1(functions, prog_section_function);
112 read_data1(strings, char);
113 read_data1(globals, qcint);
117 /* profile counters */
118 if (!qc_program_profile_resize(prog, prog->code_count))
121 /* Add tempstring area */
122 prog->tempstring_start = prog->strings_count;
123 prog->tempstring_at = prog->strings_count;
124 if (!qc_program_strings_resize(prog, prog->strings_count + 16*1024))
127 /* spawn the world entity */
128 if (!qc_program_entitypool_add(prog, true)) {
129 loaderror("failed to allocate world entity\n");
132 for (i = 0; i < prog->entityfields; ++i) {
133 if (!qc_program_entitydata_add(prog, 0)) {
134 loaderror("failed to allocate world data\n");
143 if (prog->filename) mem_d(prog->filename);
144 if (prog->code) mem_d(prog->code);
145 if (prog->defs) mem_d(prog->defs);
146 if (prog->fields) mem_d(prog->fields);
147 if (prog->functions) mem_d(prog->functions);
148 if (prog->strings) mem_d(prog->strings);
149 if (prog->globals) mem_d(prog->globals);
150 if (prog->entitydata) mem_d(prog->entitydata);
151 if (prog->entitypool) mem_d(prog->entitypool);
156 void prog_delete(qc_program *prog)
158 if (prog->filename) mem_d(prog->filename);
159 MEM_VECTOR_CLEAR(prog, code);
160 MEM_VECTOR_CLEAR(prog, defs);
161 MEM_VECTOR_CLEAR(prog, fields);
162 MEM_VECTOR_CLEAR(prog, functions);
163 MEM_VECTOR_CLEAR(prog, strings);
164 MEM_VECTOR_CLEAR(prog, globals);
165 MEM_VECTOR_CLEAR(prog, entitydata);
166 MEM_VECTOR_CLEAR(prog, entitypool);
167 MEM_VECTOR_CLEAR(prog, localstack);
168 MEM_VECTOR_CLEAR(prog, stack);
169 MEM_VECTOR_CLEAR(prog, profile);
171 if (prog->builtins_alloc) {
172 MEM_VECTOR_CLEAR(prog, builtins);
174 /* otherwise the builtins were statically allocated */
178 /***********************************************************************
182 char* prog_getstring(qc_program *prog, qcint str)
184 if (str < 0 || str >= prog->strings_count)
185 return "<<<invalid string>>>";
186 return prog->strings + str;
189 prog_section_def* prog_entfield(qc_program *prog, qcint off)
192 for (i = 0; i < prog->fields_count; ++i) {
193 if (prog->fields[i].offset == off)
194 return (prog->fields + i);
199 prog_section_def* prog_getdef(qc_program *prog, qcint off)
202 for (i = 0; i < prog->defs_count; ++i) {
203 if (prog->defs[i].offset == off)
204 return (prog->defs + i);
209 qcany* prog_getedict(qc_program *prog, qcint e)
211 if (e >= prog->entitypool_count) {
213 printf("Accessing out of bounds edict %i\n", (int)e);
216 return (qcany*)(prog->entitydata + (prog->entityfields * e));
219 qcint prog_spawn_entity(qc_program *prog)
224 for (e = 0; e < (qcint)prog->entitypool_count; ++e) {
225 if (!prog->entitypool[e]) {
226 data = (char*)(prog->entitydata + (prog->entityfields * e));
227 memset(data, 0, prog->entityfields * sizeof(qcint));
231 if (!qc_program_entitypool_add(prog, true)) {
233 printf("Failed to allocate entity\n");
237 for (i = 0; i < prog->entityfields; ++i) {
238 if (!qc_program_entitydata_add(prog, 0)) {
239 printf("Failed to allocate entity\n");
243 data = (char*)(prog->entitydata + (prog->entityfields * e));
244 memset(data, 0, prog->entityfields * sizeof(qcint));
248 void prog_free_entity(qc_program *prog, qcint e)
252 printf("Trying to free world entity\n");
255 if (e >= prog->entitypool_count) {
257 printf("Trying to free out of bounds entity\n");
260 if (!prog->entitypool[e]) {
262 printf("Double free on entity\n");
265 prog->entitypool[e] = false;
268 qcint prog_tempstring(qc_program *prog, const char *_str)
270 /* we don't access it, but the macro-generated functions don't use
273 char *str = (char*)_str;
275 size_t len = strlen(str);
276 size_t at = prog->tempstring_at;
278 /* when we reach the end we start over */
279 if (at + len >= prog->strings_count)
280 at = prog->tempstring_start;
282 /* when it doesn't fit, reallocate */
283 if (at + len >= prog->strings_count)
285 prog->strings_count = at;
286 if (!qc_program_strings_append(prog, str, len+1)) {
287 prog->vmerror = VMERR_TEMPSTRING_ALLOC;
293 /* when it fits, just copy */
294 memcpy(prog->strings + at, str, len+1);
295 prog->tempstring_at += len+1;
299 static int print_escaped_string(const char *str)
305 case '\a': len += 2; putchar('\\'); putchar('a'); break;
306 case '\b': len += 2; putchar('\\'); putchar('b'); break;
307 case '\r': len += 2; putchar('\\'); putchar('r'); break;
308 case '\n': len += 2; putchar('\\'); putchar('n'); break;
309 case '\t': len += 2; putchar('\\'); putchar('t'); break;
310 case '\f': len += 2; putchar('\\'); putchar('f'); break;
311 case '\v': len += 2; putchar('\\'); putchar('v'); break;
312 case '\\': len += 2; putchar('\\'); putchar('\\'); break;
313 case '"': len += 2; putchar('\\'); putchar('"'); break;
325 static void trace_print_global(qc_program *prog, unsigned int glob, int vtype)
327 static char spaces[40+1] = " ";
328 prog_section_def *def;
333 len = printf("<null>,");
337 def = prog_getdef(prog, glob);
338 value = (qcany*)(&prog->globals[glob]);
341 const char *name = prog_getstring(prog, def->name);
345 len = printf("%s ", name);
349 len = printf("[@%u] ", glob);
357 len += printf("(%i),", value->_int);
360 len += printf("'%g %g %g',", value->vector[0],
365 len += print_escaped_string(prog_getstring(prog, value->string));
367 /* len += printf("\"%s\",", prog_getstring(prog, value->string)); */
371 len += printf("%g,", value->_float);
375 if (len < sizeof(spaces)-1) {
376 spaces[sizeof(spaces)-1-len] = 0;
378 spaces[sizeof(spaces)-1-len] = ' ';
382 static void prog_print_statement(qc_program *prog, prog_section_statement *st)
384 if (st->opcode >= (sizeof(asm_instr)/sizeof(asm_instr[0]))) {
385 printf("<illegal instruction %d>\n", st->opcode);
388 printf(" <> %-12s", asm_instr[st->opcode].m);
389 if (st->opcode >= INSTR_IF &&
390 st->opcode <= INSTR_IFNOT)
392 trace_print_global(prog, st->o1.u1, TYPE_FLOAT);
393 printf("%d\n", st->o2.s1);
395 else if (st->opcode >= INSTR_CALL0 &&
396 st->opcode <= INSTR_CALL8)
400 else if (st->opcode == INSTR_GOTO)
402 printf("%i\n", st->o1.s1);
406 int t[3] = { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT };
410 t[1] = t[2] = TYPE_VECTOR;
413 t[0] = t[2] = TYPE_VECTOR;
416 t[0] = t[1] = TYPE_VECTOR;
422 t[0] = t[1] = t[2] = TYPE_VECTOR;
426 t[0] = t[1] = TYPE_STRING;
433 t[0] = t[1] = TYPE_VECTOR; t[2] = -1;
436 t[0] = t[1] = TYPE_STRING; t[2] = -1;
438 case INSTR_STORE_ENT:
439 t[0] = t[1] = TYPE_ENTITY; t[2] = -1;
441 case INSTR_STORE_FLD:
442 t[0] = t[1] = TYPE_FIELD; t[2] = -1;
444 case INSTR_STORE_FNC:
445 t[0] = t[1] = TYPE_FUNCTION; t[2] = -1;
448 t[0] = TYPE_VECTOR; t[1] = TYPE_ENTITY; t[2] = -1;
451 t[0] = TYPE_STRING; t[1] = TYPE_ENTITY; t[2] = -1;
453 case INSTR_STOREP_ENT:
454 t[0] = TYPE_ENTITY; t[1] = TYPE_ENTITY; t[2] = -1;
456 case INSTR_STOREP_FLD:
457 t[0] = TYPE_FIELD; t[1] = TYPE_ENTITY; t[2] = -1;
459 case INSTR_STOREP_FNC:
460 t[0] = TYPE_FUNCTION; t[1] = TYPE_ENTITY; t[2] = -1;
463 if (t[0] >= 0) trace_print_global(prog, st->o1.u1, t[0]);
464 else printf("(none), ");
465 if (t[1] >= 0) trace_print_global(prog, st->o2.u1, t[1]);
466 else printf("(none), ");
467 if (t[2] >= 0) trace_print_global(prog, st->o3.u1, t[2]);
468 else printf("(none)");
474 static qcint prog_enterfunction(qc_program *prog, prog_section_function *func)
480 st.localsp = prog->localstack_count;
481 st.stmt = prog->statement;
484 #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
485 if (prog->stack_count)
487 prog_section_function *cur;
488 cur = prog->stack[prog->stack_count-1].function;
491 qcint *globals = prog->globals + cur->firstlocal;
492 if (!qc_program_localstack_append(prog, globals, cur->locals))
494 printf("out of memory\n");
501 qcint *globals = prog->globals + func->firstlocal;
502 if (!qc_program_localstack_append(prog, globals, func->locals))
504 printf("out of memory\n");
510 /* copy parameters */
511 parampos = func->firstlocal;
512 for (p = 0; p < func->nargs; ++p)
515 for (s = 0; s < func->argsize[p]; ++s) {
516 prog->globals[parampos] = prog->globals[OFS_PARM0 + 3*p + s];
521 if (!qc_program_stack_add(prog, st)) {
522 printf("out of memory\n");
529 static qcint prog_leavefunction(qc_program *prog)
531 prog_section_function *prev = NULL;
534 qc_exec_stack st = prog->stack[prog->stack_count-1];
536 #ifdef QCVM_BACKUP_STRATEGY_CALLER_VARS
537 if (prog->stack_count > 1) {
538 prev = prog->stack[prog->stack_count-2].function;
539 oldsp = prog->stack[prog->stack_count-2].localsp;
542 prev = prog->stack[prog->stack_count-1].function;
543 oldsp = prog->stack[prog->stack_count-1].localsp;
546 qcint *globals = prog->globals + prev->firstlocal;
547 memcpy(globals, prog->localstack + oldsp, prev->locals);
548 if (!qc_program_localstack_resize(prog, oldsp)) {
549 printf("out of memory\n");
554 if (!qc_program_stack_remove(prog, prog->stack_count-1)) {
555 printf("out of memory\n");
559 return st.stmt - 1; /* offset the ++st */
562 bool prog_exec(qc_program *prog, prog_section_function *func, size_t flags, long maxjumps)
565 size_t oldxflags = prog->xflags;
566 prog_section_statement *st;
569 prog->xflags = flags;
571 st = prog->code + prog_enterfunction(prog, func);
578 #define QCVM_PROFILE 0
580 # include "execloop.h"
585 #define QCVM_PROFILE 0
587 # include "execloop.h"
592 #define QCVM_PROFILE 1
594 # include "execloop.h"
597 case (VMXF_TRACE|VMXF_PROFILE):
599 #define QCVM_PROFILE 1
601 # include "execloop.h"
607 prog->xflags = oldxflags;
608 prog->localstack_count = 0;
609 prog->stack_count = 0;
615 /***********************************************************************
616 * main for when building the standalone executor
619 #if defined(QCVM_EXECUTOR)
622 const char *type_name[TYPE_COUNT] = {
637 bool opts_debug = false;
638 bool opts_memchk = false;
640 #define CheckArgs(num) do { \
641 if (prog->argc != (num)) { \
643 printf("ERROR: invalid number of arguments for %s: %i, expected %i\n", \
644 __FUNCTION__, prog->argc, (num)); \
649 #define GetGlobal(idx) ((qcany*)(prog->globals + (idx)))
650 #define GetArg(num) GetGlobal(OFS_PARM0 + 3*(num))
651 #define Return(any) *(GetGlobal(OFS_RETURN)) = (any)
653 static int qc_print(qc_program *prog)
656 const char *laststr = NULL;
657 for (i = 0; i < prog->argc; ++i) {
658 qcany *str = (qcany*)(prog->globals + OFS_PARM0 + 3*i);
659 printf("%s", (laststr = prog_getstring(prog, str->string)));
661 if (laststr && (prog->xflags & VMXF_TRACE)) {
662 size_t len = strlen(laststr);
663 if (!len || laststr[len-1] != '\n')
669 static int qc_error(qc_program *prog)
671 printf("*** VM raised an error:\n");
677 static int qc_ftos(qc_program *prog)
684 snprintf(buffer, sizeof(buffer), "%g", num->_float);
685 str.string = prog_tempstring(prog, buffer);
690 static int qc_vtos(qc_program *prog)
697 snprintf(buffer, sizeof(buffer), "`%g %g %g`", num->vector[0], num->vector[1], num->vector[2]);
698 str.string = prog_tempstring(prog, buffer);
703 static int qc_spawn(qc_program *prog)
707 ent.edict = prog_spawn_entity(prog);
709 return (ent.edict ? 0 : -1);
712 static int qc_kill(qc_program *prog)
717 prog_free_entity(prog, ent->edict);
721 static int qc_vlen(qc_program *prog)
726 len._float = sqrt(vec->vector[0] * vec->vector[0] +
727 vec->vector[1] * vec->vector[1] +
728 vec->vector[2] * vec->vector[2]);
733 static prog_builtin qc_builtins[] = {
743 static size_t qc_builtins_count = sizeof(qc_builtins) / sizeof(qc_builtins[0]);
745 static const char *arg0 = NULL;
749 printf("usage: [-debug] %s file\n", arg0);
753 int main(int argc, char **argv)
758 size_t xflags = VMXF_DEFAULT;
759 bool opts_printfields = false;
760 bool opts_printdefs = false;
761 bool opts_info = false;
769 if (!strcmp(argv[1], "-trace")) {
772 xflags |= VMXF_TRACE;
774 else if (!strcmp(argv[1], "-profile")) {
777 xflags |= VMXF_PROFILE;
779 else if (!strcmp(argv[1], "-info")) {
784 else if (!strcmp(argv[1], "-printdefs")) {
787 opts_printdefs = true;
789 else if (!strcmp(argv[1], "-printfields")) {
792 opts_printfields = true;
799 prog = prog_load(argv[1]);
801 printf("failed to load program '%s'\n", argv[1]);
805 prog->builtins = qc_builtins;
806 prog->builtins_count = qc_builtins_count;
807 prog->builtins_alloc = 0;
809 printf("Program's system-checksum = 0x%04x\n", (int)prog->crc16);
811 for (i = 1; i < prog->functions_count; ++i) {
812 const char *name = prog_getstring(prog, prog->functions[i].name);
813 /* printf("Found function: %s\n", name); */
814 if (!strcmp(name, "main"))
817 printf("Entity field space: %i\n", (int)prog->entityfields);
822 if (opts_printdefs) {
823 for (i = 0; i < prog->defs_count; ++i) {
824 printf("Global: %8s %-16s at %u\n",
825 type_name[prog->defs[i].type],
826 prog_getstring(prog, prog->defs[i].name),
827 (unsigned int)prog->defs[i].offset);
830 else if (opts_printfields) {
831 for (i = 0; i < prog->fields_count; ++i) {
832 printf("Field: %8s %-16s at %u\n",
833 type_name[prog->fields[i].type],
834 prog_getstring(prog, prog->fields[i].name),
835 (unsigned int)prog->fields[i].offset);
842 prog_exec(prog, &prog->functions[fnmain], xflags, VM_JUMPS_DEFAULT);
845 printf("No main function found\n");