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.
267 lines
11 KiB
267 lines
11 KiB
/***********************************************************************
|
|
|
|
A JavaScript tokenizer / parser / beautifier / compressor.
|
|
https://github.com/mishoo/UglifyJS2
|
|
|
|
-------------------------------- (C) ---------------------------------
|
|
|
|
Author: Mihai Bazon
|
|
<mihai.bazon@gmail.com>
|
|
http://mihai.bazon.net/blog
|
|
|
|
Distributed under the BSD license:
|
|
|
|
Copyright 2012 (c) Mihai Bazon <mihai.bazon@gmail.com>
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the following
|
|
disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the following
|
|
disclaimer in the documentation and/or other materials
|
|
provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
|
|
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
|
|
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
|
|
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
SUCH DAMAGE.
|
|
|
|
***********************************************************************/
|
|
|
|
"use strict";
|
|
|
|
(function(){
|
|
|
|
var MOZ_TO_ME = {
|
|
TryStatement : function(M) {
|
|
return new AST_Try({
|
|
start : my_start_token(M),
|
|
end : my_end_token(M),
|
|
body : from_moz(M.block).body,
|
|
bcatch : from_moz(M.handlers[0]),
|
|
bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null
|
|
});
|
|
},
|
|
CatchClause : function(M) {
|
|
return new AST_Catch({
|
|
start : my_start_token(M),
|
|
end : my_end_token(M),
|
|
argname : from_moz(M.param),
|
|
body : from_moz(M.body).body
|
|
});
|
|
},
|
|
ObjectExpression : function(M) {
|
|
return new AST_Object({
|
|
start : my_start_token(M),
|
|
end : my_end_token(M),
|
|
properties : M.properties.map(function(prop){
|
|
var key = prop.key;
|
|
var name = key.type == "Identifier" ? key.name : key.value;
|
|
var args = {
|
|
start : my_start_token(key),
|
|
end : my_end_token(prop.value),
|
|
key : name,
|
|
value : from_moz(prop.value)
|
|
};
|
|
switch (prop.kind) {
|
|
case "init":
|
|
return new AST_ObjectKeyVal(args);
|
|
case "set":
|
|
args.value.name = from_moz(key);
|
|
return new AST_ObjectSetter(args);
|
|
case "get":
|
|
args.value.name = from_moz(key);
|
|
return new AST_ObjectGetter(args);
|
|
}
|
|
})
|
|
});
|
|
},
|
|
SequenceExpression : function(M) {
|
|
return AST_Seq.from_array(M.expressions.map(from_moz));
|
|
},
|
|
MemberExpression : function(M) {
|
|
return new (M.computed ? AST_Sub : AST_Dot)({
|
|
start : my_start_token(M),
|
|
end : my_end_token(M),
|
|
property : M.computed ? from_moz(M.property) : M.property.name,
|
|
expression : from_moz(M.object)
|
|
});
|
|
},
|
|
SwitchCase : function(M) {
|
|
return new (M.test ? AST_Case : AST_Default)({
|
|
start : my_start_token(M),
|
|
end : my_end_token(M),
|
|
expression : from_moz(M.test),
|
|
body : M.consequent.map(from_moz)
|
|
});
|
|
},
|
|
Literal : function(M) {
|
|
var val = M.value, args = {
|
|
start : my_start_token(M),
|
|
end : my_end_token(M)
|
|
};
|
|
if (val === null) return new AST_Null(args);
|
|
switch (typeof val) {
|
|
case "string":
|
|
args.value = val;
|
|
return new AST_String(args);
|
|
case "number":
|
|
args.value = val;
|
|
return new AST_Number(args);
|
|
case "boolean":
|
|
return new (val ? AST_True : AST_False)(args);
|
|
default:
|
|
args.value = val;
|
|
return new AST_RegExp(args);
|
|
}
|
|
},
|
|
UnaryExpression: From_Moz_Unary,
|
|
UpdateExpression: From_Moz_Unary,
|
|
Identifier: function(M) {
|
|
var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2];
|
|
return new (M.name == "this" ? AST_This
|
|
: p.type == "LabeledStatement" ? AST_Label
|
|
: p.type == "VariableDeclarator" && p.id === M ? (p.kind == "const" ? AST_SymbolConst : AST_SymbolVar)
|
|
: p.type == "FunctionExpression" ? (p.id === M ? AST_SymbolLambda : AST_SymbolFunarg)
|
|
: p.type == "FunctionDeclaration" ? (p.id === M ? AST_SymbolDefun : AST_SymbolFunarg)
|
|
: p.type == "CatchClause" ? AST_SymbolCatch
|
|
: p.type == "BreakStatement" || p.type == "ContinueStatement" ? AST_LabelRef
|
|
: AST_SymbolRef)({
|
|
start : my_start_token(M),
|
|
end : my_end_token(M),
|
|
name : M.name
|
|
});
|
|
}
|
|
};
|
|
|
|
function From_Moz_Unary(M) {
|
|
var prefix = "prefix" in M ? M.prefix
|
|
: M.type == "UnaryExpression" ? true : false;
|
|
return new (prefix ? AST_UnaryPrefix : AST_UnaryPostfix)({
|
|
start : my_start_token(M),
|
|
end : my_end_token(M),
|
|
operator : M.operator,
|
|
expression : from_moz(M.argument)
|
|
});
|
|
};
|
|
|
|
var ME_TO_MOZ = {};
|
|
|
|
map("Node", AST_Node);
|
|
map("Program", AST_Toplevel, "body@body");
|
|
map("Function", AST_Function, "id>name, params@argnames, body%body");
|
|
map("EmptyStatement", AST_EmptyStatement);
|
|
map("BlockStatement", AST_BlockStatement, "body@body");
|
|
map("ExpressionStatement", AST_SimpleStatement, "expression>body");
|
|
map("IfStatement", AST_If, "test>condition, consequent>body, alternate>alternative");
|
|
map("LabeledStatement", AST_LabeledStatement, "label>label, body>body");
|
|
map("BreakStatement", AST_Break, "label>label");
|
|
map("ContinueStatement", AST_Continue, "label>label");
|
|
map("WithStatement", AST_With, "object>expression, body>body");
|
|
map("SwitchStatement", AST_Switch, "discriminant>expression, cases@body");
|
|
map("ReturnStatement", AST_Return, "argument>value");
|
|
map("ThrowStatement", AST_Throw, "argument>value");
|
|
map("WhileStatement", AST_While, "test>condition, body>body");
|
|
map("DoWhileStatement", AST_Do, "test>condition, body>body");
|
|
map("ForStatement", AST_For, "init>init, test>condition, update>step, body>body");
|
|
map("ForInStatement", AST_ForIn, "left>init, right>object, body>body");
|
|
map("DebuggerStatement", AST_Debugger);
|
|
map("FunctionDeclaration", AST_Defun, "id>name, params@argnames, body%body");
|
|
map("VariableDeclaration", AST_Var, "declarations@definitions");
|
|
map("VariableDeclarator", AST_VarDef, "id>name, init>value");
|
|
|
|
map("ThisExpression", AST_This);
|
|
map("ArrayExpression", AST_Array, "elements@elements");
|
|
map("FunctionExpression", AST_Function, "id>name, params@argnames, body%body");
|
|
map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right");
|
|
map("AssignmentExpression", AST_Assign, "operator=operator, left>left, right>right");
|
|
map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right");
|
|
map("ConditionalExpression", AST_Conditional, "test>condition, consequent>consequent, alternate>alternative");
|
|
map("NewExpression", AST_New, "callee>expression, arguments@args");
|
|
map("CallExpression", AST_Call, "callee>expression, arguments@args");
|
|
|
|
/* -----[ tools ]----- */
|
|
|
|
function my_start_token(moznode) {
|
|
return new AST_Token({
|
|
file : moznode.loc && moznode.loc.source,
|
|
line : moznode.loc && moznode.loc.start.line,
|
|
col : moznode.loc && moznode.loc.start.column,
|
|
pos : moznode.start,
|
|
endpos : moznode.start
|
|
});
|
|
};
|
|
|
|
function my_end_token(moznode) {
|
|
return new AST_Token({
|
|
file : moznode.loc && moznode.loc.source,
|
|
line : moznode.loc && moznode.loc.end.line,
|
|
col : moznode.loc && moznode.loc.end.column,
|
|
pos : moznode.end,
|
|
endpos : moznode.end
|
|
});
|
|
};
|
|
|
|
function map(moztype, mytype, propmap) {
|
|
var moz_to_me = "function From_Moz_" + moztype + "(M){\n";
|
|
moz_to_me += "return new mytype({\n" +
|
|
"start: my_start_token(M),\n" +
|
|
"end: my_end_token(M)";
|
|
|
|
if (propmap) propmap.split(/\s*,\s*/).forEach(function(prop){
|
|
var m = /([a-z0-9$_]+)(=|@|>|%)([a-z0-9$_]+)/i.exec(prop);
|
|
if (!m) throw new Error("Can't understand property map: " + prop);
|
|
var moz = "M." + m[1], how = m[2], my = m[3];
|
|
moz_to_me += ",\n" + my + ": ";
|
|
if (how == "@") {
|
|
moz_to_me += moz + ".map(from_moz)";
|
|
} else if (how == ">") {
|
|
moz_to_me += "from_moz(" + moz + ")";
|
|
} else if (how == "=") {
|
|
moz_to_me += moz;
|
|
} else if (how == "%") {
|
|
moz_to_me += "from_moz(" + moz + ").body";
|
|
} else throw new Error("Can't understand operator in propmap: " + prop);
|
|
});
|
|
moz_to_me += "\n})}";
|
|
|
|
// moz_to_me = parse(moz_to_me).print_to_string({ beautify: true });
|
|
// console.log(moz_to_me);
|
|
|
|
moz_to_me = new Function("mytype", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")(
|
|
mytype, my_start_token, my_end_token, from_moz
|
|
);
|
|
return MOZ_TO_ME[moztype] = moz_to_me;
|
|
};
|
|
|
|
var FROM_MOZ_STACK = null;
|
|
|
|
function from_moz(node) {
|
|
FROM_MOZ_STACK.push(node);
|
|
var ret = node != null ? MOZ_TO_ME[node.type](node) : null;
|
|
FROM_MOZ_STACK.pop();
|
|
return ret;
|
|
};
|
|
|
|
AST_Node.from_mozilla_ast = function(node){
|
|
var save_stack = FROM_MOZ_STACK;
|
|
FROM_MOZ_STACK = [];
|
|
var ast = from_moz(node);
|
|
FROM_MOZ_STACK = save_stack;
|
|
return ast;
|
|
};
|
|
|
|
})();
|