X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=test.c;h=29aefc10106093b3cce7a4ccf90e457fb06965b4;hp=2ede2ae2c14c2ed4a2607da768f6138324e37a20;hb=063c50fce450693f0098cbc4a28efd109cbed01b;hpb=160e7cf7eebd7fa173fb739aca00143097a3518b

diff --git a/test.c b/test.c
index 2ede2ae..29aefc1 100644
--- a/test.c
+++ b/test.c
@@ -20,13 +20,16 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#include "gmqcc.h"
+#include <stdlib.h>
+#include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
+#include "gmqcc.h"
+
 opts_cmd_t opts;
 
-const char *task_bins[] = {
+static const char *task_bins[] = {
     "./gmqcc",
     "./qcvm"
 };
@@ -60,7 +63,7 @@ typedef struct {
     int pid;
 } popen_t;
 
-FILE ** task_popen(const char *command, const char *mode) {
+static FILE ** task_popen(const char *command, const char *mode) {
     int     inhandle  [2];
     int     outhandle [2];
     int     errhandle [2];
@@ -101,6 +104,7 @@ FILE ** task_popen(const char *command, const char *mode) {
         data->pipes  [0] = inhandle [1];
         data->pipes  [1] = outhandle[0];
         data->pipes  [2] = errhandle[0];
+
         data->handles[0] = fdopen(inhandle [1], "w");
         data->handles[1] = fdopen(outhandle[0], mode);
         data->handles[2] = fdopen(errhandle[0], mode);
@@ -116,9 +120,9 @@ FILE ** task_popen(const char *command, const char *mode) {
         close(errhandle[0]);
 
         /* see piping documentation for this sillyness :P */
-        close(0), dup(inhandle [0]);
-        close(1), dup(outhandle[1]);
-        close(2), dup(errhandle[1]);
+        dup2(inhandle [0], 0);
+        dup2(outhandle[1], 1);
+        dup2(errhandle[1], 2);
 
         execvp(*argv, argv);
         exit(EXIT_FAILURE);
@@ -132,12 +136,11 @@ task_popen_error_2: close(outhandle[0]), close(outhandle[1]);
 task_popen_error_1: close(inhandle [0]), close(inhandle [1]);
 task_popen_error_0:
 
-    if (argv)
-        vec_free(argv);
+    vec_free(argv);
     return NULL;
 }
 
-int task_pclose(FILE **handles) {
+static int task_pclose(FILE **handles) {
     popen_t *data   = (popen_t*)handles;
     int      status = 0;
 
@@ -152,27 +155,41 @@ int task_pclose(FILE **handles) {
     return status;
 }
 #else
-    /*
-     * Bidirectional piping implementation for windows using CreatePipe and DuplicateHandle +
-     * other hacks.
-     */
     typedef struct {
-        int __dummy;
-        /* TODO: implement */
+        FILE *handles[3];
+        char  name_err[L_tmpnam];
+        char  name_out[L_tmpnam];
     } popen_t;
 
-    FILE **task_popen(const char *command, const char *mode) {
-        (void)command;
-        (void)mode;
+    static FILE **task_popen(const char *command, const char *mode) {
+        char    *cmd  = NULL;
+        popen_t *open = (popen_t*)mem_a(sizeof(popen_t));
+
+        tmpnam(open->name_err);
+        tmpnam(open->name_out);
+
+        (void)mode; /* excluded */
+
+        util_asprintf(&cmd, "%s -redirout=%s -redirerr=%s", command, open->name_out, open->name_err);
+
+        system(cmd); /* HACK */
+        open->handles[0] = NULL;
+        open->handles[1] = fs_file_open(open->name_out, "r");
+        open->handles[2] = fs_file_open(open->name_err, "r");
 
-        /* TODO: implement */
-        return NULL;
+        mem_d(cmd);
+
+        return open->handles;
     }
 
-    void task_pclose(FILE **files) {
-        /* TODO: implement */
-        (void)files;
-        return;
+    static void task_pclose(FILE **files) {
+        popen_t *open = ((popen_t*)files);
+        fs_file_close(files[1]);
+        fs_file_close(files[2]);
+        remove(open->name_err);
+        remove(open->name_out);
+
+        mem_d(open);
     }
 #endif /*! _WIN32 */
 
@@ -267,7 +284,7 @@ typedef struct {
  * This is very much like a compiler code generator :-).  This generates
  * a value from some data observed from the compiler.
  */
-bool task_template_generate(task_template_t *tmpl, char tag, const char *file, size_t line, char *value, size_t *pad) {
+static bool task_template_generate(task_template_t *tmpl, char tag, const char *file, size_t line, char *value, size_t *pad) {
     size_t desclen = 0;
     size_t filelen = 0;
     char **destval = NULL;
@@ -283,7 +300,7 @@ bool task_template_generate(task_template_t *tmpl, char tag, const char *file, s
         case 'I': destval = &tmpl->sourcefile;     break;
         case 'F': destval = &tmpl->testflags;      break;
         default:
-            con_printmsg(LVL_ERROR, __FILE__, __LINE__, "internal error",
+            con_printmsg(LVL_ERROR, __FILE__, __LINE__, 0, "internal error",
                 "invalid tag `%c:` during code generation\n",
                 tag
             );
@@ -295,7 +312,7 @@ bool task_template_generate(task_template_t *tmpl, char tag, const char *file, s
      * assigned value.
      */
     if (*destval) {
-        con_printmsg(LVL_ERROR, file, line, "compile error",
+        con_printmsg(LVL_ERROR, file, line, 0, /*TODO: column for match*/ "compile error",
             "tag `%c:` already assigned value: %s\n",
             tag, *destval
         );
@@ -308,6 +325,8 @@ bool task_template_generate(task_template_t *tmpl, char tag, const char *file, s
      */
     if (value && *value && (*value == ' ' || *value == '\t'))
         value++;
+    else if (!value)
+        exit(EXIT_FAILURE);
 
     /*
      * Value will contain a newline character at the end, we need to strip
@@ -315,8 +334,6 @@ bool task_template_generate(task_template_t *tmpl, char tag, const char *file, s
      */
     if (strchr(value, '\n'))
         *strrchr(value, '\n')='\0';
-    else /* cppcheck: possible nullpointer dereference */
-        exit(EXIT_FAILURE);
 
     /*
      * Now allocate and set the actual value for the specific tag. Which
@@ -340,7 +357,7 @@ bool task_template_generate(task_template_t *tmpl, char tag, const char *file, s
     return true;
 }
 
-bool task_template_parse(const char *file, task_template_t *tmpl, FILE *fp, size_t *pad) {
+static bool task_template_parse(const char *file, task_template_t *tmpl, FILE *fp, size_t *pad) {
     char  *data = NULL;
     char  *back = NULL;
     size_t size = 0;
@@ -363,7 +380,7 @@ bool task_template_parse(const char *file, task_template_t *tmpl, FILE *fp, size
              */
             case '/':
                 if (data[1] != '/') {
-                    con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
+                    con_printmsg(LVL_ERROR, file, line, 0, /*TODO: column for match*/ "tmpl parse error",
                         "invalid character `/`, perhaps you meant `//` ?");
 
                     mem_d(back);
@@ -393,14 +410,14 @@ bool task_template_parse(const char *file, task_template_t *tmpl, FILE *fp, size
             case 'I':
             case 'F':
                 if (data[1] != ':') {
-                    con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
+                    con_printmsg(LVL_ERROR, file, line, 0, /*TODO: column for match*/ "tmpl parse error",
                         "expected `:` after `%c`",
                         *data
                     );
                     goto failure;
                 }
                 if (!task_template_generate(tmpl, *data, file, line, &data[3], pad)) {
-                    con_printmsg(LVL_ERROR, file, line, "tmpl compile error",
+                    con_printmsg(LVL_ERROR, file, line, 0, /*TODO: column for match*/ "tmpl compile error",
                         "failed to generate for given task\n"
                     );
                     goto failure;
@@ -415,7 +432,7 @@ bool task_template_parse(const char *file, task_template_t *tmpl, FILE *fp, size
             {
                 char *value = &data[3];
                 if (data[1] != ':') {
-                    con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
+                    con_printmsg(LVL_ERROR, file, line, 0, /*TODO: column for match*/ "tmpl parse error",
                         "expected `:` after `%c`",
                         *data
                     );
@@ -440,7 +457,7 @@ bool task_template_parse(const char *file, task_template_t *tmpl, FILE *fp, size
             }
 
             default:
-                con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
+                con_printmsg(LVL_ERROR, file, line, 0, /*TODO: column for match*/ "tmpl parse error",
                     "invalid tag `%c`", *data
                 );
                 goto failure;
@@ -457,8 +474,7 @@ bool task_template_parse(const char *file, task_template_t *tmpl, FILE *fp, size
     return true;
 
 failure:
-    if (back)
-        mem_d (back);
+    mem_d (back);
     return false;
 }
 
@@ -466,7 +482,7 @@ failure:
  * Nullifies the template data: used during initialization of a new
  * template and free.
  */
-void task_template_nullify(task_template_t *tmpl) {
+static void task_template_nullify(task_template_t *tmpl) {
     if (!tmpl)
         return;
 
@@ -481,14 +497,14 @@ void task_template_nullify(task_template_t *tmpl) {
     tmpl->testflags      = NULL;
 }
 
-task_template_t *task_template_compile(const char *file, const char *dir, size_t *pad) {
+static task_template_t *task_template_compile(const char *file, const char *dir, size_t *pad) {
     /* a page should be enough */
     char             fullfile[4096];
     size_t           filepadd = 0;
     FILE            *tempfile = NULL;
     task_template_t *tmpl     = NULL;
 
-    snprintf(fullfile,    sizeof(fullfile), "%s/%s", dir, file);
+    util_snprintf(fullfile,    sizeof(fullfile), "%s/%s", dir, file);
 
     tempfile = fs_file_open(fullfile, "r");
     tmpl     = (task_template_t*)mem_a(sizeof(task_template_t));
@@ -595,7 +611,7 @@ failure:
     return NULL;
 }
 
-void task_template_destroy(task_template_t **tmpl) {
+static void task_template_destroy(task_template_t **tmpl) {
     if (!tmpl)
         return;
 
@@ -640,13 +656,13 @@ typedef struct {
     bool             compiled;
 } task_t;
 
-task_t *task_tasks = NULL;
+static task_t *task_tasks = NULL;
 
 /*
  * Read a directory and searches for all template files in it
  * which is later used to run all tests.
  */
-bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
+static bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
     bool             success = true;
     DIR             *dir;
     struct dirent   *files;
@@ -657,7 +673,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
     dir = fs_dir_open(curdir);
 
     while ((files = fs_dir_read(dir))) {
-        snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
+        util_snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
 
         if (stat(buffer, &directory) == -1) {
             con_err("internal error: stat failed, aborting\n");
@@ -697,7 +713,16 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
              * to test compile flags for all tests.  This needs to be
              * BEFORE other flags (so that the .tmpl can override them)
              */
+            #ifdef _MSC_VER
+            {
+                char   buffer[4096];
+                size_t size;
+                getenv_s(&size, buffer, sizeof(buffer), "QCFLAGS");
+                qcflags = buffer;
+            }
+            #else
             qcflags = getenv("QCFLAGS");
+            #endif
 
             /*
              * Generate the command required to open a pipe to a process
@@ -707,7 +732,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
             if (strcmp(tmpl->proceduretype, "-pp")) {
                 if (qcflags) {
                     if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
-                        snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s",
+                        util_snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s",
                             task_bins[TASK_COMPILE],
                             curdir,
                             tmpl->sourcefile,
@@ -716,7 +741,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
                             tmpl->tempfilename
                         );
                     } else {
-                        snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s",
+                        util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s",
                             task_bins[TASK_COMPILE],
                             curdir,
                             defs,
@@ -729,7 +754,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
                     }
                 } else {
                     if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
-                        snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s",
+                        util_snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s",
                             task_bins[TASK_COMPILE],
                             curdir,
                             tmpl->sourcefile,
@@ -737,7 +762,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
                             tmpl->tempfilename
                         );
                     } else {
-                        snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s",
+                        util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s",
                             task_bins[TASK_COMPILE],
                             curdir,
                             defs,
@@ -751,14 +776,14 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
             } else {
                 /* Preprocessing (qcflags mean shit all here we don't allow them) */
                 if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
-                    snprintf(buf, sizeof(buf), "%s -E %s/%s -o %s",
+                    util_snprintf(buf, sizeof(buf), "%s -E %s/%s -o %s",
                         task_bins[TASK_COMPILE],
                         curdir,
                         tmpl->sourcefile,
                         tmpl->tempfilename
                     );
                 } else {
-                    snprintf(buf, sizeof(buf), "%s -E %s/%s %s/%s -o %s",
+                    util_snprintf(buf, sizeof(buf), "%s -E %s/%s %s/%s -o %s",
                         task_bins[TASK_COMPILE],
                         curdir,
                         defs,
@@ -786,14 +811,14 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
              * Open up some file desciptors for logging the stdout/stderr
              * to our own.
              */
-            snprintf(buf,  sizeof(buf), "%s.stdout", tmpl->tempfilename);
+            util_snprintf(buf,  sizeof(buf), "%s.stdout", tmpl->tempfilename);
             task.stdoutlogfile = util_strdup(buf);
             if (!(task.stdoutlog     = fs_file_open(buf, "w"))) {
                 con_err("error opening %s for stdout\n", buf);
                 continue;
             }
 
-            snprintf(buf,  sizeof(buf), "%s.stderr", tmpl->tempfilename);
+            util_snprintf(buf,  sizeof(buf), "%s.stderr", tmpl->tempfilename);
             task.stderrlogfile = util_strdup(buf);
             if (!(task.stderrlog = fs_file_open(buf, "w"))) {
                 con_err("error opening %s for stderr\n", buf);
@@ -817,7 +842,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
  * Task precleanup removes any existing temporary files or log files
  * left behind from a previous invoke of the test-suite.
  */
-void task_precleanup(const char *curdir) {
+static void task_precleanup(const char *curdir) {
     DIR             *dir;
     struct dirent   *files;
     char             buffer[4096];
@@ -829,7 +854,7 @@ void task_precleanup(const char *curdir) {
             strstr(files->d_name, ".stdout") ||
             strstr(files->d_name, ".stderr"))
         {
-            snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
+            util_snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
             if (remove(buffer))
                 con_err("error removing temporary file: %s\n", buffer);
             else
@@ -840,7 +865,7 @@ void task_precleanup(const char *curdir) {
     fs_dir_close(dir);
 }
 
-void task_destroy(void) {
+static void task_destroy(void) {
     /*
      * Free all the data in the task list and finally the list itself
      * then proceed to cleanup anything else outside the program like
@@ -871,7 +896,7 @@ void task_destroy(void) {
             else
                 util_debug("TEST", "removed stderr log file: %s\n", task_tasks[i].stderrlogfile);
 
-            remove(task_tasks[i].tmpl->tempfilename);
+            (void)!remove(task_tasks[i].tmpl->tempfilename);
         }
 
         /* free util_strdup data for log files */
@@ -889,8 +914,9 @@ void task_destroy(void) {
  * messages IF the procedure type is -execute, otherwise it matches
  * the preprocessor output.
  */
-bool task_trymatch(task_template_t *tmpl, char ***line) {
+static bool task_trymatch(task_template_t *tmpl, char ***line) {
     bool     success = true;
+    bool     preprocessing = false;
     FILE    *execute;
     char     buffer[4096];
     memset  (buffer,0,sizeof(buffer));
@@ -901,12 +927,12 @@ bool task_trymatch(task_template_t *tmpl, char ***line) {
          * actually specified.
          */
         if (!strcmp(tmpl->executeflags, "$null")) {
-            snprintf(buffer,  sizeof(buffer), "%s %s",
+            util_snprintf(buffer,  sizeof(buffer), "%s %s",
                 task_bins[TASK_EXECUTE],
                 tmpl->tempfilename
             );
         } else {
-            snprintf(buffer,  sizeof(buffer), "%s %s %s",
+            util_snprintf(buffer,  sizeof(buffer), "%s %s %s",
                 task_bins[TASK_EXECUTE],
                 tmpl->executeflags,
                 tmpl->tempfilename
@@ -928,6 +954,8 @@ bool task_trymatch(task_template_t *tmpl, char ***line) {
          */
         if (!(execute = fs_file_open(tmpl->tempfilename, "r")))
             return false;
+
+        preprocessing = true;
     }
 
     /*
@@ -944,7 +972,10 @@ bool task_trymatch(task_template_t *tmpl, char ***line) {
                     tmpl->description,
                     tmpl->rulesfile
                 );
-                pclose(execute);
+                if (preprocessing)
+                    fs_file_close(execute);
+                else
+                    pclose(execute);
                 return false;
             }
 
@@ -983,7 +1014,7 @@ bool task_trymatch(task_template_t *tmpl, char ***line) {
         data = NULL;
     }
 
-    if (strcmp(tmpl->proceduretype, "-pp"))
+    if (!preprocessing)
         pclose(execute);
     else
         fs_file_close(execute);
@@ -991,7 +1022,7 @@ bool task_trymatch(task_template_t *tmpl, char ***line) {
     return success;
 }
 
-const char *task_type(task_template_t *tmpl) {
+static const char *task_type(task_template_t *tmpl) {
     if (!strcmp(tmpl->proceduretype, "-pp"))
         return "type: preprocessor";
     if (!strcmp(tmpl->proceduretype, "-execute"))
@@ -1008,7 +1039,7 @@ const char *task_type(task_template_t *tmpl) {
  * from thin air and executed INLINE.
  */
 #include <math.h>
-void task_schedualize(size_t *pad) {
+static void task_schedualize(size_t *pad) {
     char   space[2][64];
     bool   execute  = false;
     char  *data     = NULL;
@@ -1017,11 +1048,11 @@ void task_schedualize(size_t *pad) {
     size_t i        = 0;
     size_t j        = 0;
 
-    snprintf(space[0], sizeof(space[0]), "%d", (int)vec_size(task_tasks));
+    util_snprintf(space[0], sizeof(space[0]), "%d", (int)vec_size(task_tasks));
 
     for (; i < vec_size(task_tasks); i++) {
         memset(space[1], 0, sizeof(space[1]));
-        snprintf(space[1], sizeof(space[1]), "%d", (int)(i + 1));
+        util_snprintf(space[1], sizeof(space[1]), "%d", (int)(i + 1));
 
         con_out("test #%u %*s", i + 1, strlen(space[0]) - strlen(space[1]), "");
 
@@ -1181,7 +1212,7 @@ void task_schedualize(size_t *pad) {
  *
  * It expects con_init() was called before hand.
  */
-GMQCC_WARN bool test_perform(const char *curdir, const char *defs) {
+static GMQCC_WARN bool test_perform(const char *curdir, const char *defs) {
     static const char *default_defs = "defs.qh";
 
     size_t pad[] = {
@@ -1254,6 +1285,7 @@ int main(int argc, char **argv) {
     char         *defs     = NULL;
 
     con_init();
+    OPTS_OPTION_U16(OPTION_MEMDUMPCOLS) = 16;
 
     /*
      * Command line option parsing commences now We only need to support
@@ -1292,7 +1324,7 @@ int main(int argc, char **argv) {
     }
     con_change(redirout, redirerr);
     succeed = test_perform("tests", defs);
-    util_meminfo();
+    stat_info();
 
 
     return (succeed) ? EXIT_SUCCESS : EXIT_FAILURE;