jscex-jit.js

(function () {
    
    var codeGenerator = (typeof eval("(function () {})") == "function") ?
        function (code) { return code; } :
        function (code) { return "false || " + code; };
        
    // support string type only.
    var stringify = (typeof JSON !== "undefined" && JSON.stringify) ?
        function (s) { return JSON.stringify(s); } :
        (function () {
            // Implementation comes from JSON2 (http://www.json.org/js.html)
        
            var escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
            
            var meta = {    // table of character substitutions
                '\b': '\\b',
                '\t': '\\t',
                '\n': '\\n',
                '\f': '\\f',
                '\r': '\\r',
                '"' : '\\"',
                '\\': '\\\\'
            }
            
            return function (s) {
                // If the string contains no control characters, no quote characters, and no
                // backslash characters, then we can safely slap some quotes around it.
                // Otherwise we must also replace the offending characters with safe escape
                // sequences.

                escapable.lastIndex = 0;
                return escapable.test(s) ? '"' + s.replace(escapable, function (a) {
                    var c = meta[a];
                    return typeof c === 's' ? c :
                        '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
                }) + '"' : '"' + s + '"';
            };
        })();
    
    // seed defined in global
    if (typeof __jscex__tempVarSeed === "undefined") {
        __jscex__tempVarSeed = 0;
    }

    var init = function (root) {
    
        if (root.modules["jit"]) {
            return;
        }
    
        function JscexTreeGenerator(binder) {
            this._binder = binder;
            this._root = null;
        }
        JscexTreeGenerator.prototype = {

            generate: function (ast) {

                var params = ast[2], statements = ast[3];

                this._root = { type: "delay", stmts: [] };

                this._visitStatements(statements, this._root.stmts);

                return this._root;
            },

            _getBindInfo: function (stmt) {

                var type = stmt[0];
                if (type == "stat") {
                    var expr = stmt[1];
                    if (expr[0] == "call") {
                        var callee = expr[1];
                        if (callee[0] == "name" && callee[1] == this._binder && expr[2].length == 1) {
                            return {
                                expression: expr[2][0],
                                argName: "",
                                assignee: null
                            };
                        }
                    } else if (expr[0] == "assign") {
                        var assignee = expr[2];
                        expr = expr[3];
                        if (expr[0] == "call") {
                            var callee = expr[1];
                            if (callee[0] == "name" && callee[1] == this._binder && expr[2].length == 1) {
                                return {
                                    expression: expr[2][0],
                                    argName: "$$_result_$$",
                                    assignee: assignee
                                };
                            }
                        }
                    }
                } else if (type == "var") {
                    var defs = stmt[1];
                    if (defs.length == 1) {
                        var item = defs[0];
                        var name = item[0];
                        var expr = item[1];
                        if (expr && expr[0] == "call") {
                            var callee = expr[1];
                            if (callee[0] == "name" && callee[1] == this._binder && expr[2].length == 1) {
                                return {
                                    expression: expr[2][0],
                                    argName: name,
                                    assignee: null
                                };                            
                            }
                        }
                    }
                } else if (type == "return") {
                    var expr = stmt[1];
                    if (expr && expr[0] == "call") {
                        var callee = expr[1];
                        if (callee[0] == "name" && callee[1] == this._binder && expr[2].length == 1) {
                            return {
                                expression: expr[2][0],
                                argName: "$$_result_$$",
                                assignee: "return"
                            };
                        }
                    }
                }

                return null;
            },

            _visitStatements: function (statements, stmts, index) {
                if (arguments.length <= 2) index = 0;

                if (index >= statements.length) {
                    stmts.push({ type: "normal" });
                    return this;
                }

                var currStmt = statements[index];
                var bindInfo = this._getBindInfo(currStmt);

                if (bindInfo) {
                    var bindStmt = { type: "bind", info: bindInfo };
                    stmts.push(bindStmt);

                    if (bindInfo.assignee != "return") {
                        bindStmt.stmts = [];
                        this._visitStatements(statements, bindStmt.stmts, index + 1);
                    }

                } else {
                    var type = currStmt[0];
                    if (type == "return" || type == "break" || type == "continue" || type == "throw") {

                        stmts.push({ type: type, stmt: currStmt });

                    } else if (type == "if" || type == "try" || type == "for" || type == "do"
                               || type == "while" || type == "switch" || type == "for-in") {

                        var newStmt = this._visit(currStmt);

                        if (newStmt.type == "raw") {
                            stmts.push(newStmt);
                            this._visitStatements(statements, stmts, index + 1);
                        } else {
                            var isLast = (index == statements.length - 1);
                            if (isLast) {
                                stmts.push(newStmt);
                            } else {

                                var combineStmt = {
                                    type: "combine",
                                    first: { type: "delay", stmts: [newStmt] },
                                    second: { type: "delay", stmts: [] }
                                };
                                stmts.push(combineStmt);

                                this._visitStatements(statements, combineStmt.second.stmts, index + 1);
                            }
                        }

                    } else {

                        stmts.push({ type: "raw", stmt: currStmt });

                        this._visitStatements(statements, stmts, index + 1);
                    }
                }

                return this;
            },

            _visit: function (ast) {

                var type = ast[0];

                function throwUnsupportedError() {
                    throw new Error('"' + type + '" is not currently supported.');
                }

                var visitor = this._visitors[type];

                if (visitor) {
                    return visitor.call(this, ast);
                } else {
                    throwUnsupportedError();
                }
            },

            _visitBody: function (ast, stmts) {
                if (ast[0] == "block") {
                    this._visitStatements(ast[1], stmts);
                } else {
                    this._visitStatements([ast], stmts);
                }
            },

            _noBinding: function (stmts) {
                switch (stmts[stmts.length - 1].type) {
                    case "normal":
                    case "return":
                    case "break":
                    case "throw":
                    case "continue":
                        return true;
                }

                return false;
            },

            _collectCaseStatements: function (cases, index) {
                var res = [];

                for (var i = index; i < cases.length; i++) {
                    var rawStmts = cases[i][1];
                    for (var j = 0; j < rawStmts.length; j++) {
                        if (rawStmts[j][0] == "break") {
                            return res
                        }

                        res.push(rawStmts[j]);
                    }
                }

                return res;
            },

            _visitors: {

                "for": function (ast) {

                    var bodyStmts = [];
                    var body = ast[4];
                    this._visitBody(body, bodyStmts);

                    if (this._noBinding(bodyStmts)) {
                        return { type: "raw", stmt: ast };
                    }

                    var delayStmt = { type: "delay", stmts: [] };
            
                    var setup = ast[1];
                    if (setup) {
                        delayStmt.stmts.push({ type: "raw", stmt: setup });
                    }

                    var loopStmt = { type: "loop", bodyFirst: false, bodyStmt: { type: "delay", stmts: bodyStmts } };
                    delayStmt.stmts.push(loopStmt);
                    
                    var condition = ast[2];
                    if (condition) {
                        loopStmt.condition = condition;
                    }
                    
                    var update = ast[3];
                    if (update) {
                        loopStmt.update = update;
                    }

                    return delayStmt;
                },

                "for-in": function (ast) {

                    var body = ast[4];
                    
                    var bodyStmts = [];
                    this._visitBody(body, bodyStmts);

                    if (this._noBinding(bodyStmts)) {
                        return { type: "raw", stmt: ast };
                    }
                
                    var id = (__jscex__tempVarSeed++);
                    var keysVar = "$$_keys_$$_" + id;
                    var indexVar = "$$_index_$$_" + id;
                    // var memVar = "$$_mem_$$_" + id;

                    var delayStmt = { type: "delay", stmts: [] };

                    // var members = Jscex._forInKeys(obj);
                    var keysAst = root.parse("var " + keysVar + " = Jscex._forInKeys(obj);")[1][0];
                    keysAst[1][0][1][2][0] = ast[3]; // replace obj with real AST;
                    delayStmt.stmts.push({ type: "raw", stmt: keysAst });

                    /*
                    // var members = [];
                    delayStmt.stmts.push({
                        type: "raw",
                        stmt: uglifyJS.parse("var " + membersVar + " = [];")[1][0]
                    });
                    
                    // for (var mem in obj) members.push(mem);
                    var keysAst = uglifyJS.parse("for (var " + memVar +" in obj) " + membersVar + ".push(" + memVar + ");")[1][0];
                    keysAst[3] = ast[3]; // replace the "obj" with real AST.
                    delayStmt.stmts.push({ type : "raw", stmt: keysAst});
                    */
                    
                    // var index = 0;
                    delayStmt.stmts.push({
                        type: "raw",
                        stmt: root.parse("var " + indexVar + " = 0;")[1][0]
                    });

                    // index < members.length
                    var condition = root.parse(indexVar + " < " + keysVar + ".length")[1][0][1];

                    // index++
                    var update = root.parse(indexVar + "++")[1][0][1];

                    var loopStmt = {
                        type: "loop",
                        bodyFirst: false,
                        update: update,
                        condition: condition,
                        bodyStmt: { type: "delay", stmts: [] }
                    };
                    delayStmt.stmts.push(loopStmt);

                    var varName = ast[2][1]; // ast[2] == ["name", m]
                    if (ast[1][0] == "var") {
                        loopStmt.bodyStmt.stmts.push({
                            type: "raw",
                            stmt: root.parse("var " + varName + " = " + keysVar + "[" + indexVar + "];")[1][0]
                        });
                    } else {
                        loopStmt.bodyStmt.stmts.push({
                            type: "raw",
                            stmt: root.parse(varName + " = " + keysVar + "[" + indexVar + "];")[1][0]
                        });
                    }

                    this._visitBody(body, loopStmt.bodyStmt.stmts);

                    return delayStmt;
                },

                "while": function (ast) {

                    var bodyStmts = [];
                    var body = ast[2];
                    this._visitBody(body, bodyStmts);

                    if (this._noBinding(bodyStmts)) {
                        return { type: "raw", stmt: ast }
                    }

                    var loopStmt = { type: "loop", bodyFirst: false, bodyStmt: { type: "delay", stmts: bodyStmts } };

                    var condition = ast[1];
                    loopStmt.condition = condition;

                    return loopStmt;
                },

                "do": function (ast) {

                    var bodyStmts = [];
                    var body = ast[2];
                    this._visitBody(body, bodyStmts);

                    if (this._noBinding(bodyStmts)) {
                        return { type: "raw", stmt: ast };
                    }

                    var loopStmt = { type: "loop", bodyFirst: true, bodyStmt: { type: "delay", stmts: bodyStmts } };

                    var condition = ast[1];
                    loopStmt.condition = condition;

                    return loopStmt;
                },

                "switch": function (ast) {
                    var noBinding = true;

                    var switchStmt = { type: "switch", item: ast[1], caseStmts: [] };

                    var cases = ast[2];
                    for (var i = 0; i < cases.length; i++) {                    
                        var caseStmt = { item: cases[i][0], stmts: [] };
                        switchStmt.caseStmts.push(caseStmt);

                        var statements = this._collectCaseStatements(cases, i);
                        this._visitStatements(statements, caseStmt.stmts);
                        noBinding = noBinding && this._noBinding(caseStmt.stmts);
                    }

                    if (noBinding) {
                        return { type: "raw", stmt: ast };
                    } else {
                        return switchStmt;
                    }
                },

                "if": function (ast) {

                    var noBinding = true;

                    var ifStmt = { type: "if", conditionStmts: [] };

                    var currAst = ast;
                    while (true) {
                        var condition = currAst[1];
                        var condStmt = { cond: condition, stmts: [] };
                        ifStmt.conditionStmts.push(condStmt);

                        var thenPart = currAst[2];
                        this._visitBody(thenPart, condStmt.stmts);

                        noBinding = noBinding && this._noBinding(condStmt.stmts);

                        var elsePart = currAst[3];
                        if (elsePart && elsePart[0] == "if") {
                            currAst = elsePart;
                        } else {
                            break;
                        }
                    }
        
                    var elsePart = currAst[3];
                    if (elsePart) {
                        ifStmt.elseStmts = [];

                        this._visitBody(elsePart, ifStmt.elseStmts);
                        
                        noBinding = noBinding && this._noBinding(ifStmt.elseStmts);
                    }

                    if (noBinding) {
                        return { type: "raw", stmt: ast };
                    } else {
                        return ifStmt;
                    }
                },

                "try": function (ast, stmts) {

                    var bodyStmts = [];
                    var bodyStatements = ast[1];
                    this._visitStatements(bodyStatements, bodyStmts);

                    var noBinding = this._noBinding(bodyStmts)

                    var tryStmt = { type: "try", bodyStmt: { type: "delay", stmts: bodyStmts } };
                    
                    var catchClause = ast[2];
                    if (catchClause) {
                        var exVar = catchClause[0];
                        tryStmt.exVar = exVar;
                        tryStmt.catchStmts = [];

                        this._visitStatements(catchClause[1], tryStmt.catchStmts);

                        noBinding = noBinding && this._noBinding(tryStmt.catchStmts);
                    }

                    var finallyStatements = ast[3];
                    if (finallyStatements) {
                        tryStmt.finallyStmt = { type: "delay", stmts: [] };

                        this._visitStatements(finallyStatements, tryStmt.finallyStmt.stmts);

                        noBinding = noBinding && this._noBinding(tryStmt.finallyStmt.stmts);
                    }

                    if (noBinding) {
                        return { type: "raw", stmt: ast };
                    } else {
                        return tryStmt;
                    }
                }
            }
        }

        function CodeGenerator(builderName, binder, indent) {
            this._builderName = builderName;
            this._binder = binder;
            this._normalMode = false;
            this._indent = indent;
            this._indentLevel = 0;
            this._builderVar = "$$_builder_$$_" + (__jscex__tempVarSeed++);
        }
        CodeGenerator.prototype = {
            _write: function (s) {
                this._buffer.push(s);
                return this;
            },

            _writeLine: function (s) {
                this._write(s)._write("\n");
                return this;
            },

            _writeIndents: function () {
                for (var i = 0; i < this._indent; i++) {
                    this._write(" ");
                }

                for (var i = 0; i < this._indentLevel; i++) {
                    this._write("    ");
                }
                return this;
            },

            generate: function (params, jscexAst) {
                this._buffer = [];

                this._writeLine("(function (" + params.join(", ") + ") {");
                this._indentLevel++;

                this._writeIndents()
                    ._writeLine("var " + this._builderVar + " = Jscex.builders[" + stringify(this._builderName) + "];");

                this._writeIndents()
                    ._writeLine("return " + this._builderVar + ".Start(this,");
                this._indentLevel++;

                this._pos = { };

                this._writeIndents()
                    ._visitJscex(jscexAst)
                    ._writeLine();
                this._indentLevel--;

                this._writeIndents()
                    ._writeLine(");");
                this._indentLevel--;

                this._writeIndents()
                    ._write("})");

                return this._buffer.join("");
            },

            _visitJscex: function (ast) {
                this._jscexVisitors[ast.type].call(this, ast);
                return this;
            },

            _visitRaw: function (ast) {
                var type = ast[0];

                function throwUnsupportedError() {
                    throw new Error('"' + type + '" is not currently supported.');
                }

                var visitor = this._rawVisitors[type];

                if (visitor) {
                    visitor.call(this, ast);
                } else {
                    throwUnsupportedError();
                }

                return this;
            },

            _visitJscexStatements: function (statements) {
                for (var i = 0; i < statements.length; i++) {
                    var stmt = statements[i];

                    if (stmt.type == "raw" || stmt.type == "if" || stmt.type == "switch") {
                        this._writeIndents()
                            ._visitJscex(stmt)._writeLine();
                    } else if (stmt.type == "delay") {
                        this._visitJscexStatements(stmt.stmts);
                    } else {
                        this._writeIndents()
                            ._write("return ")._visitJscex(stmt)._writeLine(";");
                    }
                }
            },

            _visitRawStatements: function (statements) {
                for (var i = 0; i < statements.length; i++) {
                    var s = statements[i];

                    this._writeIndents()
                        ._visitRaw(s)._writeLine();

                    switch (s[0]) {
                        case "break":
                        case "return":
                        case "continue":
                        case "throw":
                            return;
                    }
                }
            },

            _visitRawBody: function (body) {
                if (body[0] == "block") {
                    this._visitRaw(body);
                } else {
                    this._writeLine();
                    this._indentLevel++;

                    this._writeIndents()
                        ._visitRaw(body);
                    this._indentLevel--;
                }

                return this;
            },

            _visitRawFunction: function (ast) {
                var funcName = ast[1] || "";
                var args = ast[2];
                var statements = ast[3];
                
                this._writeLine("function " + funcName + "(" + args.join(", ") + ") {")
                this._indentLevel++;

                var currInFunction = this._pos.inFunction;
                this._pos.inFunction = true;

                this._visitRawStatements(statements);
                this._indentLevel--;

                this._pos.inFunction = currInFunction;

                this._writeIndents()
                    ._write("}");
            },

            _jscexVisitors: {
                "delay": function (ast) {
                    if (ast.stmts.length == 1) {
                        var subStmt = ast.stmts[0];
                        switch (subStmt.type) {
                            case "delay":
                            case "combine":
                            case "normal":
                            case "break":
                            case "continue":
                            case "loop":
                            case "try":
                                this._visitJscex(subStmt);
                                return;
                            case "return":
                                if (!subStmt.stmt[1]) {
                                    this._visitJscex(subStmt);
                                    return;
                                }
                        }
                    }

                    this._writeLine(this._builderVar + ".Delay(function () {");
                    this._indentLevel++;

                    this._visitJscexStatements(ast.stmts);
                    this._indentLevel--;

                    this._writeIndents()
                        ._write("})");
                },

                "combine": function (ast) {
                    this._writeLine(this._builderVar + ".Combine(");
                    this._indentLevel++;

                    this._writeIndents()
                        ._visitJscex(ast.first)._writeLine(",");
                    this._writeIndents()
                        ._visitJscex(ast.second)._writeLine();
                    this._indentLevel--;

                    this._writeIndents()
                        ._write(")");
                },

                "loop": function (ast) {
                    this._writeLine(this._builderVar + ".Loop(");
                    this._indentLevel++;

                    if (ast.condition) {
                        this._writeIndents()
                            ._writeLine("function () {");
                        this._indentLevel++;

                        this._writeIndents()
                            ._write("return ")._visitRaw(ast.condition)._writeLine(";");
                        this._indentLevel--;

                        this._writeIndents()
                            ._writeLine("},");
                    } else {
                        this._writeIndents()._writeLine("null,");
                    }

                    if (ast.update) {
                        this._writeIndents()
                            ._writeLine("function () {");
                        this._indentLevel++;

                        this._writeIndents()
                            ._visitRaw(ast.update)._writeLine(";");
                        this._indentLevel--;

                        this._writeIndents()
                            ._writeLine("},");
                    } else {
                        this._writeIndents()._writeLine("null,");
                    }

                    this._writeIndents()
                        ._visitJscex(ast.bodyStmt)._writeLine(",");

                    this._writeIndents()
                        ._writeLine(ast.bodyFirst);
                    this._indentLevel--;

                    this._writeIndents()
                        ._write(")");
                },

                "raw": function (ast) {
                    this._visitRaw(ast.stmt);
                },

                "bind": function (ast) {
                    var info = ast.info;
                    this._write(this._builderVar + ".Bind(")._visitRaw(info.expression)._writeLine(", function (" + info.argName + ") {");
                    this._indentLevel++;

                    if (info.assignee == "return") {
                        this._writeIndents()
                            ._writeLine("return " + this._builderVar + ".Return(" + info.argName + ");");
                    } else {
                        if (info.assignee) {
                            this._writeIndents()
                                ._visitRaw(info.assignee)._writeLine(" = " + info.argName + ";");
                        }

                        this._visitJscexStatements(ast.stmts);
                    }
                    this._indentLevel--;

                    this._writeIndents()
                        ._write("})");
                },

                "if": function (ast) {

                    for (var i = 0; i < ast.conditionStmts.length; i++) {
                        var stmt = ast.conditionStmts[i];
                        
                        this._write("if (")._visitRaw(stmt.cond)._writeLine(") {");
                        this._indentLevel++;

                        this._visitJscexStatements(stmt.stmts);
                        this._indentLevel--;

                        this._writeIndents()
                            ._write("} else ");
                    }

                    this._writeLine("{");
                    this._indentLevel++;

                    if (ast.elseStmts) {
                        this._visitJscexStatements(ast.elseStmts);
                    } else {
                        this._writeIndents()
                            ._writeLine("return " + this._builderVar + ".Normal();");
                    }

                    this._indentLevel--;

                    this._writeIndents()
                        ._write("}");
                },

                "switch": function (ast) {
                    this._write("switch (")._visitRaw(ast.item)._writeLine(") {");
                    this._indentLevel++;

                    for (var i = 0; i < ast.caseStmts.length; i++) {
                        var caseStmt = ast.caseStmts[i];

                        if (caseStmt.item) {
                            this._writeIndents()
                                ._write("case ")._visitRaw(caseStmt.item)._writeLine(":");
                        } else {
                            this._writeIndents()._writeLine("default:");
                        }
                        this._indentLevel++;

                        this._visitJscexStatements(caseStmt.stmts);
                        this._indentLevel--;
                    }

                    this._writeIndents()
                        ._write("}");
                },

                "try": function (ast) {
                    this._writeLine(this._builderVar + ".Try(");
                    this._indentLevel++;

                    this._writeIndents()
                        ._visitJscex(ast.bodyStmt)._writeLine(",");

                    if (ast.catchStmts) {
                        this._writeIndents()
                            ._writeLine("function (" + ast.exVar + ") {");
                        this._indentLevel++;

                        this._visitJscexStatements(ast.catchStmts);
                        this._indentLevel--;

                        this._writeIndents()
                            ._writeLine("},");
                    } else {
                        this._writeIndents()
                            ._writeLine("null,");
                    }

                    if (ast.finallyStmt) {
                        this._writeIndents()
                            ._visitJscex(ast.finallyStmt)._writeLine();
                    } else {
                        this._writeIndents()
                            ._writeLine("null");
                    }
                    this._indentLevel--;

                    this._writeIndents()
                        ._write(")");
                },

                "normal": function (ast) {
                    this._write(this._builderVar + ".Normal()");
                },

                "throw": function (ast) {
                    this._write(this._builderVar + ".Throw(")._visitRaw(ast.stmt[1])._write(")");
                },

                "break": function (ast) {
                    this._write(this._builderVar + ".Break()");
                },

                "continue": function (ast) {
                    this._write(this._builderVar + ".Continue()");
                },

                "return": function (ast) {
                    this._write(this._builderVar + ".Return(");
                    if (ast.stmt[1]) this._visitRaw(ast.stmt[1]);
                    this._write(")");
                }
            },

            _rawVisitors: {
                "var": function (ast) {
                    this._write("var ");

                    var items = ast[1];
                    for (var i = 0; i < items.length; i++) {
                        this._write(items[i][0]);
                        if (items[i].length > 1) {
                            this._write(" = ")._visitRaw(items[i][1]);
                        }
                        if (i < items.length - 1) this._write(", ");
                    }

                    this._write(";");
                },

                "seq": function (ast) {
                    for (var i = 1; i < ast.length; i++) {
                        this._visitRaw(ast[i]);
                        if (i < ast.length - 1) this._write(", "); 
                    }
                },

                "binary": function (ast) {
                    var op = ast[1], left = ast[2], right = ast[3];

                    function needBracket(item) {
                        var type = item[0];
                        return !(type == "num" || type == "name" || type == "dot");
                    }

                    if (needBracket(left)) {
                        this._write("(")._visitRaw(left)._write(") ");
                    } else {
                        this._visitRaw(left)._write(" ");
                    }

                    this._write(op);

                    if (needBracket(right)) {
                        this._write(" (")._visitRaw(right)._write(")");
                    } else {
                        this._write(" ")._visitRaw(right);
                    }
                },

                "sub": function (ast) {
                    var prop = ast[1], index = ast[2];

                    function needBracket() {
                        return !(prop[0] == "name")
                    }

                    if (needBracket()) {
                        this._write("(")._visitRaw(prop)._write(")[")._visitRaw(index)._write("]");
                    } else {
                        this._visitRaw(prop)._write("[")._visitRaw(index)._write("]");
                    }
                },

                "unary-postfix": function (ast) {
                    var op = ast[1];
                    var item = ast[2];
                    this._visitRaw(item)._write(op);
                },

                "unary-prefix": function (ast) {
                    var op = ast[1];
                    var item = ast[2];
                    this._write(op);
                    if (op == "typeof") {
                        this._write("(")._visitRaw(item)._write(")");
                    } else {
                        this._visitRaw(item);
                    }
                },

                "assign": function (ast) {
                    var op = ast[1];
                    var name = ast[2];
                    var value = ast[3];

                    this._visitRaw(name);
                    if ((typeof op) == "string") {
                        this._write(" " + op + "= ");
                    } else {
                        this._write(" = ");
                    }
                    this._visitRaw(value);
                },

                "stat": function (ast) {
                    this._visitRaw(ast[1])._write(";");
                },

                "dot": function (ast) {
                    function needBracket() {
                        var leftOp = ast[1][0];
                        return !(leftOp == "dot" || leftOp == "name");
                    }

                    if (needBracket()) {
                        this._write("(")._visitRaw(ast[1])._write(").")._write(ast[2]);
                    } else {
                        this._visitRaw(ast[1])._write(".")._write(ast[2]);
                    }
                },

                "new": function (ast) {
                    var ctor = ast[1];

                    this._write("new ")._visitRaw(ctor)._write("(");

                    var args = ast[2];
                    for (var i = 0, len = args.length; i < len; i++) {
                        this._visitRaw(args[i]);
                        if (i < len - 1) this._write(", ");
                    }

                    this._write(")");
                },

                "call": function (ast) {
                
                    if (_isJscexPattern(ast)) {
                        var indent = this._indent + this._indentLevel * 4;
                        var newCode = _compileJscexPattern(ast, indent);
                        this._write(newCode);
                    } else {

                        var invalidBind = (ast[1][0] == "name") && (ast[1][1] == this._binder);
                        if (invalidBind) {
                            this._pos = { inFunction: true };
                            this._buffer = [];
                        }

                        this._visitRaw(ast[1])._write("(");

                        var args = ast[2];
                        for (var i = 0; i < args.length; i++) {
                            this._visitRaw(args[i]);
                            if (i < args.length - 1) this._write(", ");
                        }

                        this._write(")");

                        if (invalidBind) {
                            throw ("Invalid bind operation: " + this._buffer.join(""));
                        }
                    }
                },

                "name": function (ast) {
                    this._write(ast[1]);
                },

                "object": function (ast) {
                    var items = ast[1];
                    if (items.length <= 0) {
                        this._write("{ }");
                    } else {
                        this._writeLine("{");
                        this._indentLevel++;
                        
                        for (var i = 0; i < items.length; i++) {
                            this._writeIndents()
                                ._write(stringify(items[i][0]) + ": ")
                                ._visitRaw(items[i][1]);
                            
                            if (i < items.length - 1) {
                                this._writeLine(",");
                            } else {
                                this._writeLine("");
                            }
                        }
                        
                        this._indentLevel--;
                        this._writeIndents()._write("}");
                    }
                },

                "array": function (ast) {
                    this._write("[");

                    var items = ast[1];
                    for (var i = 0; i < items.length; i++) {
                        this._visitRaw(items[i]);
                        if (i < items.length - 1) this._write(", ");
                    }

                    this._write("]");
                },

                "num": function (ast) {
                    this._write(ast[1]);
                },

                "regexp": function (ast) {
                    this._write("/" + ast[1] + "/" + ast[2]);
                },

                "string": function (ast) {
                    this._write(stringify(ast[1]));
                },

                "function": function (ast) {
                    this._visitRawFunction(ast);
                },

                "defun": function (ast) {
                    this._visitRawFunction(ast);
                },

                "return": function (ast) {
                    if (this._pos.inFunction) {
                        this._write("return");
                        var value = ast[1];
                        if (value) this._write(" ")._visitRaw(value);
                        this._write(";");
                    } else {
                        this._write("return ")._visitJscex({ type: "return", stmt: ast })._write(";");
                    }
                },
                
                "for": function (ast) {
                    this._write("for (");

                    var setup = ast[1];
                    if (setup) {
                        this._visitRaw(setup);
                        if (setup[0] != "var") {
                            this._write("; ");
                        } else {
                            this._write(" ");
                        }
                    } else {
                        this._write("; ");
                    }

                    var condition = ast[2];
                    if (condition) this._visitRaw(condition);
                    this._write("; ");

                    var update = ast[3];
                    if (update) this._visitRaw(update);
                    this._write(") ");

                    var currInLoop = this._pos.inLoop;
                    this._pos.inLoop = true;

                    var body = ast[4];
                    this._visitRawBody(body);

                    this._pos.inLoop = currInLoop;
                },

                "for-in": function (ast) {
                    this._write("for (");

                    var declare = ast[1];
                    if (declare[0] == "var") { // declare == ["var", [["m"]]]
                        this._write("var " + declare[1][0][0]);
                    } else {
                        this._visitRaw(declare);
                    }
                    
                    this._write(" in ")._visitRaw(ast[3])._write(") ");

                    var body = ast[4];
                    this._visitRawBody(body);
                },

                "block": function (ast) {
                    this._writeLine("{")
                    this._indentLevel++;

                    this._visitRawStatements(ast[1]);
                    this._indentLevel--;

                    this._writeIndents()
                        ._write("}");
                },

                "while": function (ast) {
                    var condition = ast[1];
                    var body = ast[2];

                    var currInLoop = this._pos.inLoop
                    this._pos.inLoop = true;

                    this._write("while (")._visitRaw(condition)._write(") ")._visitRawBody(body);

                    this._pos.inLoop = currInLoop;
                },

                "do": function (ast) {
                    var condition = ast[1];
                    var body = ast[2];

                    var currInLoop = this._pos.inLoop;
                    this._pos.inLoop = true;

                    this._write("do ")._visitRawBody(body);

                    this._pos.inLoop = currInLoop;

                    if (body[0] == "block") {
                        this._write(" ");
                    } else {
                        this._writeLine()._writeIndents();
                    }

                    this._write("while (")._visitRaw(condition)._write(");");
                },

                "if": function (ast) {
                    var condition = ast[1];
                    var thenPart = ast[2];

                    this._write("if (")._visitRaw(condition)._write(") ")._visitRawBody(thenPart);

                    var elsePart = ast[3];
                    if (elsePart) {
                        if (thenPart[0] == "block") {
                            this._write(" ");
                        } else {
                            this._writeLine("")
                                ._writeIndents();
                        }

                        if (elsePart[0] == "if") {
                            this._write("else ")._visitRaw(elsePart);
                        } else {
                            this._write("else ")._visitRawBody(elsePart);
                        }
                    }
                },

                "break": function (ast) {
                    if (this._pos.inLoop || this._pos.inSwitch) {
                        this._write("break;");
                    } else {
                        this._write("return ")._visitJscex({ type: "break", stmt: ast })._write(";");
                    }
                },

                "continue": function (ast) {
                    if (this._pos.inLoop) {
                        this._write("continue;");
                    } else {
                        this._write("return ")._visitJscex({ type: "continue", stmt: ast })._write(";");
                    }
                },

                "throw": function (ast) {
                    var pos = this._pos;
                    if (pos.inTry || pos.inFunction) {
                        this._write("throw ")._visitRaw(ast[1])._write(";");
                    } else {
                        this._write("return ")._visitJscex({ type: "throw", stmt: ast })._write(";");
                    }
                },

                "conditional": function (ast) {
                    this._write("(")._visitRaw(ast[1])._write(") ? (")._visitRaw(ast[2])._write(") : (")._visitRaw(ast[3])._write(")");
                },

                "try": function (ast) {

                    this._writeLine("try {");
                    this._indentLevel++;

                    var currInTry = this._pos.inTry;
                    this._pos.inTry = true;

                    this._visitRawStatements(ast[1]);
                    this._indentLevel--;

                    this._pos.inTry = currInTry;

                    var catchClause = ast[2];
                    var finallyStatements = ast[3];

                    if (catchClause) {
                        this._writeIndents()
                            ._writeLine("} catch (" + catchClause[0] + ") {")
                        this._indentLevel++;

                        this._visitRawStatements(catchClause[1]);
                        this._indentLevel--;
                    }

                    if (finallyStatements) {
                        this._writeIndents()
                            ._writeLine("} finally {");
                        this._indentLevel++;

                        this._visitRawStatements(finallyStatements);
                        this._indentLevel--;
                    }                

                    this._writeIndents()
                        ._write("}");
                },

                "switch": function (ast) {
                    this._write("switch (")._visitRaw(ast[1])._writeLine(") {");
                    this._indentLevel++;

                    var currInSwitch = this._pos.inSwitch;
                    this._pos.inSwitch = true;

                    var cases = ast[2];
                    for (var i = 0; i < cases.length; i++) {
                        var c = cases[i];
                        this._writeIndents();

                        if (c[0]) {
                            this._write("case ")._visitRaw(c[0])._writeLine(":");
                        } else {
                            this._writeLine("default:");
                        }
                        this._indentLevel++;

                        this._visitRawStatements(c[1]);
                        this._indentLevel--;
                    }
                    this._indentLevel--;

                    this._pos.inSwitch = currInSwitch;

                    this._writeIndents()
                        ._write("}");
                }
            }
        }

        function _isJscexPattern(ast) {
            if (ast[0] != "call") return false;
            
            var evalName = ast[1];
            if (evalName[0] != "name" || evalName[1] != "eval") return false;

            var compileCall = ast[2][0];
            if (!compileCall || compileCall[0] != "call") return false;

            var compileMethod = compileCall[1];
            if (!compileMethod || compileMethod[0] != "dot" || compileMethod[2] != "compile") return false;

            var jscexName = compileMethod[1];
            if (!jscexName || jscexName[0] != "name" || jscexName[1] != "Jscex") return false;

            var builder = compileCall[2][0];
            if (!builder || builder[0] != "string") return false;

            var func = compileCall[2][1];
            if (!func || func[0] != "function") return false;

            return true;
        }
        
        function _compileJscexPattern(ast, indent) {

            var builderName = ast[2][0][2][0][1];
            var funcAst = ast[2][0][2][1];
            var binder = root.binders[builderName];

            var jscexTreeGenerator = new JscexTreeGenerator(binder);
            var jscexAst = jscexTreeGenerator.generate(funcAst);

            var codeGenerator = new CodeGenerator(builderName, binder, indent);
            var newCode = codeGenerator.generate(funcAst[2], jscexAst);

            return newCode;
        }
        
        function compile(builderName, func) {

            var funcCode = func.toString();
            var evalCode = "eval(Jscex.compile(" + stringify(builderName) + ", " + funcCode + "))"
            var evalCodeAst = root.parse(evalCode);

            // [ "toplevel", [ [ "stat", [ "call", ... ] ] ] ]
            var evalAst = evalCodeAst[1][0][1];
            var newCode = _compileJscexPattern(evalAst, 0);

            root.logger.debug(funcCode + "\n\n>>>\n\n" + newCode);
            
            return codeGenerator(newCode);
        };

        root.compile = compile;
        
        root.modules["jit"] = true;
    }
    
    var isCommonJS = (typeof require !== "undefined" && typeof module !== "undefined" && module.exports);
    var isAmd = (typeof define !== "undefined" && define.amd);
    
    if (isCommonJS) {
        module.exports.init = function (root) {
            if (!root.modules["parser"]) {
                require("./jscex-parser").init(root);
            };
            
            init(root);
        }
    } else if (isAmd) {
        define("jscex-jit", ["jscex-parser"], function (parser) {
            return {
                init: function (root) {
                    if (!root.modules["parser"]) {
                        parser.init(root);
                    }
                    
                    init(root);
                }
            };
        });
    } else {
        if (typeof Jscex === "undefined") {
            throw new Error('Missing root object, please load "jscex" module first.');
        }
        
        if (!Jscex.modules["parser"]) {
            throw new Error('Missing essential components, please initialize "parser" module first.');
        }

        init(Jscex);
    }

})();