Remove trailing whitespace for Blub.
authorDale Weiler <killfieldengine@gmail.com>
Mon, 26 Nov 2012 11:12:06 +0000 (11:12 +0000)
committerDale Weiler <killfieldengine@gmail.com>
Mon, 26 Nov 2012 11:12:06 +0000 (11:12 +0000)
con.c
exec.c
ftepp.c
gmqcc.h
main.c
test.c
util.c

diff --git a/con.c b/con.c
index 2d18d6941992bdcc75d23915b289f3491048a5ba..2bd8e397de579096f017b421ce5ba783ff4cecf2 100644 (file)
--- a/con.c
+++ b/con.c
@@ -37,7 +37,7 @@
 typedef struct {
     FILE *handle_err;
     FILE *handle_out;
-    
+
     int   color_err;
     int   color_out;
 } con_t;
@@ -64,7 +64,7 @@ typedef struct {
  * with yay, another macro :P
  */
 #define isatty _isatty
+
 enum {
     RESET = 0,
     BOLD  = 1,
@@ -107,15 +107,15 @@ static void win_fputs(char *str, FILE *f) {
     int acolor;
     int wcolor;
     int icolor;
-    
+
     int state;
     int place;
-    
+
     /* attributes */
     int intense  =  -1;
     int colors[] = {-1, -1 };
     int colorpos = 1;
-    
+
     CONSOLE_SCREEN_BUFFER_INFO cinfo;
     GetConsoleScreenBufferInfo(
         (GMQCC_IS_STDOUT(h)) ?
@@ -123,7 +123,7 @@ static void win_fputs(char *str, FILE *f) {
             GetStdHandle(STD_ERROR_HANDLE), &cinfo
     );
     icolor = cinfo.wAttributes;
-    
+
     while (*str) {
         if (*str == '\e')
             state = '\e';
@@ -140,7 +140,7 @@ static void win_fputs(char *str, FILE *f) {
                     acolor += (colors[find] - 48) * mult;
                     mult   *= 10;
                 }
-                
+
                 /* convert to windows color */
                 if (acolor == BOLD)
                     intense = WINTENSE;
@@ -155,12 +155,12 @@ static void win_fputs(char *str, FILE *f) {
                     wcolor  = WWHITE;
                     intense = WBLACK;
                 }
-                
+
                 SetConsoleTextattribute(
                     (h == stdout) ?
                     GetStdHandle(STD_OUTPUT_HANDLE) :
                     GetStdHandle(STD_ERROR_HANDLE),
-                    
+
                     wcolor | intense | (icolor & 0xF0)
                 );
                 colorpos =  1;
@@ -190,7 +190,7 @@ static con_t console;
  * Enables color on output if supported.
  * NOTE: The support for checking colors is NULL.  On windows this will
  * always work, on *nix it depends if the term has colors.
- * 
+ *
  * NOTE: This prevents colored output to piped stdout/err via isatty
  * checks.
  */
@@ -270,21 +270,21 @@ void con_reset() {
  */
 int con_change(const char *out, const char *err) {
     con_close();
-    
+
     if (GMQCC_IS_DEFINE(out)) {
         console.handle_out = GMQCC_IS_STDOUT(out) ? stdout : stderr;
         con_enablecolor();
     } else if (!(console.handle_out = fopen(out, "w"))) return 0;
-    
+
     if (GMQCC_IS_DEFINE(err)) {
         console.handle_err = GMQCC_IS_STDOUT(err) ? stdout : stderr;
         con_enablecolor();
     } else if (!(console.handle_err = fopen(err, "w"))) return 0;
-    
+
     /* no buffering */
     setvbuf(console.handle_out, NULL, _IONBF, 0);
     setvbuf(console.handle_err, NULL, _IONBF, 0);
-    
+
     return 1;
 }
 
diff --git a/exec.c b/exec.c
index b0d7b20a62f95ee23b53dc7e5c5bb6b09c0604b6..5898428747c1fcd724f27d979224d90e0571a48c 100644 (file)
--- a/exec.c
+++ b/exec.c
@@ -740,7 +740,7 @@ static int qc_vlen(qc_program *prog)
     qcany *vec, len;
     CheckArgs(1);
     vec = GetArg(0);
-    len._float = sqrt(vec->vector[0] * vec->vector[0] + 
+    len._float = sqrt(vec->vector[0] * vec->vector[0] +
                       vec->vector[1] * vec->vector[1] +
                       vec->vector[2] * vec->vector[2]);
     Return(len);
diff --git a/ftepp.c b/ftepp.c
index ddc500b828587edb2614e2a1f622ac69b97cb928..e7be1e464fd351bd6fd29c4d3bf2e169d062a36e 100644 (file)
--- a/ftepp.c
+++ b/ftepp.c
@@ -136,7 +136,7 @@ static void pptoken_delete(pptoken *self)
 static ppmacro *ppmacro_new(lex_ctx ctx, const char *name)
 {
     ppmacro *macro = (ppmacro*)mem_a(sizeof(ppmacro));
-    
+
     (void)ctx;
     memset(macro, 0, sizeof(*macro));
     macro->name = util_strdup(name);
diff --git a/gmqcc.h b/gmqcc.h
index 8cf2a839bda7c9f353e98683dbb0d93bb2d36d4c..7533bb43ee2d09d8bb50dd68178c29c0c5052adc 100644 (file)
--- a/gmqcc.h
+++ b/gmqcc.h
@@ -270,32 +270,32 @@ typedef struct hash_table_t {
 
 /*
  * hashtable implementation:
- * 
+ *
  * Note:
  *      This was designed for pointers:  you manage the life of the object yourself
  *      if you do use this for non-pointers please be warned that the object may not
  *      be valid if the duration of it exceeds (i.e on stack).  So you need to allocate
  *      yourself, or put those in global scope to ensure duration is for the whole
  *      runtime.
- * 
+ *
  * util_htnew(size)                             -- to make a new hashtable
  * util_htset(table, key, value, sizeof(value)) -- to set something in the table
  * util_htget(table, key)                       -- to get something from the table
  * util_htdel(table)                            -- to delete the table
- * 
+ *
  * example of use:
- * 
+ *
  * ht    foo  = util_htnew(1024);
  * int   data = 100;
  * char *test = "hello world\n";
  * util_htset(foo, "foo", (void*)&data);
  * util_gtset(foo, "bar", (void*)test);
- * 
+ *
  * printf("foo: %d, bar %s",
  *     *((int *)util_htget(foo, "foo")),
  *      ((char*)util_htget(foo, "bar"))
  * );
- * 
+ *
  * util_htdel(foo);
  */
 hash_table_t *util_htnew (size_t size);
diff --git a/main.c b/main.c
index 9961ac14a89126c3f0c9791b0a832822c518c76c..ea79a6b069b55c89d8205211f6ab2de64656064e 100644 (file)
--- a/main.c
+++ b/main.c
@@ -232,7 +232,7 @@ static bool options_parse(int argc, char **argv) {
                 con_change(redirout, redirerr);
                 continue;
             }
-            
+
             /* show defaults (like pathscale) */
             if (!strcmp(argv[0]+1, "show-defaults")) {
                 size_t itr;
@@ -240,16 +240,16 @@ static bool options_parse(int argc, char **argv) {
                 for (itr = 0; itr < COUNT_FLAGS; ++itr) {
                     if (!OPTS_FLAG(itr))
                         continue;
-                        
+
                     memset(buffer, 0, sizeof(buffer));
                     util_strtononcmd(opts_flag_list[itr].name, buffer, strlen(opts_flag_list[itr].name) + 1);
-    
+
                     con_out("-f%s ", buffer);
                 }
                 for (itr = 0; itr < COUNT_WARNINGS; ++itr) {
                     if (!OPTS_WARN(itr))
                         continue;
-                    
+
                     memset(buffer, 0, sizeof(buffer));
                     util_strtononcmd(opts_warn_list[itr].name, buffer, strlen(opts_warn_list[itr].name) + 1);
                     con_out("-W%s ", buffer);
diff --git a/test.c b/test.c
index bbbeabe9350f2b39c99d49ba3dfaa531937b5c5a..34b3744952b5320ff8e79ccdb7407dba78a0c996 100644 (file)
--- a/test.c
+++ b/test.c
@@ -37,14 +37,14 @@ char *task_bins[] = {
  * this implements a unique bi-directional popen-like function that
  * allows reading data from both stdout and stderr. And writing to
  * stdin :)
- * 
+ *
  * Example of use:
  * FILE *handles[3] = task_popen("ls", "-l", "r");
  * if (!handles) { perror("failed to open stdin/stdout/stderr to ls");
  * // handles[0] = stdin
  * // handles[1] = stdout
  * // handles[2] = stderr
- * 
+ *
  * task_pclose(handles); // to close
  */
 #ifndef _WIN32
@@ -55,7 +55,7 @@ char *task_bins[] = {
 typedef struct {
     FILE *handles[3];
     int   pipes  [3];
-    
+
     int stderr_fd;
     int stdout_fd;
     int pid;
@@ -66,9 +66,9 @@ FILE ** task_popen(const char *command, const char *mode) {
     int     outhandle [2];
     int     errhandle [2];
     int     trypipe;
-    
+
     popen_t *data = mem_a(sizeof(popen_t));
-    
+
     /*
      * Parse the command now into a list for execv, this is a pain
      * in the ass.
@@ -76,36 +76,36 @@ FILE ** task_popen(const char *command, const char *mode) {
     char  *line = (char*)command;
     char **argv = NULL;
     {
-        
+
         while (*line != '\0') {
             while (*line == ' ' || *line == '\t' || *line == '\n')
                 *line++ = '\0';
             vec_push(argv, line);
-            
+
             while (*line != '\0' && *line != ' ' &&
                    *line != '\t' && *line != '\n') line++;
         }
         vec_push(argv, '\0');
     }
-    
-    
+
+
     if ((trypipe = pipe(inhandle))  < 0) goto task_popen_error_0;
     if ((trypipe = pipe(outhandle)) < 0) goto task_popen_error_1;
     if ((trypipe = pipe(errhandle)) < 0) goto task_popen_error_2;
-    
+
     if ((data->pid = fork()) > 0) {
         /* parent */
         close(inhandle  [0]);
         close(outhandle [1]);
         close(errhandle [1]);
-        
+
         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);
-        
+
         /* sigh */
         if (argv)
             vec_free(argv);
@@ -115,23 +115,23 @@ FILE ** task_popen(const char *command, const char *mode) {
         close(inhandle [1]);
         close(outhandle[0]);
         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]);
-        
+
         execvp(*argv, argv);
         exit(1);
     } else {
         /* fork failed */
         goto task_popen_error_3;
     }
-    
+
     if (argv)
         vec_free(argv);
     return data->handles;
-        
+
 task_popen_error_3: close(errhandle[0]), close(errhandle[1]);
 task_popen_error_2: close(outhandle[0]), close(outhandle[1]);
 task_popen_error_1: close(inhandle [0]), close(inhandle [1]);
@@ -145,15 +145,15 @@ task_popen_error_0:
 int task_pclose(FILE **handles) {
     popen_t *data   = (popen_t*)handles;
     int      status = 0;
-    
+
     close(data->pipes[0]); /* stdin  */
     close(data->pipes[1]); /* stdout */
     close(data->pipes[2]); /* stderr */
-    
+
     waitpid(data->pid, &status, 0);
-    
+
     mem_d(data);
-    
+
     return status;
 }
 #else
@@ -171,29 +171,29 @@ int task_pclose(FILE **handles) {
  *  the information for that test there is no way to properly "test" them.
  *  Rules for these templates are described in a template file, using a
  *  task template language.
- * 
+ *
  *  The language is a basic finite statemachine, top-down single-line
  *  description language.
- * 
+ *
  *  The languge is composed entierly of "tags" which describe a string of
  *  text for a task.  Think of it much like a configuration file.  Except
  *  it's been designed to allow flexibility and future support for prodecual
  *  semantics.
- * 
+ *
  *  The following "tags" are suported by the language
- * 
+ *
  *      D:
  *          Used to set a description of the current test, this must be
  *          provided, this tag is NOT optional.
- * 
+ *
  *      F:
  *          Used to set a failure message, this message will be displayed
  *          if the test fails, this tag is optional
- * 
+ *
  *      S:
  *          Used to set a success message, this message will be displayed
  *          if the test succeeds, this tag is optional.
- * 
+ *
  *      T:
  *          Used to set the procedure for the given task, there are two
  *          options for this:
@@ -201,39 +201,39 @@ int task_pclose(FILE **handles) {
  *                  This simply performs compilation only
  *              -execute
  *                  This will perform compilation and execution
- * 
+ *
  *          This must be provided, this tag is NOT optional.
- * 
+ *
  *      C:
  *          Used to set the compilation flags for the given task, this
  *          must be provided, this tag is NOT optional.
- * 
+ *
  *      E:
  *          Used to set the execution flags for the given task. This tag
  *          must be provided if T == -execute, otherwise it's erroneous
- *          as compilation only takes place. 
- *      
+ *          as compilation only takes place.
+ *
  *      M:
  *          Used to describe a string of text that should be matched from
  *          the output of executing the task.  If this doesn't match the
  *          task fails.  This tag must be provided if T == -execute, otherwise
  *          it's erroneous as compilation only takes place.
- * 
+ *
  *      I:
  *          Used to specify the INPUT source file to operate on, this must be
  *          provided, this tag is NOT optional
  *
- * 
+ *
  *  Notes:
  *      These tags have one-time use, using them more than once will result
  *      in template compilation errors.
- * 
+ *
  *      Lines beginning with # or // in the template file are comments and
  *      are ignored by the template parser.
- * 
+ *
  *      Whitespace is optional, with exception to the colon ':' between the
  *      tag and it's assignment value/
- * 
+ *
  *      The template compiler will detect erronrous tags (optional tags
  *      that need not be set), as well as missing tags, and error accordingly
  *      this will result in the task failing.
@@ -256,10 +256,10 @@ typedef struct {
  */
 bool task_template_generate(task_template_t *template, char tag, const char *file, size_t line, const char *value) {
     char **destval = NULL;
-    
+
     if (!template)
         return false;
-    
+
     switch(tag) {
         case 'D': destval = &template->description;    break;
         case 'F': destval = &template->failuremessage; break;
@@ -275,7 +275,7 @@ bool task_template_generate(task_template_t *template, char tag, const char *fil
             );
             return false;
     }
-    
+
     /*
      * Ensure if for the given tag, there already exists a
      * assigned value.
@@ -287,26 +287,26 @@ bool task_template_generate(task_template_t *template, char tag, const char *fil
         );
         return false;
     }
-    
+
     /*
      * Strip any whitespace that might exist in the value for assignments
      * like "D:      foo"
      */
     if (value && *value && (*value == ' ' || *value == '\t'))
         value++;
-    
+
     /*
      * Value will contain a newline character at the end, we need to strip
      * this otherwise kaboom, seriously, kaboom :P
      */
     *strrchr(value, '\n')='\0';
-    
+
     /*
      * Now allocate and set the actual value for the specific tag. Which
      * was properly selected and can be accessed with *destval.
      */
     *destval = util_strdup(value);
-    
+
     return true;
 }
 
@@ -315,17 +315,17 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp)
     char  *back = NULL;
     size_t size = 0;
     size_t line = 1;
-    
+
     if (!template)
         return false;
-    
+
     /* top down parsing */
     while (util_getline(&back, &size, fp) != EOF) {
         /* skip whitespace */
         data = back;
         if (*data && (*data == ' ' || *data == '\t'))
             data++;
-            
+
         switch (*data) {
             /*
              * Handle comments inside task template files.  We're strict
@@ -335,13 +335,13 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp)
                 if (data[1] != '/') {
                     con_printmsg(LVL_ERROR, file, line, "template parse error",
                         "invalid character `/`, perhaps you meant `//` ?");
-                    
+
                     mem_d(back);
                     return false;
                 }
             case '#':
                 break;
-                
+
             /*
              * Empty newlines are acceptable as well, so we handle that here
              * despite being just odd since there should't be that many
@@ -350,8 +350,8 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp)
             case '\r':
             case '\n':
                 break;
-                
-                
+
+
             /*
              * Now begin the actual "tag" stuff.  This works as you expect
              * it to.
@@ -377,7 +377,7 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp)
                     goto failure;
                 }
                 break;
-            
+
             /*
              * Match requires it's own system since we allow multiple M's
              * for multi-line matching.
@@ -392,21 +392,21 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp)
                     );
                     goto failure;
                 }
-                
+
                 if (value && *value && (*value == ' ' || *value == '\t'))
                     value++;
-    
+
                 /*
                  * Value will contain a newline character at the end, we need to strip
                  * this otherwise kaboom, seriously, kaboom :P
                  */
                 *strrchr(value, '\n')='\0';
-                
+
                 vec_push(template->comparematch, util_strdup(value));
-                
+
                 break;
             }
-            
+
             default:
                 con_printmsg(LVL_ERROR, file, line, "template parse error",
                     "invalid tag `%c`", *data
@@ -414,7 +414,7 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp)
                 goto failure;
             /* no break required */
         }
-        
+
         /* update line and free old sata */
         line++;
         mem_d(back);
@@ -423,7 +423,7 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp)
     if (back)
         mem_d(back);
     return true;
-    
+
 failure:
     if (back)
         mem_d (back);
@@ -437,7 +437,7 @@ failure:
 void task_template_nullify(task_template_t *template) {
     if (!template)
         return;
-        
+
     template->description    = NULL;
     template->failuremessage = NULL;
     template->successmessage = NULL;
@@ -454,14 +454,14 @@ task_template_t *task_template_compile(const char *file, const char *dir) {
     char             fullfile[4096];
     FILE            *tempfile = NULL;
     task_template_t *template = NULL;
-    
+
     memset  (fullfile, 0, sizeof(fullfile));
     snprintf(fullfile,    sizeof(fullfile), "%s/%s", dir, file);
-    
+
     tempfile = fopen(fullfile, "r");
     template = mem_a(sizeof(task_template_t));
     task_template_nullify(template);
-    
+
     /*
      * Esnure the file even exists for the task, this is pretty useless
      * to even do.
@@ -472,12 +472,12 @@ task_template_t *task_template_compile(const char *file, const char *dir) {
         );
         goto failure;
     }
-    
+
     if (!task_template_parse(file, template, tempfile)) {
         con_err("template parse error: error during parsing\n");
         goto failure;
     }
-    
+
     /*
      * Regardless procedure type, the following tags must exist:
      *  D
@@ -501,7 +501,7 @@ task_template_t *task_template_compile(const char *file, const char *dir) {
         con_err("template compile error: %s missing `I:` tag\n", file);
         goto failure;
     }
-    
+
     /*
      * Now lets compile the template, compilation is really just
      * the process of validating the input.
@@ -525,11 +525,11 @@ task_template_t *task_template_compile(const char *file, const char *dir) {
         con_err("template compile error: %s invalid procedure type: %s\n", file, template->proceduretype);
         goto failure;
     }
-    
+
 success:
     fclose(tempfile);
     return template;
-    
+
 failure:
     /*
      * The file might not exist and we jump here when that doesn't happen
@@ -538,14 +538,14 @@ failure:
     if (tempfile)
         fclose(tempfile);
     mem_d (template);
-    
+
     return NULL;
 }
 
 void task_template_destroy(task_template_t **template) {
     if (!template)
         return;
-        
+
     if ((*template)->description)    mem_d((*template)->description);
     if ((*template)->failuremessage) mem_d((*template)->failuremessage);
     if ((*template)->successmessage) mem_d((*template)->successmessage);
@@ -553,7 +553,7 @@ void task_template_destroy(task_template_t **template) {
     if ((*template)->compileflags)   mem_d((*template)->compileflags);
     if ((*template)->executeflags)   mem_d((*template)->executeflags);
     if ((*template)->sourcefile)     mem_d((*template)->sourcefile);
-    
+
     /*
      * Delete all allocated string for task template then destroy the
      * main vector.
@@ -562,10 +562,10 @@ void task_template_destroy(task_template_t **template) {
         size_t i = 0;
         for (; i < vec_size((*template)->comparematch); i++)
             mem_d((*template)->comparematch[i]);
-            
+
         vec_free((*template)->comparematch);
     }
-    
+
     /*
      * Nullify all the template members otherwise NULL comparision
      * checks will fail if template pointer is reused.
@@ -600,22 +600,22 @@ bool task_propagate(const char *curdir) {
     struct stat      directory;
     char             buffer[4096];
     size_t           found = 0;
-    
+
     dir = opendir(curdir);
-    
+
     while ((files = readdir(dir))) {
         memset  (buffer, 0,sizeof(buffer));
         snprintf(buffer,   sizeof(buffer), "%s/%s", curdir, files->d_name);
-        
+
         if (stat(buffer, &directory) == -1) {
             con_err("internal error: stat failed, aborting\n");
             abort();
         }
-        
+
         /* skip directories */
         if (S_ISDIR(directory.st_mode))
             continue;
-            
+
         /*
          * We made it here, which concludes the file/directory is not
          * actually a directory, so it must be a file :)
@@ -624,7 +624,7 @@ bool task_propagate(const char *curdir) {
             task_template_t *template = task_template_compile(files->d_name, curdir);
             char             buf[4096]; /* one page should be enough */
             task_t           task;
-            
+
             util_debug("TEST", "compiling task template: %s/%s\n", curdir, files->d_name);
             found ++;
             if (!template) {
@@ -637,7 +637,7 @@ bool task_propagate(const char *curdir) {
              * so we don't trample over an existing one.
              */
             template->tempfilename = tempnam(curdir, "TMPDAT");
-            
+
             /*
              * Generate the command required to open a pipe to a process
              * which will be refered to with a handle in the task for
@@ -651,7 +651,7 @@ bool task_propagate(const char *curdir) {
                 template->compileflags,
                 template->tempfilename
             );
-            
+
             /*
              * The task template was compiled, now lets create a task from
              * the template data which has now been propagated.
@@ -662,9 +662,9 @@ bool task_propagate(const char *curdir) {
                 success = false;
                 continue;
             }
-            
+
             util_debug("TEST", "executing test: `%s` [%s]\n", template->description, buf);
-            
+
             /*
              * Open up some file desciptors for logging the stdout/stderr
              * to our own.
@@ -676,7 +676,7 @@ bool task_propagate(const char *curdir) {
                 con_err("error opening %s for stdout\n", buf);
                 continue;
             }
-            
+
             memset  (buf,0,sizeof(buf));
             snprintf(buf,  sizeof(buf), "%s.stderr", template->tempfilename);
             task.stderrlogfile = util_strdup(buf);
@@ -684,16 +684,16 @@ bool task_propagate(const char *curdir) {
                 con_err("error opening %s for stderr\n", buf);
                 continue;
             }
-            
+
             vec_push(task_tasks, task);
         }
     }
-    
+
     util_debug("TEST", "compiled %d task template files out of %d\n",
         vec_size(task_tasks),
         found
     );
-    
+
     closedir(dir);
     return success;
 }
@@ -708,7 +708,7 @@ void task_cleanup(const char *curdir) {
     char             buffer[4096];
 
     dir = opendir(curdir);
-    
+
     while ((files = readdir(dir))) {
         memset(buffer, 0, sizeof(buffer));
         if (strstr(files->d_name, "TMP")) {
@@ -719,7 +719,7 @@ void task_cleanup(const char *curdir) {
                 util_debug("TEST", "removed temporary file: %s\n", buffer);
         }
     }
-    
+
     closedir(dir);
 }
 
@@ -733,7 +733,7 @@ void task_precleanup(const char *curdir) {
     char             buffer[4096];
 
     dir = opendir(curdir);
-    
+
     while ((files = readdir(dir))) {
         memset(buffer, 0, sizeof(buffer));
         if (strstr(files->d_name, "TMP")     ||
@@ -747,7 +747,7 @@ void task_precleanup(const char *curdir) {
                 util_debug("TEST", "removed temporary file: %s\n", buffer);
         }
     }
-    
+
     closedir(dir);
 }
 
@@ -766,7 +766,7 @@ void task_destroy(const char *curdir) {
         if (task_tasks[i].runhandles) task_pclose(task_tasks[i].runhandles);
         if (task_tasks[i].stdoutlog)  fclose     (task_tasks[i].stdoutlog);
         if (task_tasks[i].stderrlog)  fclose     (task_tasks[i].stderrlog);
-        
+
         /*
          * Only remove the log files if the test actually compiled otherwise
          * forget about it.
@@ -776,21 +776,21 @@ void task_destroy(const char *curdir) {
                 con_err("error removing stdout log file: %s\n", task_tasks[i].stdoutlogfile);
             else
                 util_debug("TEST", "removed stdout log file: %s\n", task_tasks[i].stdoutlogfile);
-            
+
             if (remove(task_tasks[i].stderrlogfile))
                 con_err("error removing stderr log file: %s\n", task_tasks[i].stderrlogfile);
             else
                 util_debug("TEST", "removed stderr log file: %s\n", task_tasks[i].stderrlogfile);
         }
-        
+
         /* 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);
     }
     vec_free(task_tasks);
-    
+
     /*
      * Cleanup outside stuff like temporary files.
      */
@@ -807,7 +807,7 @@ bool task_execute(task_template_t *template) {
     FILE    *execute;
     char     buffer[4096];
     memset  (buffer,0,sizeof(buffer));
-    
+
     /*
      * Drop the execution flags for the QCVM if none where
      * actually specified.
@@ -824,16 +824,16 @@ bool task_execute(task_template_t *template) {
             template->tempfilename
         );
     }
-    
+
     util_debug("TEST", "executing qcvm: `%s` [%s]\n",
         template->description,
         buffer
     );
-    
+
     execute = popen(buffer, "r");
     if (!execute)
         return false;
-        
+
     /*
      * Now lets read the lines and compare them to the matches we expect
      * and handle accordingly.
@@ -852,15 +852,15 @@ bool task_execute(task_template_t *template) {
                 pclose(execute);
                 return false;
             }
-            
-            /* 
+
+            /*
              * Trim newlines from data since they will just break our
              * ability to properly validate matches.
              */
             if  (strrchr(data, '\n'))
                 *strrchr(data, '\n') = '\0';
-            
-            
+
+
             /*
              * We only care about the last line from the output for now
              * implementing multi-line match is TODO.
@@ -885,9 +885,9 @@ void task_schedualize() {
     char  *data     = NULL;
     size_t size     = 0;
     size_t i;
-    
+
     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);
         /*
@@ -896,30 +896,30 @@ void task_schedualize() {
          */
         if (!strcmp(task_tasks[i].template->proceduretype, "-execute"))
             execute = true;
-            
+
         /*
          * We assume it compiled before we actually compiled :).  On error
          * we change the value
          */
         task_tasks[i].compiled = true;
-        
+
         /*
          * Read data from stdout first and pipe that stuff into a log file
          * then we do the same for stderr.
-         */    
+         */
         while (util_getline(&data, &size, task_tasks[i].runhandles[1]) != EOF) {
             fputs(data, task_tasks[i].stdoutlog);
-            
+
             if (strstr(data, "failed to open file"))
                 execute = false;
-            
+
             fflush(task_tasks[i].stdoutlog);
         }
         while (util_getline(&data, &size, task_tasks[i].runhandles[2]) != EOF) {
             /*
              * If a string contains an error we just dissalow execution
              * of it in the vm.
-             * 
+             *
              * TODO: make this more percise, e.g if we print a warning
              * that refers to a variable named error, or something like
              * that .. then this will blowup :P
@@ -928,11 +928,11 @@ void task_schedualize() {
                 execute                = false;
                 task_tasks[i].compiled = false;
             }
-            
+
             fputs(data, task_tasks[i].stderrlog);
             fflush(task_tasks[i].stdoutlog);
         }
-        
+
         /*
          * If we made it here that concludes the task is to be executed
          * in the virtual machine.
@@ -947,7 +947,7 @@ void task_schedualize() {
             );
             continue;
         }
-        
+
         con_out("test succeeded: `%s` [%s]\n",
             task_tasks[i].template->description,
             (task_tasks[i].template->successmessage) ?
@@ -965,10 +965,10 @@ void task_schedualize() {
  * schedualizes them (executes them) and actually reports errors and
  * what not.  It then proceeds to destroy the tasks and return memory
  * it's the engine :)
- * 
+ *
  * It returns true of tests could be propagated, otherwise it returns
  * false.
- * 
+ *
  * It expects con_init() was called before hand.
  */
 bool test_perform(const char *curdir) {
@@ -987,7 +987,7 @@ bool test_perform(const char *curdir) {
      */
     task_schedualize();
     task_destroy(curdir);
-    
+
     return true;
 }
 
@@ -1024,9 +1024,9 @@ static bool parsecmd(const char *optname, int *argc_, char ***argv_, char **out,
 int main(int argc, char **argv) {
     char         *redirout = (char*)stdout;
     char         *redirerr = (char*)stderr;
-    
+
     con_init();
-    
+
     /*
      * Command line option parsing commences now We only need to support
      * a few things in the test suite.
@@ -1040,7 +1040,7 @@ int main(int argc, char **argv) {
                 continue;
             if (parsecmd("redirerr", &argc, &argv, &redirerr, 1, false))
                 continue;
-            
+
             con_change(redirout, redirerr);
 
             if (!strcmp(argv[0]+1, "debug")) {
@@ -1055,7 +1055,7 @@ int main(int argc, char **argv) {
                 con_color(0);
                 continue;
             }
-            
+
             con_err("invalid argument %s\n", argv[0]+1);
             return -1;
         }
diff --git a/util.c b/util.c
index 49db70728787a7777e510afb5ba295d447fa888b..d7e325dbde1bad4842063837ac9d17fc3dec0ab1 100644 (file)
--- a/util.c
+++ b/util.c
@@ -254,7 +254,7 @@ void util_debug(const char *area, const char *ms, ...) {
 
     va_start(va, ms);
     con_out ("[%s] ", area);
-    con_vout(ms, va); 
+    con_vout(ms, va);
     va_end  (va);
 }
 
@@ -528,7 +528,7 @@ typedef struct hash_node_t {
 /*
  * x86 and x86_64 optimized murmur hash functions for the hashtable
  * we have individual implementations for optimal performance.
- * 
+ *
  * Forced inlined as we wrap these up in the actual utility function
  * below.  These should be autovectorized by gcc.
  */
@@ -542,20 +542,20 @@ GMQCC_INLINE uint32_t util_hthashfunc(hash_table_t *ht, const char *key, registe
     const uint64_t      *beg   = (const uint64_t*)key;
     const uint64_t      *end   = beg + (size / 8);
     const unsigned char *final = NULL;
-    
+
     while (beg != end) {
         alias = *beg++;
-        
+
         alias *= mix;
         alias ^= alias >> rot;
         alias *= mix;
-        
+
         hash  ^= alias;
         hash  *= mix;
     }
-    
+
     final = (const unsigned char *)beg;
-    
+
     switch (size & 7) {
         case 7: hash ^= (uint64_t)(final[6]) << 48;
         case 6: hash ^= (uint64_t)(final[5]) << 40;
@@ -566,14 +566,14 @@ GMQCC_INLINE uint32_t util_hthashfunc(hash_table_t *ht, const char *key, registe
         case 1: hash ^= (uint64_t)(final[0]);
                 hash *= mix;
     }
-    
+
     hash ^= hash >> rot;
     hash *= mix;
     hash ^= hash >> rot;
-    
+
     return (uint32_t)(hash % ht->size);
 }
-    
+
 #else
 GMQCC_INLINE uint32_t util_hthashfunc(hash_table_t *ht, const char *key, register size_t seed) {
     const uint32_t       mix   = 0x5BD1E995;
@@ -582,32 +582,32 @@ GMQCC_INLINE uint32_t util_hthashfunc(hash_table_t *ht, const char *key, registe
     uint32_t             hash  = seed ^ size;
     uint32_t             alias = 0;
     const unsigned char *data  = (const unsigned char*)ket;
-    
+
     while (size >= 4) {
         alias = *(uint32_t*)data;
-        
+
         alias *= mix;
         alias ^= alias >> rot;
         alias *= mix;
-        
+
         hash  *= mix;
         hash  ^= alias;
-        
+
         data += 4;
         size -= 4;
     }
-    
+
     switch (size) {
         case 3: hash ^= data[2] << 16;
         case 2: hash ^= data[1] << 8;
         case 1: hash ^= data[0];
                 hash *= mix;
     }
-    
+
     hash ^= hash >> 13;
     hash *= mix;
     hash ^= hash >> 15;
-    
+
     return hash % ht->size;
 }
 #endif
@@ -616,11 +616,11 @@ GMQCC_INLINE uint32_t util_hthashfunc(hash_table_t *ht, const char *key, registe
 size_t util_hthash(hash_table_t *ht, const char *key) {
     static   size_t seed = 0;
     register size_t hash = util_hthashfunc(ht, key, util_crc32_table[seed]);
-    
+
     /* reset seed */
     if (seed >= sizeof(util_crc32_table) / sizeof(*util_crc32_table))
         seed  = 0;
-        
+
     return hash;
 }
 
@@ -628,15 +628,15 @@ hash_node_t *_util_htnewpair(const char *key, void *value) {
     hash_node_t *node;
     if (!(node = mem_a(sizeof(hash_node_t))))
         return NULL;
-        
+
     if (!(node->key = util_strdup(key))) {
         mem_d(node);
         return NULL;
     }
-    
+
     node->value = value;
     node->next  = NULL;
-    
+
     return node;
 }
 
@@ -651,18 +651,18 @@ hash_table_t *util_htnew(size_t size) {
     hash_table_t *hashtable = NULL;
     if (size < 1)
         return NULL;
-        
+
     if (!(hashtable = mem_a(sizeof(hash_table_t))))
         return NULL;
-        
+
     if (!(hashtable->table = mem_a(sizeof(hash_node_t*) * size))) {
         mem_d(hashtable);
         return NULL;
     }
-    
+
     hashtable->size = size;
     memset(hashtable->table, 0, sizeof(hash_node_t*) * size);
-    
+
     return hashtable;
 }
 
@@ -670,12 +670,12 @@ void util_htseth(hash_table_t *ht, const char *key, size_t bin, void *value) {
     hash_node_t *newnode = NULL;
     hash_node_t *next    = NULL;
     hash_node_t *last    = NULL;
-    
+
     next = ht->table[bin];
-    
+
     while (next && next->key && strcmp(key, next->key) > 0)
         last = next, next = next->next;
-    
+
     /* already in table, do a replace */
     if (next && next->key && strcmp(key, next->key) == 0) {
         next->value = value;
@@ -700,13 +700,13 @@ void util_htset(hash_table_t *ht, const char *key, void *value) {
 
 void *util_htgeth(hash_table_t *ht, const char *key, size_t bin) {
     hash_node_t *pair = ht->table[bin];
-    
+
     while (pair && pair->key && strcmp(key, pair->key) > 0)
         pair = pair->next;
-        
+
     if (!pair || !pair->key || strcmp(key, pair->key) != 0)
         return NULL;
-        
+
     return pair->value;
 }
 
@@ -723,7 +723,7 @@ void util_htdel(hash_table_t *ht) {
     for (; i < ht->size; i++) {
         hash_node_t *n = ht->table[i];
         hash_node_t *p;
-        
+
         /* free in list */
         while (n) {
             if (n->key)
@@ -732,7 +732,7 @@ void util_htdel(hash_table_t *ht) {
             n = n->next;
             mem_d(p);
         }
-        
+
     }
     /* free table */
     mem_d(ht->table);