root/trunk/dxmp_lib.d

private import std.conv;
private import std.process;
private import std.file;
private import std.stdio;
private import std.string;
private import std.regexp;
private import std.math2;

struct XMPOptions {
    char[] interpreter;
    bool output_stdout;
    char[] dump;
    char[] filename;
}

class XMPFilter {
    const char[] VERSION = "0.1.0";

    const char[] MARKER = "!XMP87678_555_333333!";
    static RegExp XMP_RE;
    const char[] VAR = "_xmp_99999_555_333333";
    static RegExp RUNTIME_ERROR_RE;

    struct RuntimeData {
        char[][][][int] results;
        char[][][int] exceptions;
    }

    // INITIALIZE_OPTS

    static this() {
        XMP_RE = RegExp("^" ~ MARKER ~ `\[([0-9]+)\] (=>|~>) (.*)`);
        RUNTIME_ERROR_RE = RegExp(`^Error: (.+) \S+\(([0-9]+)\)`);  
    }

    static char[] run(char[] code, XMPOptions opts) {
        auto obj = new XMPFilter(opts);
        return obj.annotate(code);
    }

    char[] interpreter;
    bool output_stdout;
    char[] dump;
    char[] filename;

    this(XMPOptions opts) {
        interpreter = opts.interpreter;
        output_stdout = opts.output_stdout;
        dump = opts.dump;
        filename = opts.filename;
    }

    this() {}

    static char[] add_markers(char[] code, int min_codeline_size = 50) {
        int[] lengthes;
        int maxlen;
        foreach(line; code.splitlines()) {
            lengthes ~= line.length;
        }
        maxlen = lengthes.max();

        lengthes.length = 2;
        lengthes[0] = min_codeline_size;
        lengthes[1] = maxlen + 2;
        maxlen = lengthes.max();

        char[] ret = "";
        foreach(line; code.splitlines()) {
            line = line.sub(r" // (=>|!>).*", "", "gm").sub(r" \t*$", "");
            ret ~= (line ~ " ".repeat(maxlen - line.length) ~ " // =>" ~ newline);
        }
        return ret;
    }

    unittest {
        assert("a;         // =>\n" == add_markers("a;", 10),
               format("\n<%s> expected but was\n<%s>.\n", "a;         // =>\n", add_markers("a;", 10)));
        assert("a;         // =>\n" == add_markers("a; // =>\n", 10),
               format("\n<%s> expected but was\n<%s>.\n", "a;         // =>\n", add_markers("a; // =>\n", 10)));
    }


    static char[] add_import(char[] code) {
        char[] ret = "import std.cstream;";
        return ret ~ code.sub(`^#!.+`, "");
    }
  
    unittest {
        assert("import std.cstream;void main() {}\n" == add_import("void main() {}\n"),
               format("\n<%s> expected but was\n<%s>.\n", "import std.cstream;void main() {}\n", add_import("void main() {}\n")));
        assert("import std.cstream;\nvoid main() {}\n" == add_import("#!/usr/bin/env rdmd\nvoid main() {}\n"),
               format("\n<%s> expected but was\n<%s>.\n", "import std.cstream;\nvoid main() {}\n", add_import("#!/usr/bin/env rdmd\nvoid main() {}\n")));
    }

    char[] annotate(char[] code) {
        auto idx = 0;
        char[] newcode = add_import(code).
            sub(r"^(.*) // =>.*",
                (RegExp l){ return prepare_line(l.match(1), ++idx);},
                "gm");
        if (dump) write(dump, newcode);

        char[][] exec_result = execute_tmpfile(newcode, interpreter);
        char[] stdout = exec_result[0], stderr = exec_result[1];

        RuntimeData runtime_data = extract_data(stderr);

        set_internal_info();

        idx = 0;
        char[] annotated = code.sub(r"^(.*) // =>.*",
                                    (RegExp re){
                                        auto l = re.match(0);
                                        auto expr = re.match(1);
      
                                        if (RegExp(r"^\s*//").test(l))
                                            return l;
                                        else
                                            return annotated_line(l, expr, runtime_data, ++idx);
                                    }, "gm").sub(r" // !>.*", "", "gm").sub(r"// (>>|~>).*$", "", "gm");

        auto ret = final_decoration(annotated, (stdout ~ stderr).splitlines()).join("");
        if (output_stdout && stdout != "") {
            char[] retplus;
            foreach(line; stdout.splitlines()) {
                if (!( (compile_error_regexp.test(line)) ||
                       (RUNTIME_ERROR_RE.test(line)))) {
                    retplus ~= "// >> " ~ line ~ newline;
                }
            }
            ret ~= retplus;
        }
        return ret;
    }
    
    static char[] cast_void(char[] expression) {
        if (std.string.find(expression, "cast(void)") >= 0) {
            return expression;
        } else {
            RegExp re;
            char[] lspaces, rspaces;
            re = expression.search(r"^\s*");
            lspaces = re ? re.match(0) : "";
            re = expression.search(r"\s+$");
            rspaces = re ? re.match(0) : "";
            return format("%scast(void)(%s);%s", lspaces, expression.strip().chomp(";"), rspaces);
        }
    }

    unittest {
        assert("cast(void)(1+1);" == cast_void("1+1;"),
               format("\n<%s> expected but was\n<%s>.\n", "cast(void)(1+1);", cast_void("1+1;")));
        assert("cast(void)(1+1)" == cast_void("cast(void)(1+1)"),
               format("\n<%s> expected but was\n<%s>.\n", "cast(void)(1+1)", cast_void("cast(void)(1+1)")));
    }

    static char[] annotated_line(char[] line, char[] expression, RuntimeData runtime_data, int idx) {
        char[][] elems;

        try { 
            foreach(x; runtime_data.results[idx]) {
                elems ~= x[1];
            }
            return cast_void(expression) ~ " // => " ~ elems.join(", ");
        } catch  {
            return cast(char[])"";
        }
    }

    unittest {
        RuntimeData runtime_data;
        runtime_data.results[0] = [["klass", "1"]];
        runtime_data.results[1] = [["klass", "2"], ["klass", "4"], ["klass", "6"]];

        char[] expected = "cast(void)(a); // => 1";
        char[] actual = annotated_line("ignore", "a", runtime_data, 0);
        assert(expected == actual,
               format("\n<%s> expected but was\n<%s>.\n", expected, actual));

        expected = "cast(void)(a); // => 2, 4, 6";
        actual = annotated_line("ignore", "cast(void)(a);", runtime_data, 1);
        assert(expected == actual,
               format("\n<%s> expected but was\n<%s>.\n", expected, actual));

        assert("" == annotated_line("", "", runtime_data, 999),
               format("\n<%s> expected but was\n<%s>.\n", "", annotated_line("", "", runtime_data, 999)));

    }

    static char[] prepare_line_annotation(char[] expr, int idx) {
        expr = expr.sub(r"cast\(void\)", "").sub(r";\s*$", "");
        return format(`derr.writefln("%s[%d] => %%s %%s", "klass", (%s));`, MARKER, idx, expr);
    }
    alias prepare_line_annotation prepare_line;

    unittest {
        assert("derr.writefln(\"" ~ MARKER ~ "[0] => %s %s\", \"klass\", (  1+1));" == prepare_line_annotation("  1+1;", 0),
               format("\n<%s> expected but was\n<%s>.\n", "derr.writefln(\"" ~ MARKER ~ "[0] => %s %s\", \"klass\", (  1+1));", prepare_line_annotation("  1+1;", 0)));

        auto expected = "derr.writefln(\"" ~ MARKER ~ "[1] => %s %s\", \"klass\", (  (1+1)));";
        auto actual = prepare_line_annotation("  cast(void)(1+1);", 1);
        assert(expected == actual,
               format("\n<%s> expected but was\n<%s>.\n", expected, actual));
    }

    const char[] DXMP_TMPFILE_FMT = "dxmp_tmpfile_999_%d.d";

    static char[][] execute_tmpfile(char[] code, char[] interpreter) {
        enum { stdin=1, stdout=2, stderr=3 };
        char[][] fname;
        int i;
        fname.length = 4;
        for (i=stdin; i<=stderr; i++) {
            fname[i] = format(DXMP_TMPFILE_FMT, i);
        }
        write(fname[stdin], code.chomp() ~ newline);
        system(format("%s %s > %s 2> %s", interpreter, fname[stdin], fname[stdout], fname[stderr]));

        char[][] ret = [ cast(char[])read(fname[stdout]), cast(char[])read(fname[stderr]) ];
        for (i=stdin; i<=stderr; i++)
            std.file.remove(fname[i]);
        return ret;
    }
    
  
    unittest {
        assert(["hoge\n", ""] == execute_tmpfile("hoge", "cat"),
               format("\n<%s> expected but was\n<%s>.\n", ["hoge\n", ""], execute_tmpfile("hoge", "cat")));
        assert(["", "0\n"] == execute_tmpfile("hoge", "ruby -e '$stderr.puts 0'"),
               format("\n<%s> expected but was\n<%s>.\n", ["", "0\n"], execute_tmpfile("hoge", "ruby -e '$stderr.puts 0'")));

        assert(0 == format(DXMP_TMPFILE_FMT,1).exists(),
               format("\n<%s> expected but was\n<%s>.\n", 0, format(DXMP_TMPFILE_FMT,1).exists()));
        assert(0 == format(DXMP_TMPFILE_FMT,2).exists(),
               format("\n<%s> expected but was\n<%s>.\n", 0, format(DXMP_TMPFILE_FMT,2).exists()));
        assert(0 == format(DXMP_TMPFILE_FMT,3).exists(),
               format("\n<%s> expected but was\n<%s>.\n", 0, format(DXMP_TMPFILE_FMT,3).exists()));
    }

    static RuntimeData extract_data(char[] output){
        char[][][][int] results;
        char[][][int] exceptions;
        foreach(line; output.splitlines()) {
            auto md = XMP_RE;
            if (XMP_RE.test(line)) {
                int result_id = toInt(md.match(1));
                char[] op = md.match(2);
                char[] result = md.match(3);
                switch(op) {
                case "=>":
                    RegExp md2 = RegExp(r"(\S+)\s+(.*)");
                    md2.find(result);
                    char[] klass = md2.match(1);
                    char[] value = md2.match(2);
                    results[result_id] ~= [klass, value];
                    break;
                case "~>":
                    exceptions[result_id] ~= result;
                    break;
                default:
                    assert(0);
                }
            }
        }

        RuntimeData ret;
        ret.results = results;
        ret.exceptions = exceptions;
        return ret;
    }

    unittest {
        char[] output = format(r"%s[0] => klass 2
%s[1] => klass 3
%s[2] ~> an error", MARKER, MARKER, MARKER);
        RuntimeData runtime_data = extract_data(output);
        auto results = runtime_data.results;
        auto exceptions = runtime_data.exceptions;
        assert( [["klass", "2"]] == results[0] ,
                format("\n<%s> expected but was\n<%s>.\n", [["klass", "2"]], results[0]));
        assert( [["klass", "3"]] == results[1] ,
                format("\n<%s> expected but was\n<%s>.\n", [["klass", "3"]], results[1]));
        assert( "an error" == exceptions[2][0] ,
                format("\n<%s> expected but was\n<%s>.\n", "an error", exceptions[2][0]));
    }
  
    char[][] final_decoration(char[] code, char[][] output) {
        char[][int] runtime_errors;
        foreach(x; output) {
            if (RUNTIME_ERROR_RE.test(x)) {
                runtime_errors[toInt(RUNTIME_ERROR_RE.match(2))] = RUNTIME_ERROR_RE.match(1);
            }
        }
        int idx = 1;
        char[][] ret;
        foreach(line; code.splitlines()) {
            if (idx in runtime_errors) {
                auto w = runtime_errors[idx];
                ret ~= line ~ " // !> " ~ w ~ newline;
            } else {
                ret ~= line ~ newline;
            }
            idx++;
        }

        foreach(inout x; output) {
            x = x.chomp() ~ newline;
            if (RUNTIME_ERROR_RE.test(x))
                x = "";
        }
    
        if (compile_error_regexp.test(output.join(""))) {
            char[] exception_lines = output.join("").sub(input_d, filename, "gm");
            foreach(line; exception_lines.splitlines()) 
                ret ~= "// ~> " ~ line.chomp() ~ newline;
        }
        return ret;
    }
  
    char[] input_d;
    RegExp compile_error_regexp;
    void set_internal_info() {
        input_d = format(DXMP_TMPFILE_FMT, 1);
        auto error = input_d ~ r"\([0-9]+\)";
        compile_error_regexp = RegExp(format("^(%s|warning -).*", error));
    }

    unittest {
        char[] code = r"void main(){
assert(0)
}
";
        auto x = new XMPFilter();
        x.filename = "temp.d";
        x.set_internal_info();

        {
            char[] expected = "assert(0) // !> AssertError Failure\n";
            char[] actual = x.final_decoration(code, ["Error: AssertError Failure temp(2) \n"])[1];
            assert(expected == actual,
                   format("\n<%s> expected but was\n<%s>.\n", expected, actual));
        }

        {
            char[][] output =
                [ x.input_d ~ "(40): Error: undefined identifier x\n",
                  x.input_d ~ "(40): Error: function expected before (), not x of type int\n",
                  "rdmd: Couldn't compile or execute dxmp_testcases.d.\n"];
            char[][] expected =
                ["code\n",
                 "// ~> temp.d(40): Error: undefined identifier x\n",
                 "// ~> temp.d(40): Error: function expected before (), not x of type int\n",
                 "// ~> rdmd: Couldn't compile or execute dxmp_testcases.d.\n"];
            char[][] actual = x.final_decoration("code\n", output);
            assert(expected == actual,
                   format("\n<%s> expected but was\n<%s>.\n", expected, actual));
        }

        {
            char[][] output = [ cast(char[])(MARKER ~ "[2] => klass 20") ];
            assert(null == x.final_decoration("", output),
                   format("\n<%s> expected but was\n<%s>.\n", null, x.final_decoration("", output)));

        }
    
    }
}