/*
- * Copyright (C) 2012, 2013
+ * Copyright (C) 2012, 2013, 2014
* Dale Weiler
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
+#define GMQCC_PLATFORM_HEADER /* TODO: eliminate! */
#include <stdlib.h>
#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
#include "gmqcc.h"
+#include "platform.h"
static const char *task_bins[] = {
"./gmqcc",
#include <dirent.h>
#include <unistd.h>
typedef struct {
- FILE *handles[3];
- int pipes [3];
+ fs_file_t *handles[3];
+ int pipes [3];
int stderr_fd;
int stdout_fd;
int pid;
} popen_t;
-static FILE ** task_popen(const char *command, const char *mode) {
+static fs_file_t **task_popen(const char *command, const char *mode) {
int inhandle [2];
int outhandle [2];
int errhandle [2];
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);
+ data->handles[0] = (fs_file_t*)fdopen(inhandle [1], "w");
+ data->handles[1] = (fs_file_t*)fdopen(outhandle[0], mode);
+ data->handles[2] = (fs_file_t*)fdopen(errhandle[0], mode);
/* sigh */
vec_free(argv);
return NULL;
}
-static int task_pclose(FILE **handles) {
+static int task_pclose(fs_file_t **handles) {
popen_t *data = (popen_t*)handles;
int status = 0;
return status;
}
#else
+ #include <sys/stat.h>
typedef struct {
- FILE *handles[3];
- char name_err[L_tmpnam];
- char name_out[L_tmpnam];
+ fs_file_t *handles[3];
+ char name_err[L_tmpnam];
+ char name_out[L_tmpnam];
} popen_t;
- static FILE **task_popen(const char *command, const char *mode) {
+ static fs_file_t **task_popen(const char *command, const char *mode) {
char *cmd = NULL;
popen_t *open = (popen_t*)mem_a(sizeof(popen_t));
- platform_tmpnam(open->name_err);
- platform_tmpnam(open->name_out);
+ tmpnam(open->name_err);
+ tmpnam(open->name_out);
(void)mode; /* excluded */
return open->handles;
}
- static int task_pclose(FILE **files) {
+ static int task_pclose(fs_file_t **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);
return true;
}
-static 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, fs_file_t *fp, size_t *pad) {
char *data = NULL;
char *back = NULL;
size_t size = 0;
return false;
/* top down parsing */
- while (fs_file_getline(&back, &size, fp) != EOF) {
+ while (fs_file_getline(&back, &size, fp) != FS_FILE_EOF) {
/* skip whitespace */
data = back;
if (*data && (*data == ' ' || *data == '\t'))
/* a page should be enough */
char fullfile[4096];
size_t filepadd = 0;
- FILE *tempfile = NULL;
+ fs_file_t *tempfile = NULL;
task_template_t *tmpl = NULL;
- platform_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));
*/
typedef struct {
task_template_t *tmpl;
- FILE **runhandles;
- FILE *stderrlog;
- FILE *stdoutlog;
+ fs_file_t **runhandles;
+ fs_file_t *stderrlog;
+ fs_file_t *stdoutlog;
char *stdoutlogfile;
char *stderrlogfile;
bool compiled;
*/
static bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
bool success = true;
- DIR *dir;
- struct dirent *files;
+ fs_dir_t *dir;
+ fs_dirent_t *files;
struct stat directory;
char buffer[4096];
size_t found = 0;
dir = fs_dir_open(directories[i]);
while ((files = fs_dir_read(dir))) {
- platform_snprintf(buffer, sizeof(buffer), "%s/%s", directories[i], files->d_name);
+ util_snprintf(buffer, sizeof(buffer), "%s/%s", directories[i], files->d_name);
if (stat(buffer, &directory) == -1) {
con_err("internal error: stat failed, aborting\n");
abort();
* so we don't trample over an existing one.
*/
tmpl->tempfilename = NULL;
- util_asprintf(&tmpl->tempfilename, "%s/TMPDAT.%s", directories[i], files->d_name);
+ util_asprintf(&tmpl->tempfilename, "%s/TMPDAT.%s.dat", directories[i], files->d_name);
/*
* Additional QCFLAGS enviroment variable may be used
if (strcmp(tmpl->proceduretype, "-pp")) {
if (qcflags) {
if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
- platform_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],
directories[i],
tmpl->sourcefile,
tmpl->tempfilename
);
} else {
- platform_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,
}
} else {
if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
- platform_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],
directories[i],
tmpl->sourcefile,
tmpl->tempfilename
);
} else {
- platform_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,
} else {
/* Preprocessing (qcflags mean shit all here we don't allow them) */
if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
- platform_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],
directories[i],
tmpl->sourcefile,
tmpl->tempfilename
);
} else {
- platform_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,
* Open up some file desciptors for logging the stdout/stderr
* to our own.
*/
- platform_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;
}
- platform_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);
* left behind from a previous invoke of the test-suite.
*/
static void task_precleanup(const char *curdir) {
- DIR *dir;
- struct dirent *files;
- char buffer[4096];
+ fs_dir_t *dir;
+ fs_dirent_t *files;
+ char buffer[4096];
dir = fs_dir_open(curdir);
while ((files = fs_dir_read(dir))) {
if (strstr(files->d_name, "TMP") ||
strstr(files->d_name, ".stdout") ||
- strstr(files->d_name, ".stderr"))
+ strstr(files->d_name, ".stderr") ||
+ strstr(files->d_name, ".dat"))
{
- platform_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);
}
bool success = true;
bool process = true;
int retval = EXIT_SUCCESS;
- FILE *execute;
+ fs_file_t *execute;
char buffer[4096];
task_template_t *tmpl = task_tasks[i].tmpl;
* actually specified.
*/
if (!strcmp(tmpl->executeflags, "$null")) {
- platform_snprintf(buffer, sizeof(buffer), "%s %s",
+ util_snprintf(buffer, sizeof(buffer), "%s %s",
task_bins[TASK_EXECUTE],
tmpl->tempfilename
);
} else {
- platform_snprintf(buffer, sizeof(buffer), "%s %s %s",
+ util_snprintf(buffer, sizeof(buffer), "%s %s %s",
task_bins[TASK_EXECUTE],
tmpl->executeflags,
tmpl->tempfilename
);
}
- execute = popen(buffer, "r");
+ execute = (fs_file_t*)popen(buffer, "r");
if (!execute)
return false;
} else if (!strcmp(tmpl->proceduretype, "-pp")) {
size_t size = 0;
size_t compare = 0;
- while (fs_file_getline(&data, &size, execute) != EOF) {
+ while (fs_file_getline(&data, &size, execute) != FS_FILE_EOF) {
if (!strcmp(data, "No main function found\n")) {
con_err("test failure: `%s` (No main function found) [%s]\n",
tmpl->description,
if (!process)
fs_file_close(execute);
else
- pclose(execute);
+ pclose((FILE*)execute);
return false;
}
}
if (process)
- retval = pclose(execute);
+ retval = pclose((FILE*)execute);
else
fs_file_close(execute);
size_t j = 0;
size_t failed = 0;
- platform_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]));
- platform_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]), "");
* Read data from stdout first and pipe that stuff into a log file
* then we do the same for stderr.
*/
- while (fs_file_getline(&data, &size, task_tasks[i].runhandles[1]) != EOF) {
+ while (fs_file_getline(&data, &size, task_tasks[i].runhandles[1]) != FS_FILE_EOF) {
fs_file_puts(task_tasks[i].stdoutlog, data);
if (strstr(data, "failed to open file")) {
execute = false;
}
}
- while (fs_file_getline(&data, &size, task_tasks[i].runhandles[2]) != EOF) {
+ while (fs_file_getline(&data, &size, task_tasks[i].runhandles[2]) != FS_FILE_EOF) {
/*
* If a string contains an error we just dissalow execution
* of it in the vm.
}
fs_file_puts (task_tasks[i].stderrlog, data);
- fflush(task_tasks[i].stderrlog); /* fast flush for read */
+ fs_file_flush(task_tasks[i].stderrlog); /* fast flush for read */
}
if (!task_tasks[i].compiled && strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) {