X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=exec.c;h=959f90b5d9ecf4d8c50a0ee9e1a17664662000fa;hp=7a6322be5d3a75bcd0ed4ea298d30cff7e1561f1;hb=96ec27966330f93223fbaa7c314660a85df40d2e;hpb=30eac57199629dc6b6603a18620026bae64f5f8f

diff --git a/exec.c b/exec.c
index 7a6322b..959f90b 100644
--- a/exec.c
+++ b/exec.c
@@ -26,6 +26,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
+#include <stdlib.h>
 
 #include "gmqcc.h"
 
@@ -36,7 +37,7 @@ static void loaderror(const char *fmt, ...)
     va_start(ap, fmt);
     vprintf(fmt, ap);
     va_end(ap);
-    printf(": %s\n", strerror(err));
+    printf(": %s\n", util_strerror(err));
 }
 
 static void qcvmerror(qc_program *prog, const char *fmt, ...)
@@ -51,31 +52,31 @@ static void qcvmerror(qc_program *prog, const char *fmt, ...)
     putchar('\n');
 }
 
-qc_program* prog_load(const char *filename)
+qc_program* prog_load(const char *filename, bool skipversion)
 {
     qc_program   *prog;
     prog_header   header;
-    FILE         *file   = file_open(filename, "rb");
+    FILE         *file  = fs_file_open(filename, "rb");
 
     if (!file)
         return NULL;
 
-    if (file_read(&header, sizeof(header), 1, file) != 1) {
+    if (fs_file_read(&header, sizeof(header), 1, file) != 1) {
         loaderror("failed to read header from '%s'", filename);
-        file_close(file);
+        fs_file_close(file);
         return NULL;
     }
 
-    if (header.version != 6) {
+    if (!skipversion && header.version != 6) {
         loaderror("header says this is a version %i progs, we need version 6\n", header.version);
-        file_close(file);
+        fs_file_close(file);
         return NULL;
     }
 
     prog = (qc_program*)mem_a(sizeof(qc_program));
     if (!prog) {
-        file_close(file);
-        printf("failed to allocate program data\n");
+        fs_file_close(file);
+        fprintf(stderr, "failed to allocate program data\n");
         return NULL;
     }
     memset(prog, 0, sizeof(*prog));
@@ -90,11 +91,11 @@ qc_program* prog_load(const char *filename)
     }
 
 #define read_data(hdrvar, progvar, reserved)                           \
-    if (file_seek(file, header.hdrvar.offset, SEEK_SET) != 0) {        \
+    if (fs_file_seek(file, header.hdrvar.offset, SEEK_SET) != 0) {        \
         loaderror("seek failed");                                      \
         goto error;                                                    \
     }                                                                  \
-    if (file_read (                                                    \
+    if (fs_file_read (                                                    \
             vec_add(prog->progvar, header.hdrvar.length + reserved),   \
             sizeof(*prog->progvar),                                    \
             header.hdrvar.length,                                      \
@@ -114,7 +115,7 @@ qc_program* prog_load(const char *filename)
     read_data1(strings);
     read_data2(globals, 2); /* reserve more in case a RETURN using with the global at "the end" exists */
 
-    file_close(file);
+    fs_file_close(file);
 
     /* profile counters */
     memset(vec_add(prog->profile, vec_size(prog->code)), 0, sizeof(prog->profile[0]) * vec_size(prog->code));
@@ -143,6 +144,8 @@ error:
     vec_free(prog->entitydata);
     vec_free(prog->entitypool);
     mem_d(prog);
+
+    fs_file_close(file);
     return NULL;
 }
 
@@ -167,16 +170,15 @@ void prog_delete(qc_program *prog)
  * VM code
  */
 
-char* prog_getstring(qc_program *prog, qcint str)
-{
+const char* prog_getstring(qc_program *prog, qcint str) {
     /* cast for return required for C++ */
     if (str < 0 || str >= (qcint)vec_size(prog->strings))
-        return (char*)"<<<invalid string>>>";
+        return  "<<<invalid string>>>";
+
     return prog->strings + str;
 }
 
-prog_section_def* prog_entfield(qc_program *prog, qcint off)
-{
+prog_section_def* prog_entfield(qc_program *prog, qcint off) {
     size_t i;
     for (i = 0; i < vec_size(prog->fields); ++i) {
         if (prog->fields[i].offset == off)
@@ -195,18 +197,16 @@ prog_section_def* prog_getdef(qc_program *prog, qcint off)
     return NULL;
 }
 
-qcany* prog_getedict(qc_program *prog, qcint e)
-{
+qcany* prog_getedict(qc_program *prog, qcint e) {
     if (e >= (qcint)vec_size(prog->entitypool)) {
         prog->vmerror++;
-        printf("Accessing out of bounds edict %i\n", (int)e);
+        fprintf(stderr, "Accessing out of bounds edict %i\n", (int)e);
         e = 0;
     }
     return (qcany*)(prog->entitydata + (prog->entityfields * e));
 }
 
-qcint prog_spawn_entity(qc_program *prog)
-{
+qcint prog_spawn_entity(qc_program *prog) {
     char  *data;
     qcint  e;
     for (e = 0; e < (qcint)vec_size(prog->entitypool); ++e) {
@@ -223,28 +223,26 @@ qcint prog_spawn_entity(qc_program *prog)
     return e;
 }
 
-void prog_free_entity(qc_program *prog, qcint e)
-{
+void prog_free_entity(qc_program *prog, qcint e) {
     if (!e) {
         prog->vmerror++;
-        printf("Trying to free world entity\n");
+        fprintf(stderr, "Trying to free world entity\n");
         return;
     }
     if (e >= (qcint)vec_size(prog->entitypool)) {
         prog->vmerror++;
-        printf("Trying to free out of bounds entity\n");
+        fprintf(stderr, "Trying to free out of bounds entity\n");
         return;
     }
     if (!prog->entitypool[e]) {
         prog->vmerror++;
-        printf("Double free on entity\n");
+        fprintf(stderr, "Double free on entity\n");
         return;
     }
     prog->entitypool[e] = false;
 }
 
-qcint prog_tempstring(qc_program *prog, const char *str)
-{
+qcint prog_tempstring(qc_program *prog, const char *str) {
     size_t len = strlen(str);
     size_t at = prog->tempstring_at;
 
@@ -266,8 +264,7 @@ qcint prog_tempstring(qc_program *prog, const char *str)
     return at;
 }
 
-static size_t print_escaped_string(const char *str, size_t maxlen)
-{
+static size_t print_escaped_string(const char *str, size_t maxlen) {
     size_t len = 2;
     putchar('"');
     --maxlen; /* because we're lazy and have escape sequences */
@@ -300,15 +297,16 @@ static size_t print_escaped_string(const char *str, size_t maxlen)
     return len;
 }
 
-static void trace_print_global(qc_program *prog, unsigned int glob, int vtype)
-{
+static void trace_print_global(qc_program *prog, unsigned int glob, int vtype) {
     static char spaces[28+1] = "                            ";
     prog_section_def *def;
     qcany    *value;
     int       len;
 
     if (!glob) {
-        len = printf("<null>,");
+        if ((len = printf("<null>,")) == -1)
+            len = 0;
+
         goto done;
     }
 
@@ -354,13 +352,12 @@ static void trace_print_global(qc_program *prog, unsigned int glob, int vtype)
 done:
     if (len < (int)sizeof(spaces)-1) {
         spaces[sizeof(spaces)-1-len] = 0;
-        file_puts(stdout, spaces);
+        fs_file_puts(stdout, spaces);
         spaces[sizeof(spaces)-1-len] = ' ';
     }
 }
 
-static void prog_print_statement(qc_program *prog, prog_section_statement *st)
-{
+static void prog_print_statement(qc_program *prog, prog_section_statement *st) {
     if (st->opcode >= (sizeof(asm_instr)/sizeof(asm_instr[0]))) {
         printf("<illegal instruction %d>\n", st->opcode);
         return;
@@ -455,11 +452,9 @@ static void prog_print_statement(qc_program *prog, prog_section_statement *st)
         else           printf("(none)");
         printf("\n");
     }
-    fflush(stdout);
 }
 
-static qcint prog_enterfunction(qc_program *prog, prog_section_function *func)
-{
+static qcint prog_enterfunction(qc_program *prog, prog_section_function *func) {
     qc_exec_stack st;
     size_t  parampos;
     int32_t p;
@@ -508,8 +503,7 @@ static qcint prog_enterfunction(qc_program *prog, prog_section_function *func)
     return func->entry;
 }
 
-static qcint prog_leavefunction(qc_program *prog)
-{
+static qcint prog_leavefunction(qc_program *prog) {
     prog_section_function *prev = NULL;
     size_t oldsp;
 
@@ -541,8 +535,7 @@ static qcint prog_leavefunction(qc_program *prog)
     return st.stmt - 1; /* offset the ++st */
 }
 
-bool prog_exec(qc_program *prog, prog_section_function *func, size_t flags, long maxjumps)
-{
+bool prog_exec(qc_program *prog, prog_section_function *func, size_t flags, long maxjumps) {
     long jumpcount = 0;
     size_t oldxflags = prog->xflags;
     prog_section_statement *st;
@@ -626,12 +619,12 @@ typedef struct {
     const char *value;
 } qcvm_parameter;
 
-qcvm_parameter *main_params = NULL;
+static qcvm_parameter *main_params = NULL;
 
 #define CheckArgs(num) do {                                                    \
     if (prog->argc != (num)) {                                                 \
         prog->vmerror++;                                                       \
-        printf("ERROR: invalid number of arguments for %s: %i, expected %i\n", \
+        fprintf(stderr, "ERROR: invalid number of arguments for %s: %i, expected %i\n", \
         __FUNCTION__, prog->argc, (num));                                      \
         return -1;                                                             \
     }                                                                          \
@@ -641,8 +634,7 @@ qcvm_parameter *main_params = NULL;
 #define GetArg(num) GetGlobal(OFS_PARM0 + 3*(num))
 #define Return(any) *(GetGlobal(OFS_RETURN)) = (any)
 
-static int qc_print(qc_program *prog)
-{
+static int qc_print(qc_program *prog) {
     size_t i;
     const char *laststr = NULL;
     for (i = 0; i < (size_t)prog->argc; ++i) {
@@ -658,66 +650,60 @@ static int qc_print(qc_program *prog)
     return 0;
 }
 
-static int qc_error(qc_program *prog)
-{
-    printf("*** VM raised an error:\n");
+static int qc_error(qc_program *prog) {
+    fprintf(stderr, "*** VM raised an error:\n");
     qc_print(prog);
     prog->vmerror++;
     return -1;
 }
 
-static int qc_ftos(qc_program *prog)
-{
+static int qc_ftos(qc_program *prog) {
     char buffer[512];
     qcany *num;
     qcany str;
     CheckArgs(1);
     num = GetArg(0);
-    snprintf(buffer, sizeof(buffer), "%g", num->_float);
+    util_snprintf(buffer, sizeof(buffer), "%g", num->_float);
     str.string = prog_tempstring(prog, buffer);
     Return(str);
     return 0;
 }
 
-static int qc_stof(qc_program *prog)
-{
+static int qc_stof(qc_program *prog) {
     qcany *str;
     qcany num;
     CheckArgs(1);
     str = GetArg(0);
-    num._float = strtof(prog_getstring(prog, str->string), NULL);
+    num._float = (float)strtod(prog_getstring(prog, str->string), NULL);
     Return(num);
     return 0;
 }
 
-static int qc_vtos(qc_program *prog)
-{
+static int qc_vtos(qc_program *prog) {
     char buffer[512];
     qcany *num;
     qcany str;
     CheckArgs(1);
     num = GetArg(0);
-    snprintf(buffer, sizeof(buffer), "'%g %g %g'", num->vector[0], num->vector[1], num->vector[2]);
+    util_snprintf(buffer, sizeof(buffer), "'%g %g %g'", num->vector[0], num->vector[1], num->vector[2]);
     str.string = prog_tempstring(prog, buffer);
     Return(str);
     return 0;
 }
 
-static int qc_etos(qc_program *prog)
-{
+static int qc_etos(qc_program *prog) {
     char buffer[512];
     qcany *num;
     qcany str;
     CheckArgs(1);
     num = GetArg(0);
-    snprintf(buffer, sizeof(buffer), "%i", num->_int);
+    util_snprintf(buffer, sizeof(buffer), "%i", num->_int);
     str.string = prog_tempstring(prog, buffer);
     Return(str);
     return 0;
 }
 
-static int qc_spawn(qc_program *prog)
-{
+static int qc_spawn(qc_program *prog) {
     qcany ent;
     CheckArgs(0);
     ent.edict = prog_spawn_entity(prog);
@@ -725,8 +711,7 @@ static int qc_spawn(qc_program *prog)
     return (ent.edict ? 0 : -1);
 }
 
-static int qc_kill(qc_program *prog)
-{
+static int qc_kill(qc_program *prog) {
     qcany *ent;
     CheckArgs(1);
     ent = GetArg(0);
@@ -734,8 +719,7 @@ static int qc_kill(qc_program *prog)
     return 0;
 }
 
-static int qc_sqrt(qc_program *prog)
-{
+static int qc_sqrt(qc_program *prog) {
     qcany *num, out;
     CheckArgs(1);
     num = GetArg(0);
@@ -744,8 +728,7 @@ static int qc_sqrt(qc_program *prog)
     return 0;
 }
 
-static int qc_vlen(qc_program *prog)
-{
+static int qc_vlen(qc_program *prog) {
     qcany *vec, len;
     CheckArgs(1);
     vec = GetArg(0);
@@ -756,8 +739,7 @@ static int qc_vlen(qc_program *prog)
     return 0;
 }
 
-static int qc_normalize(qc_program *prog)
-{
+static int qc_normalize(qc_program *prog) {
     double len;
     qcany *vec;
     qcany out;
@@ -777,14 +759,15 @@ static int qc_normalize(qc_program *prog)
     return 0;
 }
 
-static int qc_strcat(qc_program *prog)
-{
+static int qc_strcat(qc_program *prog) {
     char  *buffer;
     size_t len1,   len2;
-    char  *cstr1, *cstr2;
     qcany *str1,  *str2;
     qcany  out;
 
+    const char *cstr1;
+    const char *cstr2;
+
     CheckArgs(2);
     str1 = GetArg(0);
     str2 = GetArg(1);
@@ -801,14 +784,15 @@ static int qc_strcat(qc_program *prog)
     return 0;
 }
 
-static int qc_strcmp(qc_program *prog)
-{
-    char  *cstr1, *cstr2;
+static int qc_strcmp(qc_program *prog) {
     qcany *str1,  *str2;
     qcany out;
 
+    const char *cstr1;
+    const char *cstr2;
+
     if (prog->argc != 2 && prog->argc != 3) {
-        printf("ERROR: invalid number of arguments for strcmp/strncmp: %i, expected 2 or 3\n",
+        fprintf(stderr, "ERROR: invalid number of arguments for strcmp/strncmp: %i, expected 2 or 3\n",
                prog->argc);
         return -1;
     }
@@ -825,6 +809,15 @@ static int qc_strcmp(qc_program *prog)
     return 0;
 }
 
+static int qc_floor(qc_program *prog) {
+    qcany *num, out;
+    CheckArgs(1);
+    num = GetArg(0);
+    out._float = floor(num->_float);
+    Return(out);
+    return 0;
+}
+
 static prog_builtin qc_builtins[] = {
     NULL,
     &qc_print,       /*   1   */
@@ -839,13 +832,14 @@ static prog_builtin qc_builtins[] = {
     &qc_strcat,      /*   10  */
     &qc_strcmp,      /*   11  */
     &qc_normalize,   /*   12  */
-    &qc_sqrt         /*   13  */
+    &qc_sqrt,        /*   13  */
+    &qc_floor        /*   14  */
 };
 static size_t qc_builtins_count = sizeof(qc_builtins) / sizeof(qc_builtins[0]);
 
 static const char *arg0 = NULL;
 
-static void version() {
+static void version(void) {
     printf("GMQCC-QCVM %d.%d.%d Built %s %s\n",
            GMQCC_VERSION_MAJOR,
            GMQCC_VERSION_MINOR,
@@ -855,8 +849,7 @@ static void version() {
     );
 }
 
-static void usage()
-{
+static void usage(void) {
     printf("usage: %s [options] [parameters] file\n", arg0);
     printf("options:\n");
     printf("  -h, --help         print this message\n"
@@ -876,8 +869,7 @@ static void usage()
            "  -string <s>   pass a string parameter to main() \n");
 }
 
-static void prog_main_setparams(qc_program *prog)
-{
+static void prog_main_setparams(qc_program *prog) {
     size_t i;
     qcany *arg;
 
@@ -907,15 +899,41 @@ static void prog_main_setparams(qc_program *prog)
                 arg->string = prog_tempstring(prog, main_params[i].value);
                 break;
             default:
-                printf("error: unhandled parameter type: %i\n", main_params[i].vtype);
+                fprintf(stderr, "error: unhandled parameter type: %i\n", main_params[i].vtype);
                 break;
         }
     }
 }
 
+void escapestring(char* dest, const char* src)  {
+  char c;
+  while ((c = *(src++))) {
+    switch(c) {
+      case '\t':
+        *(dest++) = '\\', *(dest++) = 't';
+        break;
+      case '\n':
+        *(dest++) = '\\', *(dest++) = 'n';
+        break;
+      case '\r':
+        *(dest++) = '\\', *(dest++) = 'r';
+        break;
+      case '\\':
+        *(dest++) = '\\', *(dest++) = '\\';
+        break;
+      case '\"':
+        *(dest++) = '\\', *(dest++) = '\"';
+        break;
+      default:
+        *(dest++) = c;
+     }
+  }
+  *dest = '\0';
+}
+
 void prog_disasm_function(qc_program *prog, size_t id);
-int main(int argc, char **argv)
-{
+
+int main(int argc, char **argv) {
     size_t      i;
     qcint       fnmain = -1;
     qc_program *prog;
@@ -1032,6 +1050,8 @@ int main(int argc, char **argv)
                 p.vtype = TYPE_STRING;
             else if (argv[1][1] == 'v')
                 p.vtype = TYPE_VECTOR;
+            else
+                p.vtype = TYPE_VOID;
 
             --argc;
             ++argv;
@@ -1052,7 +1072,7 @@ int main(int argc, char **argv)
         }
         else if (argv[1][0] != '-') {
             if (progsfile) {
-                printf("only 1 program file may be specified\n");
+                fprintf(stderr, "only 1 program file may be specified\n");
                 usage();
                 exit(1);
             }
@@ -1062,7 +1082,7 @@ int main(int argc, char **argv)
         }
         else
         {
-            printf("unknown parameter: %s\n", argv[1]);
+            fprintf(stderr, "unknown parameter: %s\n", argv[1]);
             usage();
             exit(1);
         }
@@ -1075,14 +1095,14 @@ int main(int argc, char **argv)
     }
 
     if (!progsfile) {
-        printf("must specify a program to execute\n");
+        fprintf(stderr, "must specify a program to execute\n");
         usage();
         exit(1);
     }
 
-    prog = prog_load(progsfile);
+    prog = prog_load(progsfile, noexec);
     if (!prog) {
-        printf("failed to load program '%s'\n", progsfile);
+        fprintf(stderr, "failed to load program '%s'\n", progsfile);
         exit(1);
     }
 
@@ -1127,12 +1147,42 @@ int main(int argc, char **argv)
         return 0;
     }
     if (opts_printdefs) {
+        char       *escape    = NULL;
+        const char *getstring = NULL;
+
         for (i = 0; i < vec_size(prog->defs); ++i) {
-            printf("Global: %8s %-16s at %u%s\n",
+            printf("Global: %8s %-16s at %u%s",
                    type_name[prog->defs[i].type & DEF_TYPEMASK],
                    prog_getstring(prog, prog->defs[i].name),
                    (unsigned int)prog->defs[i].offset,
                    ((prog->defs[i].type & DEF_SAVEGLOBAL) ? " [SAVE]" : ""));
+            if (opts_v) {
+                switch (prog->defs[i].type & DEF_TYPEMASK) {
+                    case TYPE_FLOAT:
+                        printf(" [init: %g]", ((qcany*)(prog->globals + prog->defs[i].offset))->_float);
+                        break;
+                    case TYPE_INTEGER:
+                        printf(" [init: %i]", (int)( ((qcany*)(prog->globals + prog->defs[i].offset))->_int ));
+                        break;
+                    case TYPE_ENTITY:
+                    case TYPE_FUNCTION:
+                    case TYPE_FIELD:
+                    case TYPE_POINTER:
+                        printf(" [init: %u]", (unsigned)( ((qcany*)(prog->globals + prog->defs[i].offset))->_int ));
+                        break;
+                    case TYPE_STRING:
+                        getstring = prog_getstring(prog, ((qcany*)(prog->globals + prog->defs[i].offset))->string);
+                        escape    = (char*)mem_a(strlen(getstring) * 2 + 1); /* will be enough */
+                        escapestring(escape, getstring);
+                        printf(" [init: `%s`]", escape);
+
+                        mem_d(escape); /* free */
+                        break;
+                    default:
+                        break;
+                }
+            }
+            printf("\n");
         }
     }
     if (opts_printfields) {
@@ -1193,15 +1243,14 @@ int main(int argc, char **argv)
             prog_exec(prog, &prog->functions[fnmain], xflags, VM_JUMPS_DEFAULT);
         }
         else
-            printf("No main function found\n");
+            fprintf(stderr, "No main function found\n");
     }
 
     prog_delete(prog);
     return 0;
 }
 
-void prog_disasm_function(qc_program *prog, size_t id)
-{
+void prog_disasm_function(qc_program *prog, size_t id) {
     prog_section_function *fdef = prog->functions + id;
     prog_section_statement *st;
 
@@ -1282,15 +1331,21 @@ while (1) {
                           OPA->vector[2]*OPB->vector[2];
             break;
         case INSTR_MUL_FV:
-            OPC->vector[0] = OPA->_float * OPB->vector[0];
-            OPC->vector[1] = OPA->_float * OPB->vector[1];
-            OPC->vector[2] = OPA->_float * OPB->vector[2];
+        {
+            qcfloat f = OPA->_float;
+            OPC->vector[0] = f * OPB->vector[0];
+            OPC->vector[1] = f * OPB->vector[1];
+            OPC->vector[2] = f * OPB->vector[2];
             break;
+        }
         case INSTR_MUL_VF:
-            OPC->vector[0] = OPB->_float * OPA->vector[0];
-            OPC->vector[1] = OPB->_float * OPA->vector[1];
-            OPC->vector[2] = OPB->_float * OPA->vector[2];
+        {
+            qcfloat f = OPB->_float;
+            OPC->vector[0] = f * OPA->vector[0];
+            OPC->vector[1] = f * OPA->vector[1];
+            OPC->vector[2] = f * OPA->vector[2];
             break;
+        }
         case INSTR_DIV_F:
             if (OPB->_float != 0.0f)
                 OPC->_float = OPA->_float / OPB->_float;
@@ -1396,9 +1451,10 @@ while (1) {
                 goto cleanup;
             }
             ed = prog_getedict(prog, OPA->edict);
-            OPC->ivector[0] = ((qcany*)( ((qcint*)ed) + OPB->_int ))->ivector[0];
-            OPC->ivector[1] = ((qcany*)( ((qcint*)ed) + OPB->_int ))->ivector[1];
-            OPC->ivector[2] = ((qcany*)( ((qcint*)ed) + OPB->_int ))->ivector[2];
+            ptr = (qcany*)( ((qcint*)ed) + OPB->_int );
+            OPC->ivector[0] = ptr->ivector[0];
+            OPC->ivector[1] = ptr->ivector[1];
+            OPC->ivector[2] = ptr->ivector[2];
             break;
 
         case INSTR_ADDRESS: