niushuai233
/
love
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
love page
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
0 Tags
2.1 MiB
 
 
 
Tree: 3603c14d65
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3603c14d65'
${ noResults }
love/Love_files/jscex-jit.js

1406 lines
49 KiB
Raw Blame History

(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);
}
})();