]> git.rm.cloudns.org Git - xonotic/gmqcc.git/commitdiff
Make the testsuite C++ compatible.
authorDale Weiler <killfieldengine@gmail.com>
Wed, 6 Feb 2013 10:52:09 +0000 (10:52 +0000)
committerDale Weiler <killfieldengine@gmail.com>
Wed, 6 Feb 2013 10:52:09 +0000 (10:52 +0000)
test.c

diff --git a/test.c b/test.c
index 5e99df404063de4b7d638cd3e6217107414f5f36..42a1272952367463dedc2b5cb03ebc25e576f59b 100644 (file)
--- a/test.c
+++ b/test.c
@@ -26,7 +26,7 @@
 
 opts_cmd_t opts;
 
-char *task_bins[] = {
+const char *task_bins[] = {
     "./gmqcc",
     "./qcvm"
 };
@@ -66,7 +66,7 @@ FILE ** task_popen(const char *command, const char *mode) {
     int     errhandle [2];
     int     trypipe;
 
-    popen_t *data = mem_a(sizeof(popen_t));
+    popen_t *data = (popen_t*)mem_a(sizeof(popen_t));
 
     /*
      * Parse the command now into a list for execv, this is a pain
@@ -360,20 +360,20 @@ 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 *template, char tag, const char *file, size_t line, const char *value, size_t *pad) {
+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;
     char **destval = NULL;
 
-    if (!template)
+    if (!tmpl)
         return false;
 
     switch(tag) {
-        case 'D': destval = &template->description;    break;
-        case 'T': destval = &template->proceduretype;  break;
-        case 'C': destval = &template->compileflags;   break;
-        case 'E': destval = &template->executeflags;   break;
-        case 'I': destval = &template->sourcefile;     break;
-        case 'F': destval = &template->testflags;      break;
+        case 'D': destval = &tmpl->description;    break;
+        case 'T': destval = &tmpl->proceduretype;  break;
+        case 'C': destval = &tmpl->compileflags;   break;
+        case 'E': destval = &tmpl->executeflags;   break;
+        case 'I': destval = &tmpl->sourcefile;     break;
+        case 'F': destval = &tmpl->testflags;      break;
         default:
             con_printmsg(LVL_ERROR, __FILE__, __LINE__, "internal error",
                 "invalid tag `%c:` during code generation\n",
@@ -417,25 +417,25 @@ bool task_template_generate(task_template_t *template, char tag, const char *fil
     *destval = util_strdup(value);
 
 
-    if (*destval == template->description) {
+    if (*destval == tmpl->description) {
         /*
          * Create some padding for the description to align the
          * printing of the rules file.
          */  
-        if ((desclen = strlen(template->description)) > pad[0])
+        if ((desclen = strlen(tmpl->description)) > pad[0])
             pad[0] = desclen;
     }
 
     return true;
 }
 
-bool task_template_parse(const char *file, task_template_t *template, FILE *fp, size_t *pad) {
+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;
     size_t line = 1;
 
-    if (!template)
+    if (!tmpl)
         return false;
 
     /* top down parsing */
@@ -447,12 +447,12 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp,
 
         switch (*data) {
             /*
-             * Handle comments inside task template files.  We're strict
+             * Handle comments inside task tmpl files.  We're strict
              * about the language for fun :-)
              */
             case '/':
                 if (data[1] != '/') {
-                    con_printmsg(LVL_ERROR, file, line, "template parse error",
+                    con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
                         "invalid character `/`, perhaps you meant `//` ?");
 
                     mem_d(back);
@@ -482,14 +482,14 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp,
             case 'I':
             case 'F':
                 if (data[1] != ':') {
-                    con_printmsg(LVL_ERROR, file, line, "template parse error",
+                    con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
                         "expected `:` after `%c`",
                         *data
                     );
                     goto failure;
                 }
-                if (!task_template_generate(template, *data, file, line, &data[3], pad)) {
-                    con_printmsg(LVL_ERROR, file, line, "template compile error",
+                if (!task_template_generate(tmpl, *data, file, line, &data[3], pad)) {
+                    con_printmsg(LVL_ERROR, file, line, "tmpl compile error",
                         "failed to generate for given task\n"
                     );
                     goto failure;
@@ -504,7 +504,7 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp,
             {
                 char *value = &data[3];
                 if (data[1] != ':') {
-                    con_printmsg(LVL_ERROR, file, line, "template parse error",
+                    con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
                         "expected `:` after `%c`",
                         *data
                     );
@@ -523,13 +523,13 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp,
                 else /* cppcheck: possible null pointer dereference */
                     abort();
 
-                vec_push(template->comparematch, util_strdup(value));
+                vec_push(tmpl->comparematch, util_strdup(value));
 
                 break;
             }
 
             default:
-                con_printmsg(LVL_ERROR, file, line, "template parse error",
+                con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
                     "invalid tag `%c`", *data
                 );
                 goto failure;
@@ -555,19 +555,19 @@ failure:
  * Nullifies the template data: used during initialization of a new
  * template and free.
  */
-void task_template_nullify(task_template_t *template) {
-    if (!template)
+void task_template_nullify(task_template_t *tmpl) {
+    if (!tmpl)
         return;
 
-    template->description    = NULL;
-    template->proceduretype  = NULL;
-    template->compileflags   = NULL;
-    template->executeflags   = NULL;
-    template->comparematch   = NULL;
-    template->sourcefile     = NULL;
-    template->tempfilename   = NULL;
-    template->rulesfile      = NULL;
-    template->testflags      = NULL;
+    tmpl->description    = NULL;
+    tmpl->proceduretype  = NULL;
+    tmpl->compileflags   = NULL;
+    tmpl->executeflags   = NULL;
+    tmpl->comparematch   = NULL;
+    tmpl->sourcefile     = NULL;
+    tmpl->tempfilename   = NULL;
+    tmpl->rulesfile      = NULL;
+    tmpl->testflags      = NULL;
 }
 
 task_template_t *task_template_compile(const char *file, const char *dir, size_t *pad) {
@@ -575,14 +575,14 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
     char             fullfile[4096];
     size_t           filepadd = 0;
     FILE            *tempfile = NULL;
-    task_template_t *template = NULL;
+    task_template_t *tmpl     = NULL;
 
     memset  (fullfile, 0, sizeof(fullfile));
     snprintf(fullfile,    sizeof(fullfile), "%s/%s", dir, file);
 
-    tempfile            = file_open(fullfile, "r");
-    template            = mem_a(sizeof(task_template_t));
-    task_template_nullify(template);
+    tempfile = file_open(fullfile, "r");
+    tmpl     = (task_template_t*)mem_a(sizeof(task_template_t));
+    task_template_nullify(tmpl);
 
     /*
      * Create some padding for the printing to align the
@@ -591,7 +591,7 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
     if ((filepadd = strlen(fullfile)) > pad[1])
         pad[1] = filepadd;
 
-    template->rulesfile = util_strdup(fullfile);
+    tmpl->rulesfile = util_strdup(fullfile);
 
     /*
      * Esnure the file even exists for the task, this is pretty useless
@@ -604,7 +604,7 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
         goto failure;
     }
 
-    if (!task_template_parse(file, template, tempfile, pad)) {
+    if (!task_template_parse(file, tmpl, tempfile, pad)) {
         con_err("template parse error: error during parsing\n");
         goto failure;
     }
@@ -616,19 +616,19 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
      *  C
      *  I
      */
-    if (!template->description) {
+    if (!tmpl->description) {
         con_err("template compile error: %s missing `D:` tag\n", file);
         goto failure;
     }
-    if (!template->proceduretype) {
+    if (!tmpl->proceduretype) {
         con_err("template compile error: %s missing `T:` tag\n", file);
         goto failure;
     }
-    if (!template->compileflags) {
+    if (!tmpl->compileflags) {
         con_err("template compile error: %s missing `C:` tag\n", file);
         goto failure;
     }
-    if (!template->sourcefile) {
+    if (!tmpl->sourcefile) {
         con_err("template compile error: %s missing `I:` tag\n", file);
         goto failure;
     }
@@ -637,35 +637,35 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
      * Now lets compile the template, compilation is really just
      * the process of validating the input.
      */
-    if (!strcmp(template->proceduretype, "-compile")) {
-        if (template->executeflags)
+    if (!strcmp(tmpl->proceduretype, "-compile")) {
+        if (tmpl->executeflags)
             con_err("template compile warning: %s erroneous tag `E:` when only compiling\n", file);
-        if (template->comparematch)
+        if (tmpl->comparematch)
             con_err("template compile warning: %s erroneous tag `M:` when only compiling\n", file);
         goto success;
-    } else if (!strcmp(template->proceduretype, "-execute")) {
-        if (!template->executeflags) {
+    } else if (!strcmp(tmpl->proceduretype, "-execute")) {
+        if (!tmpl->executeflags) {
             /* default to $null */
-            template->executeflags = util_strdup("$null");
+            tmpl->executeflags = util_strdup("$null");
         }
-        if (!template->comparematch) {
+        if (!tmpl->comparematch) {
             con_err("template compile error: %s missing `M:` tag (use `$null` for exclude)\n", file);
             goto failure;
         }
-    } else if (!strcmp(template->proceduretype, "-fail")) {
-        if (template->executeflags)
+    } else if (!strcmp(tmpl->proceduretype, "-fail")) {
+        if (tmpl->executeflags)
             con_err("template compile warning: %s erroneous tag `E:` when only failing\n", file);
-        if (template->comparematch)
+        if (tmpl->comparematch)
             con_err("template compile warning: %s erroneous tag `M:` when only failing\n", file);
         goto success;
     } else {
-        con_err("template compile error: %s invalid procedure type: %s\n", file, template->proceduretype);
+        con_err("template compile error: %s invalid procedure type: %s\n", file, tmpl->proceduretype);
         goto failure;
     }
 
 success:
     file_close(tempfile);
-    return template;
+    return tmpl;
 
 failure:
     /*
@@ -674,40 +674,40 @@ failure:
      */
     if (tempfile)
         file_close(tempfile);
-    mem_d (template);
+    mem_d (tmpl);
 
     return NULL;
 }
 
-void task_template_destroy(task_template_t **template) {
-    if (!template)
+void task_template_destroy(task_template_t **tmpl) {
+    if (!tmpl)
         return;
 
-    if ((*template)->description)    mem_d((*template)->description);
-    if ((*template)->proceduretype)  mem_d((*template)->proceduretype);
-    if ((*template)->compileflags)   mem_d((*template)->compileflags);
-    if ((*template)->executeflags)   mem_d((*template)->executeflags);
-    if ((*template)->sourcefile)     mem_d((*template)->sourcefile);
-    if ((*template)->rulesfile)      mem_d((*template)->rulesfile);
-    if ((*template)->testflags)      mem_d((*template)->testflags);
+    if ((*tmpl)->description)    mem_d((*tmpl)->description);
+    if ((*tmpl)->proceduretype)  mem_d((*tmpl)->proceduretype);
+    if ((*tmpl)->compileflags)   mem_d((*tmpl)->compileflags);
+    if ((*tmpl)->executeflags)   mem_d((*tmpl)->executeflags);
+    if ((*tmpl)->sourcefile)     mem_d((*tmpl)->sourcefile);
+    if ((*tmpl)->rulesfile)      mem_d((*tmpl)->rulesfile);
+    if ((*tmpl)->testflags)      mem_d((*tmpl)->testflags);
 
     /*
-     * Delete all allocated string for task template then destroy the
+     * Delete all allocated string for task tmpl then destroy the
      * main vector.
      */
     {
         size_t i = 0;
-        for (; i < vec_size((*template)->comparematch); i++)
-            mem_d((*template)->comparematch[i]);
+        for (; i < vec_size((*tmpl)->comparematch); i++)
+            mem_d((*tmpl)->comparematch[i]);
 
-        vec_free((*template)->comparematch);
+        vec_free((*tmpl)->comparematch);
     }
 
     /*
      * Nullify all the template members otherwise NULL comparision
-     * checks will fail if template pointer is reused.
+     * checks will fail if tmpl pointer is reused.
      */
-    mem_d(*template);
+    mem_d(*tmpl);
 }
 
 /*
@@ -715,7 +715,7 @@ void task_template_destroy(task_template_t **template) {
  * of a task list.  This is the executor of the tasks essentially as well.
  */
 typedef struct {
-    task_template_t *template;
+    task_template_t *tmpl;
     FILE           **runhandles;
     FILE            *stderrlog;
     FILE            *stdoutlog;
@@ -758,14 +758,14 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
          * actually a directory, so it must be a file :)
          */
         if (strcmp(files->d_name + strlen(files->d_name) - 5, ".tmpl") == 0) {
-            task_template_t *template = task_template_compile(files->d_name, curdir, pad);
+            task_template_t *tmpl = task_template_compile(files->d_name, curdir, pad);
             char             buf[4096]; /* one page should be enough */
             char            *qcflags = NULL;
             task_t           task;
 
             util_debug("TEST", "compiling task template: %s/%s\n", curdir, files->d_name);
             found ++;
-            if (!template) {
+            if (!tmpl) {
                 con_err("error compiling task template: %s\n", files->d_name);
                 success = false;
                 continue;
@@ -774,7 +774,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
              * Generate a temportary file name for the output binary
              * so we don't trample over an existing one.
              */
-            template->tempfilename = tempnam(curdir, "TMPDAT");
+            tmpl->tempfilename = tempnam(curdir, "TMPDAT");
 
             /*
              * Additional QCFLAGS enviroment variable may be used
@@ -790,14 +790,14 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
              */
             memset (buf,0,sizeof(buf));
             if (qcflags) {
-                if (template->testflags && !strcmp(template->testflags, "-no-defs")) {
+                if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
                     snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s",
                         task_bins[TASK_COMPILE],
                         curdir,
-                        template->sourcefile,
+                        tmpl->sourcefile,
                         qcflags,
-                        template->compileflags,
-                        template->tempfilename
+                        tmpl->compileflags,
+                        tmpl->tempfilename
                     );
                 } else {
                     snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s",
@@ -805,20 +805,20 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
                         curdir,
                         defs,
                         curdir,
-                        template->sourcefile,
+                        tmpl->sourcefile,
                         qcflags,
-                        template->compileflags,
-                        template->tempfilename
+                        tmpl->compileflags,
+                        tmpl->tempfilename
                     );
                 }
             } else {
-                if (template->testflags && !strcmp(template->testflags, "-no-defs")) {
+                if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
                     snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s",
                         task_bins[TASK_COMPILE],
                         curdir,
-                        template->sourcefile,
-                        template->compileflags,
-                        template->tempfilename
+                        tmpl->sourcefile,
+                        tmpl->compileflags,
+                        tmpl->tempfilename
                     );
                 } else {
                     snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s",
@@ -826,9 +826,9 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
                         curdir,
                         defs,
                         curdir,
-                        template->sourcefile,
-                        template->compileflags,
-                        template->tempfilename
+                        tmpl->sourcefile,
+                        tmpl->compileflags,
+                        tmpl->tempfilename
                     );
                 }
             }
@@ -837,21 +837,21 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
              * The task template was compiled, now lets create a task from
              * the template data which has now been propagated.
              */
-            task.template = template;
+            task.tmpl = tmpl;
             if (!(task.runhandles = task_popen(buf, "r"))) {
-                con_err("error opening pipe to process for test: %s\n", template->description);
+                con_err("error opening pipe to process for test: %s\n", tmpl->description);
                 success = false;
                 continue;
             }
 
-            util_debug("TEST", "executing test: `%s` [%s]\n", template->description, buf);
+            util_debug("TEST", "executing test: `%s` [%s]\n", tmpl->description, buf);
 
             /*
              * Open up some file desciptors for logging the stdout/stderr
              * to our own.
              */
             memset  (buf,0,sizeof(buf));
-            snprintf(buf,  sizeof(buf), "%s.stdout", template->tempfilename);
+            snprintf(buf,  sizeof(buf), "%s.stdout", tmpl->tempfilename);
             task.stdoutlogfile = util_strdup(buf);
             if (!(task.stdoutlog     = file_open(buf, "w"))) {
                 con_err("error opening %s for stdout\n", buf);
@@ -859,9 +859,9 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
             }
 
             memset  (buf,0,sizeof(buf));
-            snprintf(buf,  sizeof(buf), "%s.stderr", template->tempfilename);
+            snprintf(buf,  sizeof(buf), "%s.stderr", tmpl->tempfilename);
             task.stderrlogfile = util_strdup(buf);
-            if (!(task.stderrlog     = file_open(buf, "w"))) {
+            if (!(task.stderrlog = file_open(buf, "w"))) {
                 con_err("error opening %s for stderr\n", buf);
                 continue;
             }
@@ -928,7 +928,7 @@ void task_destroy(void) {
          * forget about it (or if it didn't compile, and the procedure type
          * was set to -fail (meaning it shouldn't compile) .. stil remove) 
          */
-        if (task_tasks[i].compiled || !strcmp(task_tasks[i].template->proceduretype, "-fail")) {
+        if (task_tasks[i].compiled || !strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) {
             if (remove(task_tasks[i].stdoutlogfile))
                 con_err("error removing stdout log file: %s\n", task_tasks[i].stdoutlogfile);
             else
@@ -938,14 +938,14 @@ void task_destroy(void) {
             else
                 util_debug("TEST", "removed stderr log file: %s\n", task_tasks[i].stderrlogfile);
 
-            remove(task_tasks[i].template->tempfilename);
+            remove(task_tasks[i].tmpl->tempfilename);
         }
 
         /* free util_strdup data for log files */
         mem_d(task_tasks[i].stdoutlogfile);
         mem_d(task_tasks[i].stderrlogfile);
 
-        task_template_destroy(&task_tasks[i].template);
+        task_template_destroy(&task_tasks[i].tmpl);
     }
     vec_free(task_tasks);
 }
@@ -955,7 +955,7 @@ void task_destroy(void) {
  * using the template passed into it for call-flags and user defined
  * messages.
  */
-bool task_execute(task_template_t *template, char ***line) {
+bool task_execute(task_template_t *tmpl, char ***line) {
     bool     success = true;
     FILE    *execute;
     char     buffer[4096];
@@ -965,21 +965,21 @@ bool task_execute(task_template_t *template, char ***line) {
      * Drop the execution flags for the QCVM if none where
      * actually specified.
      */
-    if (!strcmp(template->executeflags, "$null")) {
+    if (!strcmp(tmpl->executeflags, "$null")) {
         snprintf(buffer,  sizeof(buffer), "%s %s",
             task_bins[TASK_EXECUTE],
-            template->tempfilename
+            tmpl->tempfilename
         );
     } else {
         snprintf(buffer,  sizeof(buffer), "%s %s %s",
             task_bins[TASK_EXECUTE],
-            template->executeflags,
-            template->tempfilename
+            tmpl->executeflags,
+            tmpl->tempfilename
         );
     }
 
     util_debug("TEST", "executing qcvm: `%s` [%s]\n",
-        template->description,
+        tmpl->description,
         buffer
     );
 
@@ -998,8 +998,8 @@ bool task_execute(task_template_t *template, char ***line) {
         while (file_getline(&data, &size, execute) != EOF) {
             if (!strcmp(data, "No main function found\n")) {
                 con_err("test failure: `%s` (No main function found) [%s]\n",
-                    template->description,
-                    template->rulesfile
+                    tmpl->description,
+                    tmpl->rulesfile
                 );
                 pclose(execute);
                 return false;
@@ -1012,8 +1012,8 @@ bool task_execute(task_template_t *template, char ***line) {
             if  (strrchr(data, '\n'))
                 *strrchr(data, '\n') = '\0';
 
-            if (vec_size(template->comparematch) > compare) {
-                if (strcmp(data, template->comparematch[compare++]))
+            if (vec_size(tmpl->comparematch) > compare) {
+                if (strcmp(data, tmpl->comparematch[compare++]))
                     success = false;
             } else {
                     success = false;
@@ -1053,12 +1053,12 @@ void task_schedualize(size_t *pad) {
     util_debug("TEST", "found %d tasks, preparing to execute\n", vec_size(task_tasks));
 
     for (i = 0; i < vec_size(task_tasks); i++) {
-        util_debug("TEST", "executing task: %d: %s\n", i, task_tasks[i].template->description);
+        util_debug("TEST", "executing task: %d: %s\n", i, task_tasks[i].tmpl->description);
         /*
          * Generate a task from thin air if it requires execution in
          * the QCVM.
          */
-        execute = !!(!strcmp(task_tasks[i].template->proceduretype, "-execute"));
+        execute = !!(!strcmp(task_tasks[i].tmpl->proceduretype, "-execute"));
 
         /*
          * We assume it compiled before we actually compiled :).  On error
@@ -1098,22 +1098,22 @@ void task_schedualize(size_t *pad) {
             fflush(task_tasks[i].stdoutlog);
         }
 
-        if (!task_tasks[i].compiled && strcmp(task_tasks[i].template->proceduretype, "-fail")) {
+        if (!task_tasks[i].compiled && strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) {
             con_err("test failure: `%s` (failed to compile) see %s.stdout and %s.stderr [%s]\n",
-                task_tasks[i].template->description,
-                task_tasks[i].template->tempfilename,
-                task_tasks[i].template->tempfilename,
-                task_tasks[i].template->rulesfile
+                task_tasks[i].tmpl->description,
+                task_tasks[i].tmpl->tempfilename,
+                task_tasks[i].tmpl->tempfilename,
+                task_tasks[i].tmpl->rulesfile
             );
             continue;
         }
 
         if (!execute) {
             con_out("test succeeded: `%s` %*s\n",
-                task_tasks[i].template->description,
-                (pad[0] + pad[1] - strlen(task_tasks[i].template->description)) +
-                (strlen(task_tasks[i].template->rulesfile) - pad[1]),
-                task_tasks[i].template->rulesfile
+                task_tasks[i].tmpl->description,
+                (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) +
+                (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
+                task_tasks[i].tmpl->rulesfile
                 
             );
             continue;
@@ -1123,12 +1123,12 @@ void task_schedualize(size_t *pad) {
          * If we made it here that concludes the task is to be executed
          * in the virtual machine.
          */
-        if (!task_execute(task_tasks[i].template, &match)) {
+        if (!task_execute(task_tasks[i].tmpl, &match)) {
             size_t d = 0;
 
             con_err("test failure: `%s` (invalid results from execution) [%s]\n",
-                task_tasks[i].template->description,
-                task_tasks[i].template->rulesfile
+                task_tasks[i].tmpl->description,
+                task_tasks[i].tmpl->rulesfile
             );
 
             /*
@@ -1137,11 +1137,11 @@ void task_schedualize(size_t *pad) {
              * what was actually returned from executing.
              */
             con_err("    Expected From %u Matches: (got %u Matches)\n",
-                vec_size(task_tasks[i].template->comparematch),
+                vec_size(task_tasks[i].tmpl->comparematch),
                 vec_size(match)
             );
-            for (; d < vec_size(task_tasks[i].template->comparematch); d++) {
-                char  *select = task_tasks[i].template->comparematch[d];
+            for (; d < vec_size(task_tasks[i].tmpl->comparematch); d++) {
+                char  *select = task_tasks[i].tmpl->comparematch[d];
                 size_t length = 40 - strlen(select);
 
                 con_err("        Expected: \"%s\"", select);
@@ -1155,10 +1155,10 @@ void task_schedualize(size_t *pad) {
              * This will help track down bugs in template files that fail to match
              * something.
              */  
-            if (vec_size(match) > vec_size(task_tasks[i].template->comparematch)) {
-                for (d = 0; d < vec_size(match) - vec_size(task_tasks[i].template->comparematch); d++) {
+            if (vec_size(match) > vec_size(task_tasks[i].tmpl->comparematch)) {
+                for (d = 0; d < vec_size(match) - vec_size(task_tasks[i].tmpl->comparematch); d++) {
                     con_err("        Expected: Nothing                                   | Got: \"%s\"\n",
-                        match[d + vec_size(task_tasks[i].template->comparematch)]
+                        match[d + vec_size(task_tasks[i].tmpl->comparematch)]
                     );
                 }
             }
@@ -1174,10 +1174,10 @@ void task_schedualize(size_t *pad) {
         vec_free(match);
 
         con_out("test succeeded: `%s` %*s\n",
-            task_tasks[i].template->description,
-            (pad[0] + pad[1] - strlen(task_tasks[i].template->description)) +
-            (strlen(task_tasks[i].template->rulesfile) - pad[1]),
-            task_tasks[i].template->rulesfile
+            task_tasks[i].tmpl->description,
+            (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) +
+            (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
+            task_tasks[i].tmpl->rulesfile
             
         );
     }