root/dstress.c

/*
 * core test tool for the DStress test suite
 * http://dstress.kuehne.cn
 *
 * Copyright (C)
 *  2005, 2006 Thomas Kuehne <thomas@kuehne.cn>
 *  2005 Carlos Santander (Windows files)
 *  2005 Stewart Gordon <smjg_1998@yahoo.com> (Windows crashRun)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * $HeadURL$
 * $Date$
 * $Author$
 *
 */

/* Beware: the code doesn't care about freeing allocated memory etc. ... */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>

/* number's choice: XOR and printf :) */
#define MODE_RUN    (0x10000)
#define MODE_NORUN  (0x01000)
#define MODE_COMPILE    (0x00100)
#define MODE_NOCOMPILE  (0x00010)
#define MODE_TORTURE    (0x00002)

#define RES_BASE_MASK   (0xFFFFFF0)
#define RES_PASS    (0x1000000)
#define RES_XFAIL   (0x0100000)
#define RES_XPASS   (0x0010000)
#define RES_FAIL    (0x0001000)
#define RES_ERROR   (0x0000100)
#define RES_UNTESTED    (0x0000010)
#define RES_BAD_GDB (0x0000004)
#define RES_BAD_MSG (0x0000002)

#if defined(__GNU_LIBRARY__) || defined(__GLIBC__)
#define USE_POSIX 1
#endif

#if defined(linux) || defined(__FreeBSD__) || defined(__OpenBSD__)
#define USE_POSIX 1
#endif

#if defined(__APPLE__) && defined(__MACH__)
#define USE_POSIX 1
#endif

#if defined(WIN) || defined(WIN32) || defined(WIN64)
#define USE_WINDOWS 1
#endif

/* prefere USE_POSIX over USE_WINDOWS if both APIs are detected */
#ifdef USE_POSIX

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <regex.h>
#include <limits.h>

/* not every STDLIB propperly supports C99's "%z" for printf formating */
/* (I just love those non-conforming headers...) */
#undef ZU

#if !defined(ZU) && defined(SSIZE_MAX)
#if defined(INT_MAX) && SSIZE_MAX == INT_MAX
#define ZU "%u"
#elif defined(LONG_MAX) && SSIZE_MAX == LONG_MAX
#define ZU "%lu"
#elif defined(LLONG_MAX) && SSIZE_MAX == LLONG_MAX
#define ZU "%llu"
#elif defined(SHRT_MAX) && SSIZE_MAX == SHRT_MAX
#define ZU "%hu"
#endif
#endif /* SSIZE_MAX */

#if !defined(ZU) && defined(SIZE_T_MAX)
#if defined(UINT_MAX) && SIZE_T_MAX == UINT_MAX
#define ZU "%u"
#elif defined(ULONG_MAX) && SIZE_T_MAX == ULONG_MAX
#define ZU "%lu"
#elif defined(ULLONG_MAX) && SIZE_T_MAX == ULLONG_MAX
#define ZU "%llu"
#elif defined(USHRT_MAX) && SIZE_T_MAX == USHRT_MAX
#define ZU "%hu"
#endif
#endif /* SIZE_T_MAX */

#ifndef ZU
#include <stdint.h>
#undef ZU
#ifdef PTRDIFF_MAX
#if defined(INT_MAX) && PTRDIFF_MAX == INT_MAX
#define ZU "%u"
#elif defined(LONG_MAX) && PTRDIFF_MAX == LONG_MAX
#define ZU "%lu"
#elif defined(LLONG_MAX) && PTRDIFF_MAX == LLONG_MAX
#define ZU "%llu"
#elif defined(SHRT_MAX) && PTRDIFF_MAX == SHRT_MAX
#define ZU "%hu"
#endif
#endif
#endif /* PTRDIFF_MAX */

#ifndef ZU
#error what is the size of a pointer?
#endif

#else
#ifdef USE_WINDOWS

#include <process.h>
typedef int pid_t;

#include <windows.h>
#define snprintf _snprintf
#ifndef INVALID_FILE_SIZE
#define INVALID_FILE_SIZE (-1)
#endif

/* not every STDLIB supports C99's "%z" for printf formating */
#ifdef WIN32
#define ZU "%u"
#else
#ifdef WIN64
#define ZU "%llu"
#else
#error what is the size of a pointer?
#endif
#endif

#else
#error neither POSIX nor MSWindows API detected
#endif /* USE_WINDOWS else */
#endif /* USE_POSIX else */

#define TORTURE_PREFIX      "torture-"

#ifdef USE_POSIX
#define     CRASH_RUN   "./crashRun 10 256"
#ifdef USE_VALGRIND
#define     VALGRIND    "valgrind --leak-check=no -q --suppressions=valgrind.suppress"  
#else
#define     VALGRIND    NULL
#endif
#define     TMP_DIR     "./obj"
#define     RM_DIR      "rm -rf"
#else
#ifdef USE_WINDOWS
#define     VALGRIND    NULL
#define     TMP_DIR     ".\\obj"
#define     RM_DIR      "rd /sq"
#else
#error OS dependent file names not defined
#endif
#endif

char* tmp_dir;

#ifdef USE_WINDOWS
HANDLE originalStdout, originalStderr;
#endif

const char* torture[] = {
    /* 0 args */
    "",

    /* 1 args */
    "-g",
    "-inline",
    "-fPIC",
    "-O",
    "-release",

    /* 2 args */
    "-g -inline",
    "-g -fPIC",
    "-g -O",
    "-g -release",
    "-inline -fPIC",
    "-inline -O",
    "-inline -release",
    "-fPIC -O",
    "-fPIC -release",
    "-O -release",

    /* 3 args */
    "-g -inline -fPIC",
    "-g -inline -O",
    "-g -inline -release",
    "-g -fPIC -O",
    "-g -fPIC -release",
    "-g -O -release",
    "-inline -fPIC -O",
    "-inline -fPIC -release",
    "-inline -O -release",
    "-fPIC -O -release",

    /* 4 args */
    "-g -inline -fPIC -O",
    "-g -inline -fPIC -release",
    "-g -fPIC -O -release",
    "-inline -fPIC -O -release",

    /* 5 args */
    "-g -inline -fPIC -O -release",

    /* 4 args - ommitted */
    "-g -inline -O -release"
};

/* secure malloc */
void *xmalloc(size_t size){
    void *p = malloc(size);
    if (p == NULL){
        fprintf(stderr, "Failed to allocate " ZU " bytes!\n", size);
        exit(EXIT_FAILURE);
    }
    return p;
}
#define malloc xmalloc

/* secure calloc */
void* xcalloc(size_t members, size_t size){
    void* ptr = calloc(members, size);
    if(ptr == NULL){
        fprintf(stderr, "Failed to allocate " ZU " elements"
            "(" ZU " bytes each)!\n", members, size);
        exit(EXIT_FAILURE);
    }
    return ptr;
}
#define calloc xcalloc


void printResult(int result, int modus, char* case_file, FILE* stream){
    char* msg = NULL;
#ifdef DEBUG
    fprintf(stderr, "case: %s, modus: %x, result: %x\n", case_file, modus,
            result);
#endif

    if(result & RES_PASS){
        msg = "PASS: ";
    }else if(result & RES_XFAIL){
        msg = "XFAIL:";
    }else if(result & RES_XPASS){
        msg = "XPASS:";
    }else if(result & RES_FAIL){
        msg = "FAIL: ";
    }else if(result & RES_ERROR){
        msg = "ERROR:";
    }

    fprintf(stream, "%s\t%s%s%s\n", msg, case_file,
            (result & RES_BAD_MSG) ? " [bad error message]" : "",
            (result & RES_BAD_GDB) ? " [bad debugger message]" : "");
}

char* strip(char* buffer){
    char* tmp = NULL;

    if(buffer!=NULL){
        while(isspace(buffer[0])){
            buffer++;
        }

        for(tmp=buffer+strlen(buffer)-1; isspace(tmp[0]); tmp=buffer+strlen(buffer)-1){
            tmp[0]='\x00';
        }
    }
    return buffer;
}

unsigned int genTempFileNameCount;
char* genTempFileName(){
    char* back;
    size_t len;

    len = strlen(tmp_dir) + 128;
    back = (char*) malloc(len);

#ifdef USE_POSIX
    snprintf(back, len, "%s/t%x-%x-%x.tmp", tmp_dir, getpid(), rand(), ++genTempFileNameCount);
#else
    snprintf(back, len, "%s\\t%x-%x-%x.tmp", tmp_dir, getpid(), rand(), ++genTempFileNameCount);
#endif

    return back;
}

/* cleanup "/" versus "\" in filenames */
char* cleanPathSeperator(char* filename){
    char* pos = NULL;
#ifdef USE_POSIX
    for(pos=strchr(filename, '\\'); pos; pos=strchr(filename, '\\')){
        *pos='/';
    }
#else
#if USE_WINDOWS
    for(pos=strchr(filename, '/'); pos; pos=strchr(filename, '/')){
        *pos='\\';
    }
#else

#error no cleanPathSeperator implementation available for this system

#endif /* USE_WINDOWS else */
#endif /* USE_POSIX else */
    return filename;
}

char* loadFile(char* filename, size_t* len){
#ifdef USE_POSIX
    char* back;
    struct stat fileInfo;
    int file = open(filename, O_RDONLY);

    back = NULL;

    if(errno == 0 && file != 0 && file != -1){
        if(0==fstat(file, &fileInfo)){
            back = (char*) malloc(fileInfo.st_size+1);
            fileInfo.st_size = read(file, back, fileInfo.st_size);
            if(fileInfo.st_size>=0){
                *(back+fileInfo.st_size) = '\x00';
                *len = fileInfo.st_size;
            }else{
                back = NULL;
                *len = 0;
            }
        }
        close(file);
    }

    if(back){
        return back;
    }

    fprintf(stderr, "File not found \"%s\" (%s)\n", filename, strerror(errno));
    exit(EXIT_FAILURE);
#else /* USE_POSIX */
#ifdef USE_WINDOWS
    /* @todo@ check for 32bit/64bit */
    char* back;
    DWORD size, numread;
    HANDLE file=CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL,
        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);

    back = NULL;
    size = 0;
    numread = 0;
    if (file != INVALID_HANDLE_VALUE){
        size = GetFileSize(file, NULL);
        if (size != INVALID_FILE_SIZE){
            back=malloc((size+1)*sizeof(char));
            if (ReadFile(file,back,size,&numread,NULL) == 1){
                if (numread==size){
                    *(back+size) = '\x00';
                    *len = size;
                }else{
                    back = NULL;
                    *len = 0;
                }
            }else{
                back = NULL;
                *len = 0;
            }
        }
        CloseHandle(file);
    }
    if(back){
        errno = 0;
        return back;
    }

    fprintf(stderr, "File not found \"%s\"\n", filename);
    exit(EXIT_FAILURE);
#else /* USE_WINDOWS */

#error no loadFile implementation present

#endif /* USE_WINDOWS */
#endif /* USE_POSIX else */
}

void writeFile(const char* filename, const char* content){
    size_t len;
    FILE* file;

    len = strlen(content);
    errno = 0;
    file = fopen(filename, "w+");

    if(errno == 0 && file != NULL){
        if((fwrite(content, sizeof(char), len, file) != len) || (errno != 0)){
            fprintf(stderr, "failed to write file \"%s\" (%s)\n", filename, strerror(errno));
            exit(EXIT_FAILURE);
        }
        if(fclose(file) || (errno != 0)){
            fprintf(stderr, "failed to close file \"%s\" (%s)\n", filename, strerror(errno));
            exit(EXIT_FAILURE);
        }
        return;
    }

    fprintf(stderr, "couldn't open file \"%s\" for writing (%s)\n", filename, strerror(errno));
    exit(EXIT_FAILURE);
}

/* query the environment for the compiler name */
char* getCompiler(void){
    char* back = getenv("DMD");

    if(back==NULL){
        back = "dmd";
    }

    return strip(cleanPathSeperator(back));
}

/* query the environment for the debugger name */
char* getGDB(void){
    char* back = getenv("GDB");

    if(back==NULL){
        back = "gdb";
    }

    return strip(cleanPathSeperator(back));
}

char* getTortureBlock(void){
    char* back = getenv("DSTRESS_TORTURE_BLOCK");

    if(back!=NULL){
        back = strip(back);
        if(strlen(back)<1){
            back = NULL;
        }
    }

    return back;
}

/* extract the FIRST occurance of a given TAG until the next linebreak */
char* getCaseFlag(const char* data, const char* tag){
    char* begin;
    char* end1;
    char* end2;
    char* back;

    begin = NULL;
    end1 = NULL;
    end2 = NULL;
    back = NULL;

    if(data!=NULL && tag!=NULL){
        begin = strstr(data, tag);
        if(begin!=NULL){
            begin = begin+strlen(tag);
            end1 = strstr(begin, "\n");
            end2 = strstr(begin, "\r");
            if(end2!=NULL && ((end1!=NULL && end2<end1) || end1==NULL)){
                end1=end2;
            }
            if(end1==NULL){
                end1 = begin + strlen(begin);
            }
            back = (char*) malloc(end1-begin+1);
            strncpy(back, begin, end1-begin);
            back[end1-begin]='\x00';
            return strip(back);
        }
    }

    back = (char*) malloc(1);
    back[0] = 0;
    return back;
}

/* check compile-time error messages */
int checkErrorMessage(const char* file, const char* line, const char* buffer){

    char* dmd;
    char* gdc;
    size_t len;
    int back;

    dmd = NULL;
    gdc = NULL;
    len = 0;
    back = 0;

    /* clean arguments */
    if(file && !file[0]){
        file = NULL;
    }

    if(line && !line[0]){
        line = NULL;
    }

    /* gen patterns*/
    if(file!=NULL){
        if(line!=NULL){
            len = strlen(file)+strlen(line)+3;
            dmd = (char*) malloc(len);
            snprintf(dmd, len, "%s(%s)", file, line);

            gdc = (char*) malloc(--len);
            snprintf(gdc, len, "%s:%s", file, line);
        }else{
            len = strlen(file)+2;
            dmd = (char*) malloc(len);
            snprintf(dmd, len, "%s(", file);

            gdc = (char*) malloc(len);
            snprintf(gdc, len, "%s:", file);
        }
    }else if(line!=NULL){
        len = strlen(line)+3;
        dmd = (char*) malloc(len);
        snprintf(dmd, len, "(%s)", line);

        gdc = (char*) malloc(--len);
        snprintf(gdc, len, ":%s", line);
    }else{
        return 1;
    }

    /* specific error messages */
#ifdef DEBUG
    fprintf(stderr, "pattern(dmd):\t%s\n", dmd);
    fprintf(stderr, "pattern(gdc):\t%s\n", gdc);
#endif

    if( (dmd!=NULL && strstr(buffer, dmd))
            || (gdc!=NULL && strstr(buffer, gdc))
            || (dmd==NULL && gdc==NULL)){
        back=1;
    }

    free(dmd);
    free(gdc);

    return back;
}

int checkRuntimeErrorMessage(const char* file, const char* line, const char* buffer){
    /* PhobosLong   dir/file.d(2)
     * Phobos   package.module(2)
     */

    char* phobos;
    char* phobosLong;

    const char* begin;
    const char* end;
    size_t len;

    int back=0;

    phobos = NULL;
    phobosLong = NULL;

    begin = NULL;
    end = NULL;
    len = 0;

    /* clean arguments */
    if(file && !file[0]){
        file = NULL;
    }

    if(line && !line[0]){
        line = NULL;
    }

    /* gen patterns*/
    if(file!=NULL){
        if(line!=NULL){
            len = strlen(file)+strlen(line)+3;
            phobos = (char*) malloc(len);
            begin=strrchr(file,'/');
            if(begin){
                begin++;
            }else{
                begin=strrchr(file,'\\');
                if(begin){
                    begin++;
                }else{
                    begin=file;
                }
            }
            end=strrchr(file,'.');
            strncat(phobos, begin, end-begin);
            snprintf(phobos, len, "%.*s(%s)",
                (int)(end-begin), begin,
                line);

            phobosLong = (char*) malloc(len);
            snprintf(phobosLong, len, "%s(%s)", file, line);
        }else{
            len = strlen(file)+2;
            phobos = (char*) malloc(len);
            begin=strrchr(file,'/');
            if(begin){
                begin++;
            }else{
                begin=strrchr(file,'\\');
                if(begin){
                    begin++;
                }else{
                    begin=file;
                }
            }
            end=strrchr(file,'.');
            snprintf(phobos, len, "%.*s(", (int)(end-begin), begin);

            phobosLong = (char*) malloc(len);
            snprintf(phobosLong, len, "%s(", file);
        }
    }else if(line!=NULL){
        len = strlen(line)+3;
        phobos = (char*) malloc(len);
        snprintf(phobos, len, "(%s)", line);

        phobosLong=NULL;
    }else{
        return 1;
    }

    /* specific error messages */

#ifdef DEBUG
    fprintf(stderr, "pattern(phobosShort):\t%s\n", phobos);
    fprintf(stderr, "pattern(phobosLong):\t%s\n", phobosLong);
#endif

    if( (phobos && strstr(buffer, phobos))
        || (phobosLong && strstr(buffer, phobosLong)))
    {
        back=1;
    }

    free(phobos);
    if(phobosLong){
        free(phobosLong);
    }

    return back;
}

int hadExecCrash(const char* buffer){
    if(strstr(buffer, "Segmentation fault")
            || strstr(buffer, "Internal error")
            || strstr(buffer, "gcc.gnu.org/bugs")
            || strstr(buffer, "EXIT CODE: signal")
            || strstr(buffer, "Assertion failure")
            || strstr(buffer, "Access Violation")
            || strstr(buffer, "Invalid read of size")
            || strstr(buffer, "Conditional jump or move depends on uninitialised value")
            || strstr(buffer, "Use of uninitialised value of size"))
    {
        return 1;
    }
    return 0;
}

int conditionalResult(const char* buffer){
    if(strstr(buffer, "DSTRESS{XFAIL}")){
        return RES_XFAIL;
    }else if(strstr(buffer, "DSTRESS{XPASS}")){
        return RES_XPASS;
    }else if(strstr(buffer, "DSTRESS{FAIL}")){
        return RES_FAIL;
    }else if(strstr(buffer, "DSTRESS{PASS}")){
        return RES_PASS;
    }else if(strstr(buffer, "DSTRESS{ERROR}")){
        return RES_ERROR;
    }else{
        return 0;
    }
    
}

/* system call with time-out */
int crashRun(const char* cmd, char** logFile){

    size_t len;
    char* buffer;
    int back;
#ifdef USE_WINDOWS
    PROCESS_INFORMATION processInfo;
    STARTUPINFO startupInfo;
    SECURITY_ATTRIBUTES sa = {
        sizeof(SECURITY_ATTRIBUTES), NULL, TRUE
    };
    HANDLE tLogFile;
    unsigned long exitCode;
    int timeLeft = 600; /* time limit in iterations of WFX loop */
#endif

    *logFile = genTempFileName();
#ifdef USE_POSIX
    len = 40 + strlen(CRASH_RUN) + strlen(cmd) + strlen(*logFile);
    buffer = (char*) malloc(len);

    snprintf(buffer, len, "%s %s 2>&1 | head -n 200 > %s", CRASH_RUN, cmd, *logFile);

    system(buffer);
    free(buffer);

    buffer=loadFile(*logFile, &len);

    /* @todo@ use: len */
    if(strstr(buffer, "EXIT CODE: 0")){
        back = EXIT_SUCCESS;
    }else if(strstr(buffer, "EXIT CODE: 256")
            || strstr(buffer, "EXIT CODE: timeout") || strstr(buffer, "Cputime limit exceeded"))
    {
        back = EXIT_FAILURE;
    }else{
        back = RAND_MAX;
    }
    free(buffer);

    return back;
#elif defined USE_WINDOWS
    memset(&processInfo, 0, sizeof(PROCESS_INFORMATION));
    memset(&startupInfo, 0, sizeof(STARTUPINFO));
    startupInfo.cb = sizeof(STARTUPINFO);

    tLogFile = CreateFile(*logFile, GENERIC_WRITE,
      0, &sa, CREATE_ALWAYS, FILE_FLAG_WRITE_THROUGH, NULL);

    if (tLogFile == NULL) {
        printf("ERROR: could not open log file");
        return RAND_MAX;
    }

    SetStdHandle(STD_OUTPUT_HANDLE, tLogFile);
    SetStdHandle(STD_ERROR_HANDLE, originalStdout);

    if (!CreateProcess(NULL, (char*) cmd, NULL, NULL, TRUE, 0, NULL, NULL,
          &startupInfo, &processInfo)) {
        void *message;

        FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER
          | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
           (char*) &message, 0, NULL);

        SetStdHandle(STD_OUTPUT_HANDLE, originalStdout);
        SetStdHandle(STD_ERROR_HANDLE, originalStderr);
        CloseHandle(tLogFile);

        /* this should never happen */
        fprintf(stderr, "ERROR running %s:\n", cmd);
        fprintf(stderr, "%s\n", message);
        LocalFree((HLOCAL) message);
        return RAND_MAX;
    }

    /* wait for exit */
    while (TRUE) {
        GetExitCodeProcess(processInfo.hProcess, &exitCode);
        if (exitCode == 0x103) {
            if (--timeLeft == 0) {
                TerminateProcess(processInfo.hProcess, EXIT_FAILURE);
                SetStdHandle(STD_OUTPUT_HANDLE, originalStdout);
                SetStdHandle(STD_ERROR_HANDLE, originalStderr);
                CloseHandle(tLogFile);
                printf("EXIT CODE: timeout\n");
                Sleep(100);
                return RAND_MAX;
            }
            Sleep(100);
        } else {
            SetStdHandle(STD_OUTPUT_HANDLE, originalStdout);
            SetStdHandle(STD_ERROR_HANDLE, originalStderr);

            CloseHandle(tLogFile);

            printf("EXIT CODE: %i\n", exitCode);
            return exitCode;
        }
    }

#else /* USE_WINDOWS */
#error comment me out, if your test cases produce neither eternal loops nor Access Violations

    len = 10 + strlen(cmd) + strlen(*logFile);
    buffer = malloc(len);

    snprintf(buffer, len, "%s > %s 2>&1", cmd, *logFile);

    int i = system(buffer);
    printf("EXIT CODE: %i\n", i);

    return i;
#endif /* USE_POSIX else */
}

int target_compile(int modus, char* compiler, char* arguments, char* case_file,
        char* error_file, char* error_line)
{
    size_t bufferLen;
    char* buffer;
    int res;
    int testResult;
    int good_error;
    char* logFile;

    bufferLen = 0;
    buffer = NULL;
    res = -1;
    testResult = -1;
    good_error = 0;
    logFile = NULL;

    if(!(modus & MODE_COMPILE) && !(modus & MODE_NOCOMPILE)){
        fprintf(stderr, "BUG: badly handled mode %i (->compile)\n",
            modus);
        exit(EXIT_FAILURE);
    }

    /* gen command */
    bufferLen = strlen(compiler) + strlen(arguments) + strlen(tmp_dir)
        + strlen(case_file) + 21;
    buffer = (char*) malloc(bufferLen);
    snprintf(buffer, bufferLen, "%s %s ", compiler, arguments);

    if(NULL == strstr(buffer, "-od")){
        snprintf(buffer, bufferLen, "%s %s -od%s -c %s",
            compiler, arguments, tmp_dir, case_file);
    }else{
        snprintf(buffer, bufferLen, "%s %s -c %s",
            compiler, arguments, case_file);
    }

    /* test */
    if(modus & MODE_COMPILE){
        printf("compile: %s\n", buffer);
    }else{
        printf("nocompile: %s\n", buffer);
    }
    res = crashRun(buffer, &logFile);
    free(buffer);

    /* diagnostic */
    buffer = loadFile(logFile, &bufferLen);
    printf("%.*s\n", (int)bufferLen, buffer);
    remove(logFile);
    free(logFile);
    good_error = checkErrorMessage(error_file, error_line, buffer);

    testResult = conditionalResult(buffer);

    if(testResult){
        /* conditional result */
    }else if(hadExecCrash(buffer)){
        testResult = RES_ERROR;
    }else if(modus & MODE_COMPILE){
        if(res == EXIT_SUCCESS){
            testResult = RES_PASS;
        }else if(res == EXIT_FAILURE){
            testResult = RES_FAIL | (good_error ? 0 : RES_BAD_MSG);
        }else{
            testResult = RES_ERROR | (good_error ? 0 : RES_BAD_MSG);
        }
    }else{
        if(res == EXIT_FAILURE){
            if(good_error){
                testResult = RES_XFAIL;
            }else{
                testResult = RES_FAIL | RES_BAD_MSG;
            }
        }else if(res == EXIT_SUCCESS){
            testResult = RES_XPASS;
        }else{
            testResult = RES_ERROR;
        }
    }

    free(buffer);

    return testResult;
}

int target_run(int modus, char* compiler, char* arguments, char* case_file,
    char* error_file, char* error_line
#ifdef REG_EXTENDED
    , char* gdb, char* gdb_script, regex_t* gdb_pattern
#endif
    )
{
    size_t bufferLen;
    char* buffer;
    int res;
    int testResult;
    int good_error;
    char* logFile;
    char* gdb_scripter;
    int good_gdb;

    bufferLen = 0;
    buffer = NULL;
    res = -1;
    testResult = -1;
    good_error = 0;
    logFile = NULL;
    good_gdb = 0;
    gdb_scripter = NULL;

    if(!(modus & MODE_RUN) && !(modus & MODE_NORUN)){
        fprintf(stderr, "BUG: badly handled mode %i (->run)\n", modus);
        exit(EXIT_FAILURE);
    }

    /* gen command */

    bufferLen = strlen(compiler) + strlen(arguments) + strlen(tmp_dir)
            + strlen(case_file) * 2 + 64;
    buffer = (char*) malloc(bufferLen);
    snprintf(buffer, bufferLen, "%s %s ", compiler, arguments);

    if(NULL == strstr(buffer, "-od")){
        if(NULL == strstr(buffer, "-of")){
            snprintf(buffer, bufferLen,
                "%s %s -od%s -of%s.exe %s",
                compiler, arguments, tmp_dir, case_file,
                case_file);
        }else{
            snprintf(buffer, bufferLen,
                "%s %s -od%s %s",
                compiler, arguments, tmp_dir, case_file);
        }
    }else if(NULL == strstr(buffer, "-of")){
        snprintf(buffer, bufferLen,
            "%s %s -of%s.exe %s",
            compiler, arguments, case_file, case_file);
    }else{
        snprintf(buffer, bufferLen, "%s %s %s",
            compiler, arguments, case_file);
    }

    /* test 1/3 - compile */
    if(modus & MODE_RUN){
        printf("run: %s\n", buffer);
    }else{
        printf("norun: %s\n", buffer);
    }
    res = crashRun(buffer, &logFile);
    free(buffer);

    /* diagnostic 1/3 */
    buffer = loadFile(logFile, &bufferLen);
    printf("%.*s", (int)bufferLen, buffer);
    remove(logFile);
    free(logFile);

    if(modus & MODE_RUN){
        good_error = checkErrorMessage(error_file, error_line,
            buffer);
    }else{
        good_error = 1;
    }

    testResult = conditionalResult(buffer);
    if(hadExecCrash(buffer)){
        free(buffer);
        return RES_ERROR;
    }else{
        free(buffer);
        if(testResult){
            return testResult;
        }else if((res == EXIT_FAILURE) && good_error){
            return RES_FAIL;
        }else if(res!=EXIT_SUCCESS){
            return RES_ERROR | (good_error ? 0 : RES_BAD_MSG);
        }
    }

    /* test 2/3 - run */
    if((modus & MODE_NORUN) && (strstr(case_file, "/asm_")
                || strstr(case_file, "\\asm_")
                || (case_file == strstr(case_file, "asm_"))))
    {
        /* Valgrind doesn't support privileged instructions */
        goto no_valgrind;
    }else if(strstr(case_file, "/asm_") || strstr(case_file, "\\asm_")
            || (case_file == strstr(case_file, "asm_")))
    {
        /* FIXME asm workaround due to Valgrind bugs (mainly SSE3) */
        goto no_valgrind;
    }else if(VALGRIND){
        bufferLen = strlen(VALGRIND) + strlen(case_file) + 8;
        buffer = (char*) malloc(bufferLen);
        snprintf(buffer, bufferLen, "%s %s.exe", VALGRIND, case_file);
    }else{
no_valgrind:
        bufferLen = strlen(case_file) + 8;
        buffer = (char*) malloc(bufferLen);
        snprintf(buffer, bufferLen, "%s.exe", case_file);
    }
    printf("%s\n", buffer);
    res=crashRun(buffer, &logFile);
    testResult = conditionalResult(buffer);
    if(testResult){
        free(buffer);
        return testResult;
    }
    free(buffer);

    /* diagnostic 2/3 */
    buffer = loadFile(logFile, &bufferLen);
    printf("%.*s\n", (int) bufferLen, buffer);
    remove(logFile);
    free(logFile);

    if(modus & MODE_NORUN){
        good_error = checkRuntimeErrorMessage(error_file, error_line,
                buffer);
    }else{
        good_error = 1;
    }

#ifdef REG_EXTENDED
    if(((res==EXIT_SUCCESS && (modus & MODE_RUN))
            ||(res != EXIT_FAILURE && (modus & MODE_NORUN)))
            && gdb_script != NULL)
    {
        testResult = conditionalResult(buffer);
        if(testResult){
            return testResult;
        }

        free(buffer);
        good_gdb = 0;
        /* test 3/3 - gdb */
        gdb_scripter = genTempFileName();
        writeFile(gdb_scripter, gdb_script);
        bufferLen = strlen(gdb) + strlen(case_file)
            + strlen(gdb_scripter) + 20;
        buffer = (char*) malloc(bufferLen);
        snprintf(buffer, bufferLen, "%s %s.exe < %s",
            gdb, case_file, gdb_scripter);
        printf("%s\n", buffer);
        if(EXIT_SUCCESS==crashRun(buffer, &logFile)){
            /* diagnostic 3/3 */
            buffer = loadFile(logFile, &bufferLen);
            printf("%.*s\n", (int)bufferLen, buffer);
            good_gdb = (regexec(gdb_pattern, buffer, 0, NULL, 0)==0);
        }
        remove(logFile);
        remove(gdb_scripter);
    }else{
        good_gdb = 1;
    }
#else
    good_gdb = 1;
#endif /* REG_EXTENDED else */

    testResult = conditionalResult(buffer);
    if(testResult){
        return testResult;
    }

    if(modus & MODE_RUN){
        if(hadExecCrash(buffer)){
            testResult = RES_ERROR;
        }else if((res==EXIT_SUCCESS) && good_gdb){
            testResult = RES_PASS;
        }else if((res==EXIT_FAILURE) && good_error && good_gdb){
            testResult = RES_FAIL;
        }else{
            testResult = RES_ERROR | (good_error ? 0 : RES_BAD_MSG)
                | (good_gdb ? 0 : RES_BAD_GDB);
        }
    }else{
        if(res==EXIT_SUCCESS){
            testResult = RES_XPASS;
        }else if(good_error && good_gdb){
            testResult = RES_XFAIL;
        }else{
            testResult = RES_FAIL | (good_error ? 0 : RES_BAD_MSG)
                | (good_gdb ? 0 : RES_BAD_GDB);
        }
    }
    free(buffer);

    return testResult;
}

int main(int argc, char* arg[]){

    char* compiler;     /* the compiler - from enviroment flag "DMD" */
    char* cmd_arg_case; /* additional arguments - from the testcase file */
    char* buffer;       /* general purpose buffer */
    size_t bufferLen;
    int index;
    int modus;      /* test modus: RUN NORUN COMPILE NOCOMPILE */
    char* case_file;
    int case_result;
    int torture_result[sizeof(torture)/sizeof(char*)];
    char* torture_block_global;
    char* torture_block_case;
    char* torture_require;
    char* error_file;   /* expected sourcefile containing the error */
    char* error_line;   /* expected error line */
    char* gdb;      /* the debugger - from environment flag "GDB" */
    char* gdb_script;   /* gdb command sequence */
    char* gdb_pattern_raw;  /* POSIX regexp expected in GDB's output */
#ifdef REG_EXTENDED
    regex_t* gdb_pattern;
#endif

    compiler    = NULL;
    cmd_arg_case    = NULL;
    buffer      = NULL;
    bufferLen   = 0;
    modus       = -1;
    case_file   = NULL;
    torture_block_global    = NULL;
    torture_block_case  = NULL;
    torture_require = NULL;
    error_file  = NULL;
    error_line  = NULL;
    gdb     = NULL;
    gdb_script  = NULL;
    gdb_pattern_raw = NULL;
#ifdef REG_EXTENDED
    gdb_pattern     = NULL;
#endif

    /* check arguments */
    if(argc != 3){
err:
        fprintf(stderr, "DStress test executer (revision 1083)\n"
            "Copyright by Thomas Kuehne <thomas@kuehne.cn> 2005, 2006\n"
            "\n");

        if(argc!=0){
            fprintf(stderr,
                "%s <run|norun|compile|nocompile> <source>\n",
                arg[0]);
        }else{
            fprintf(stderr,
                "dstress <run|norun|compile|nocompile>"
                " <source>\n");
        }

        fprintf(stderr, "\n"
        "== eniroment settings (usually $NAME or %%NAME%%)  ==\n"
        "* DMD                - compiler (including standard arguments)\n"
        "* GDB                - debugger (including standard arguments)\n");
        fprintf(stderr, "\n"
        "== case setting (line in the case source) ==\n"
        "* __DSTRESS_DFLAGS__ - additional compiler arguments\n"
        "only evaluated if it is a \"nocompile\" or \"norun\" test:\n"
        "* __DSTRESS_ELINE__  - expected source line to throw an error message\n"
        "* __DSTRESS_EFILE__  - expected source file to throw an error message\n"
        "                       (defaults to the case file)\n");
        fprintf(stderr,
        "only evaluated if it is a \"run\" or \"norun\" test:\n"
        "* __GDB_SCRIPT__     - command sequence to feed to the debugger\n"
        "                       (use \\n to encode a line break)\n"
        "* __GDB_PATTERN__    - expected regular expression in the debugger's\n"
        "                       output\n");
        fprintf(stderr, "\n"
        "== note ==\n"
        "* the current directory is required to contain the sub-directory \"obj\"\n"
        "  (used for temporary files)\n"
        );
        exit(EXIT_FAILURE);
    }

    modus = 0;
    if(0==strncmp(arg[1], TORTURE_PREFIX, strlen(TORTURE_PREFIX))){
        modus |= MODE_TORTURE;
        arg[1] += strlen(TORTURE_PREFIX);
    }
    if(0==strcmp(arg[1], "run")){
        modus |= MODE_RUN;
    }else if(0==strcmp(arg[1], "norun")){
        modus |= MODE_NORUN;
    }else if(0==strcmp(arg[1], "compile")){
        modus |= MODE_COMPILE;
    }else if(0==strcmp(arg[1], "nocompile")){
        modus |= MODE_NOCOMPILE;
    }else{
        goto err;
    }

    /* gen flags */
    case_file = cleanPathSeperator(arg[2]);
    compiler = getCompiler();
    gdb = getGDB();
    torture_block_global = getTortureBlock();
    buffer = loadFile(case_file, &bufferLen);
    bufferLen = 0;

    cmd_arg_case =  cleanPathSeperator(getCaseFlag(buffer, "__DSTRESS_DFLAGS__"));
    error_line = getCaseFlag(buffer, "__DSTRESS_ELINE__");
    error_file =  cleanPathSeperator(getCaseFlag(buffer, "__DSTRESS_EFILE__"));
    gdb_script = getCaseFlag(buffer, "__GDB_SCRIPT__");
    gdb_pattern_raw = getCaseFlag(buffer, "__GDB_PATTERN__");
    torture_block_case = getCaseFlag(buffer, "__DSTRESS_TORTURE_BLOCK__");
    torture_require = getCaseFlag(buffer, "__DSTRESS_TORTURE_REQUIRE__");

    free(buffer);

    /* tmp_dir */
    if(!cmd_arg_case || !cmd_arg_case[0]){
        tmp_dir = TMP_DIR;
    }else{
        pid_t pid;
        pid = getpid();
        bufferLen = strlen(TMP_DIR) + 4 + sizeof(pid_t) * 4;
        buffer = (char*) malloc(bufferLen);
        snprintf(buffer, bufferLen, "%s/_%X", TMP_DIR, pid);
        tmp_dir = cleanPathSeperator(buffer);
        if(mkdir(tmp_dir, 0770)){
            fprintf(stderr, "failed to create tmp dir: %s (%d, %s)\n",
                    tmp_dir, errno, strerror(errno));
            return EXIT_FAILURE;
        }
    }

    /* set implicit source file */
    if(strcmp(error_line, "")!=0 && strcmp(error_file, "")==0){
        error_file=case_file;
    }

    /* gdb pattern */
#ifdef REG_EXTENDED
    if(gdb_pattern_raw!=NULL && gdb_pattern_raw[0]!='\x00'){

        gdb_pattern = (regex_t*) malloc(sizeof(regex_t));
        if(regcomp(gdb_pattern, gdb_pattern_raw, REG_EXTENDED | REG_NOSUB)){
            fprintf(stderr, "failed to compile regular expression:"
                "\n\t%s\n", gdb_pattern_raw);
            exit(EXIT_FAILURE);
        }else if(gdb_script==NULL){
            fprintf(stderr, "GDB pattern without GDB script\n");
            exit(EXIT_FAILURE);
        }
    }else{
        gdb_pattern = NULL;
    }

    /* gdb script */
    if(gdb_script!=NULL && gdb_script[0]!='\x00'){
        if(gdb_pattern==NULL){
            fprintf(stderr, "GDB script without GDB pattern\n");
            exit(EXIT_FAILURE);
        }
        buffer=gdb_script;
        for(; *buffer; buffer++){
            if(buffer[0]=='\\'){
                if(buffer[1]=='n'){
                    buffer[0]=' ';
                    buffer[1]='\n';
                }
                buffer++;
            }
        }

        bufferLen = strlen(gdb_script)+11;
        buffer = (char*) malloc(bufferLen);
        snprintf(buffer, bufferLen, "%s\n\nquit\ny\n\n", gdb_script);
        gdb_script=buffer;
    }else if(gdb_script){
        free(gdb_script);
        gdb_script = NULL;
    }

#else

    if(gdb_script && strlen(gdb_script)){
        if(gdb_pattern_raw && strlen(gdb_pattern_raw)){
            fprintf(stderr, "WARNING: GDB/regex support inactive\n");
        }else{
            fprintf(stderr, "GDB script without GDB pattern\n");
            exit(EXIT_FAILURE);
        }
    }else if(gdb_pattern_raw && strlen(gdb_pattern_raw)){
        fprintf(stderr, "GDB pattern without GDB script\n");
        exit(EXIT_FAILURE);
    }

#endif /* REG_EXTENDED else */

#ifdef DEBUG
    fprintf(stderr, "case    : \"%s\"\n", case_file);
    fprintf(stderr, "compiler: \"%s\"\n", compiler);
    fprintf(stderr, "DFLAGS C: \"%s\"\n", cmd_arg_case);
    fprintf(stderr, "ELINE   : \"%s\"\n", error_line);
    fprintf(stderr, "EFILE   : \"%s\"\n", error_file);
#ifdef REG_EXTENDED
    fprintf(stderr, "GDB Scri: \"%s\"\n", gdb_script);
    fprintf(stderr, "GDB Patt: \"%s\"\n", gdb_pattern_raw);
#endif
    fprintf(stderr, "block G : \"%s\"\n", torture_block_global);
    fprintf(stderr, "block C : \"%s\"\n", torture_block_case);
    fprintf(stderr, "modus   : %x\n", modus);
#endif


    /* let's get serious */
#ifdef USE_WINDOWS
    originalStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    originalStderr = GetStdHandle(STD_ERROR_HANDLE);
#endif

    if(modus & MODE_TORTURE){
        if((modus & (MODE_COMPILE | MODE_NOCOMPILE))
            && (modus & (MODE_RUN | MODE_NORUN)))
        {
            fprintf(stderr, "BUG: unhandled torture modus %x\n", modus);
            exit(EXIT_FAILURE);
        }else if(!(modus & (MODE_COMPILE | MODE_NOCOMPILE | MODE_RUN | MODE_NORUN))){
            fprintf(stderr, "BUG: unhandled torture modus %x\n", modus);
            exit(EXIT_FAILURE);
        }

        bufferLen = strlen(torture[(sizeof(torture) / sizeof(char*))-1])
            + 128 + strlen(cmd_arg_case) + 3;

        if(torture_block_case!=NULL && strlen(torture_block_case)<1){
            torture_block_case=NULL;
        }

        buffer = (char*) malloc(bufferLen);
        for(index=0; index < sizeof(torture)/sizeof(char*); index++){
            if((torture_block_global && strstr(torture[index], torture_block_global))
                || (torture_block_case && strstr(torture[index], torture_block_case))
                || (torture_require && !strstr(torture[index], torture_require)))
            {
                torture_result[index]=RES_UNTESTED;
                continue;
            }

            buffer[0]=0;
            snprintf(buffer, bufferLen, "%s %s", torture[index], cmd_arg_case);

            if(modus & (MODE_COMPILE | MODE_NOCOMPILE)){
                torture_result[index] = target_compile(modus,
                    compiler, buffer, case_file,
                    error_file, error_line);
            }else if(modus & (MODE_RUN | MODE_NORUN)){
                torture_result[index] = target_run(modus,
                    compiler, buffer, case_file,
                    error_file, error_line
#ifdef REG_EXTENDED
                    , gdb, gdb_script, gdb_pattern
#endif
                );
            }

            printf("Torture-Sub-%i/" ZU "-", index+1,
                    sizeof(torture)/sizeof(char*));
            printResult(torture_result[index], modus, case_file,
                    stdout);
            printf("--------\n");
        }
    }else{
        if(torture_require && torture_require[0]){
            if(!cmd_arg_case || !cmd_arg_case[0]){
                cmd_arg_case = torture_require;
            }else{
                bufferLen = strlen(cmd_arg_case);
                bufferLen += strlen(torture_require);
                bufferLen += 2;
                buffer = (char*) malloc(bufferLen);
                snprintf(buffer, bufferLen, "%s %s", cmd_arg_case, torture_require);
                cmd_arg_case = buffer;
            }
        }
        if(modus & (MODE_RUN | MODE_NORUN)){
            case_result = target_run(modus, compiler, cmd_arg_case,
                    case_file, error_file, error_line
#ifdef REG_EXTENDED
                    , gdb, gdb_script, gdb_pattern
#endif
                    );
        }else if(modus & (MODE_COMPILE | MODE_NOCOMPILE)){
            case_result = target_compile(modus, compiler,
                    cmd_arg_case, case_file, error_file,
                    error_line);
        }else{
            fprintf(stderr, "BUG: unhandled non-torture modus %x\n", modus);
            exit(EXIT_FAILURE);
        }

        printf("Torture-Sub-1/" ZU "-",
            sizeof(torture)/sizeof(char*));
        printResult(case_result, modus, case_file, stdout);
    }

    if(strcmp(TMP_DIR, tmp_dir)){
        bufferLen = strlen(tmp_dir);
        bufferLen += strlen(RM_DIR);
        bufferLen += 2;
        buffer = (char*) malloc(bufferLen);
        snprintf(buffer, bufferLen, "%s %s", RM_DIR, tmp_dir);
        system(buffer);
    }
    exit(EXIT_SUCCESS);
}