| /*********************************************************************** |
| |
| 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() { |
| function normalize_directives(body) { |
| var in_directive = true; |
| for (var i = 0; i < body.length; i++) { |
| if (in_directive && body[i] instanceof AST_Statement && body[i].body instanceof AST_String) { |
| body[i] = new AST_Directive({ |
| start: body[i].start, |
| end: body[i].end, |
| value: body[i].body.value |
| }); |
| } else if (in_directive && !(body[i] instanceof AST_Statement && body[i].body instanceof AST_String)) { |
| in_directive = false; |
| } |
| } |
| return body; |
| } |
| |
| var MOZ_TO_ME = { |
| Program: function(M) { |
| return new AST_Toplevel({ |
| start: my_start_token(M), |
| end: my_end_token(M), |
| body: normalize_directives(M.body.map(from_moz)) |
| }); |
| }, |
| FunctionDeclaration: function(M) { |
| return new AST_Defun({ |
| start: my_start_token(M), |
| end: my_end_token(M), |
| name: from_moz(M.id), |
| argnames: M.params.map(from_moz), |
| body: normalize_directives(from_moz(M.body).body) |
| }); |
| }, |
| FunctionExpression: function(M) { |
| return new AST_Function({ |
| start: my_start_token(M), |
| end: my_end_token(M), |
| name: from_moz(M.id), |
| argnames: M.params.map(from_moz), |
| body: normalize_directives(from_moz(M.body).body) |
| }); |
| }, |
| ExpressionStatement: function(M) { |
| return new AST_SimpleStatement({ |
| start: my_start_token(M), |
| end: my_end_token(M), |
| body: from_moz(M.expression) |
| }); |
| }, |
| TryStatement: function(M) { |
| var handlers = M.handlers || [M.handler]; |
| if (handlers.length > 1 || M.guardedHandlers && M.guardedHandlers.length) { |
| throw new Error("Multiple catch clauses are not supported."); |
| } |
| return new AST_Try({ |
| start : my_start_token(M), |
| end : my_end_token(M), |
| body : from_moz(M.block).body, |
| bcatch : from_moz(handlers[0]), |
| bfinally : M.finalizer ? new AST_Finally(from_moz(M.finalizer)) : null |
| }); |
| }, |
| Property: function(M) { |
| var key = M.key; |
| var args = { |
| start : my_start_token(key), |
| end : my_end_token(M.value), |
| key : key.type == "Identifier" ? key.name : key.value, |
| value : from_moz(M.value) |
| }; |
| if (M.kind == "init") return new AST_ObjectKeyVal(args); |
| args.key = new AST_SymbolAccessor({ |
| name: args.key |
| }); |
| args.value = new AST_Accessor(args.value); |
| if (M.kind == "get") return new AST_ObjectGetter(args); |
| if (M.kind == "set") return new AST_ObjectSetter(args); |
| }, |
| ArrayExpression: function(M) { |
| return new AST_Array({ |
| start : my_start_token(M), |
| end : my_end_token(M), |
| elements : M.elements.map(function(elem) { |
| return elem === null ? new AST_Hole() : from_moz(elem); |
| }) |
| }); |
| }, |
| ObjectExpression: function(M) { |
| return new AST_Object({ |
| start : my_start_token(M), |
| end : my_end_token(M), |
| properties : M.properties.map(function(prop) { |
| prop.type = "Property"; |
| return from_moz(prop) |
| }) |
| }); |
| }, |
| SequenceExpression: function(M) { |
| return new AST_Sequence({ |
| start : my_start_token(M), |
| end : my_end_token(M), |
| expressions: 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) |
| }); |
| }, |
| VariableDeclaration: function(M) { |
| return new AST_Var({ |
| start : my_start_token(M), |
| end : my_end_token(M), |
| definitions : M.declarations.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); |
| var rx = M.regex; |
| if (rx && rx.pattern) { |
| // RegExpLiteral as per ESTree AST spec |
| args.value = new RegExp(rx.pattern, rx.flags); |
| args.value.raw_source = rx.pattern; |
| return new AST_RegExp(args); |
| } else if (rx) { |
| // support legacy RegExp |
| args.value = M.regex && M.raw ? M.raw : val; |
| return new AST_RegExp(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); |
| } |
| }, |
| Identifier: function(M) { |
| var p = FROM_MOZ_STACK[FROM_MOZ_STACK.length - 2]; |
| return new ( p.type == "LabeledStatement" ? AST_Label |
| : p.type == "VariableDeclarator" && p.id === M ? 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 |
| }); |
| } |
| }; |
| |
| MOZ_TO_ME.UpdateExpression = |
| MOZ_TO_ME.UnaryExpression = function To_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) |
| }); |
| }; |
| |
| map("EmptyStatement", AST_EmptyStatement); |
| map("BlockStatement", AST_BlockStatement, "body@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("VariableDeclarator", AST_VarDef, "id>name, init>value"); |
| map("CatchClause", AST_Catch, "param>argname, body%body"); |
| |
| map("ThisExpression", AST_This); |
| map("BinaryExpression", AST_Binary, "operator=operator, left>left, right>right"); |
| map("LogicalExpression", AST_Binary, "operator=operator, left>left, right>right"); |
| map("AssignmentExpression", AST_Assign, "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"); |
| |
| def_to_moz(AST_Toplevel, function To_Moz_Program(M) { |
| return to_moz_scope("Program", M); |
| }); |
| |
| def_to_moz(AST_Defun, function To_Moz_FunctionDeclaration(M) { |
| return { |
| type: "FunctionDeclaration", |
| id: to_moz(M.name), |
| params: M.argnames.map(to_moz), |
| body: to_moz_scope("BlockStatement", M) |
| } |
| }); |
| |
| def_to_moz(AST_Function, function To_Moz_FunctionExpression(M) { |
| return { |
| type: "FunctionExpression", |
| id: to_moz(M.name), |
| params: M.argnames.map(to_moz), |
| body: to_moz_scope("BlockStatement", M) |
| } |
| }); |
| |
| def_to_moz(AST_Directive, function To_Moz_Directive(M) { |
| return { |
| type: "ExpressionStatement", |
| expression: { |
| type: "Literal", |
| value: M.value |
| } |
| }; |
| }); |
| |
| def_to_moz(AST_SimpleStatement, function To_Moz_ExpressionStatement(M) { |
| return { |
| type: "ExpressionStatement", |
| expression: to_moz(M.body) |
| }; |
| }); |
| |
| def_to_moz(AST_SwitchBranch, function To_Moz_SwitchCase(M) { |
| return { |
| type: "SwitchCase", |
| test: to_moz(M.expression), |
| consequent: M.body.map(to_moz) |
| }; |
| }); |
| |
| def_to_moz(AST_Try, function To_Moz_TryStatement(M) { |
| return { |
| type: "TryStatement", |
| block: to_moz_block(M), |
| handler: to_moz(M.bcatch), |
| guardedHandlers: [], |
| finalizer: to_moz(M.bfinally) |
| }; |
| }); |
| |
| def_to_moz(AST_Catch, function To_Moz_CatchClause(M) { |
| return { |
| type: "CatchClause", |
| param: to_moz(M.argname), |
| guard: null, |
| body: to_moz_block(M) |
| }; |
| }); |
| |
| def_to_moz(AST_Definitions, function To_Moz_VariableDeclaration(M) { |
| return { |
| type: "VariableDeclaration", |
| kind: "var", |
| declarations: M.definitions.map(to_moz) |
| }; |
| }); |
| |
| def_to_moz(AST_Sequence, function To_Moz_SequenceExpression(M) { |
| return { |
| type: "SequenceExpression", |
| expressions: M.expressions.map(to_moz) |
| }; |
| }); |
| |
| def_to_moz(AST_PropAccess, function To_Moz_MemberExpression(M) { |
| var isComputed = M instanceof AST_Sub; |
| return { |
| type: "MemberExpression", |
| object: to_moz(M.expression), |
| computed: isComputed, |
| property: isComputed ? to_moz(M.property) : {type: "Identifier", name: M.property} |
| }; |
| }); |
| |
| def_to_moz(AST_Unary, function To_Moz_Unary(M) { |
| return { |
| type: M.operator == "++" || M.operator == "--" ? "UpdateExpression" : "UnaryExpression", |
| operator: M.operator, |
| prefix: M instanceof AST_UnaryPrefix, |
| argument: to_moz(M.expression) |
| }; |
| }); |
| |
| def_to_moz(AST_Binary, function To_Moz_BinaryExpression(M) { |
| return { |
| type: M.operator == "&&" || M.operator == "||" ? "LogicalExpression" : "BinaryExpression", |
| left: to_moz(M.left), |
| operator: M.operator, |
| right: to_moz(M.right) |
| }; |
| }); |
| |
| def_to_moz(AST_Array, function To_Moz_ArrayExpression(M) { |
| return { |
| type: "ArrayExpression", |
| elements: M.elements.map(to_moz) |
| }; |
| }); |
| |
| def_to_moz(AST_Object, function To_Moz_ObjectExpression(M) { |
| return { |
| type: "ObjectExpression", |
| properties: M.properties.map(to_moz) |
| }; |
| }); |
| |
| def_to_moz(AST_ObjectProperty, function To_Moz_Property(M) { |
| var key = { |
| type: "Literal", |
| value: M.key instanceof AST_SymbolAccessor ? M.key.name : M.key |
| }; |
| var kind; |
| if (M instanceof AST_ObjectKeyVal) { |
| kind = "init"; |
| } else |
| if (M instanceof AST_ObjectGetter) { |
| kind = "get"; |
| } else |
| if (M instanceof AST_ObjectSetter) { |
| kind = "set"; |
| } |
| return { |
| type: "Property", |
| kind: kind, |
| key: key, |
| value: to_moz(M.value) |
| }; |
| }); |
| |
| def_to_moz(AST_Symbol, function To_Moz_Identifier(M) { |
| var def = M.definition(); |
| return { |
| type: "Identifier", |
| name: def && def.mangled_name || M.name |
| }; |
| }); |
| |
| def_to_moz(AST_RegExp, function To_Moz_RegExpLiteral(M) { |
| var flags = M.value.toString().match(/[gimuy]*$/)[0]; |
| var value = "/" + M.value.raw_source + "/" + flags; |
| return { |
| type: "Literal", |
| value: value, |
| raw: value, |
| regex: { |
| pattern: M.value.raw_source, |
| flags: flags |
| } |
| }; |
| }); |
| |
| def_to_moz(AST_Constant, function To_Moz_Literal(M) { |
| var value = M.value; |
| if (typeof value === 'number' && (value < 0 || (value === 0 && 1 / value < 0))) { |
| return { |
| type: "UnaryExpression", |
| operator: "-", |
| prefix: true, |
| argument: { |
| type: "Literal", |
| value: -value, |
| raw: M.start.raw |
| } |
| }; |
| } |
| return { |
| type: "Literal", |
| value: value, |
| raw: M.start.raw |
| }; |
| }); |
| |
| def_to_moz(AST_Atom, function To_Moz_Atom(M) { |
| return { |
| type: "Identifier", |
| name: String(M.value) |
| }; |
| }); |
| |
| AST_Boolean.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast); |
| AST_Null.DEFMETHOD("to_mozilla_ast", AST_Constant.prototype.to_mozilla_ast); |
| AST_Hole.DEFMETHOD("to_mozilla_ast", function To_Moz_ArrayHole() { return null }); |
| |
| AST_Block.DEFMETHOD("to_mozilla_ast", AST_BlockStatement.prototype.to_mozilla_ast); |
| AST_Lambda.DEFMETHOD("to_mozilla_ast", AST_Function.prototype.to_mozilla_ast); |
| |
| /* -----[ tools ]----- */ |
| |
| function raw_token(moznode) { |
| if (moznode.type == "Literal") { |
| return moznode.raw != null ? moznode.raw : moznode.value + ""; |
| } |
| } |
| |
| function my_start_token(moznode) { |
| var loc = moznode.loc, start = loc && loc.start; |
| var range = moznode.range; |
| return new AST_Token({ |
| file : loc && loc.source, |
| line : start && start.line, |
| col : start && start.column, |
| pos : range ? range[0] : moznode.start, |
| endline : start && start.line, |
| endcol : start && start.column, |
| endpos : range ? range[0] : moznode.start, |
| raw : raw_token(moznode), |
| }); |
| } |
| |
| function my_end_token(moznode) { |
| var loc = moznode.loc, end = loc && loc.end; |
| var range = moznode.range; |
| return new AST_Token({ |
| file : loc && loc.source, |
| line : end && end.line, |
| col : end && end.column, |
| pos : range ? range[1] : moznode.end, |
| endline : end && end.line, |
| endcol : end && end.column, |
| endpos : range ? range[1] : moznode.end, |
| raw : raw_token(moznode), |
| }); |
| } |
| |
| function map(moztype, mytype, propmap) { |
| var moz_to_me = "function From_Moz_" + moztype + "(M){\n"; |
| moz_to_me += "return new U2." + mytype.name + "({\n" + |
| "start: my_start_token(M),\n" + |
| "end: my_end_token(M)"; |
| |
| var me_to_moz = "function To_Moz_" + moztype + "(M){\n"; |
| me_to_moz += "return {\n" + |
| "type: " + JSON.stringify(moztype); |
| |
| 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[1], how = m[2], my = m[3]; |
| moz_to_me += ",\n" + my + ": "; |
| me_to_moz += ",\n" + moz + ": "; |
| switch (how) { |
| case "@": |
| moz_to_me += "M." + moz + ".map(from_moz)"; |
| me_to_moz += "M." + my + ".map(to_moz)"; |
| break; |
| case ">": |
| moz_to_me += "from_moz(M." + moz + ")"; |
| me_to_moz += "to_moz(M." + my + ")"; |
| break; |
| case "=": |
| moz_to_me += "M." + moz; |
| me_to_moz += "M." + my; |
| break; |
| case "%": |
| moz_to_me += "from_moz(M." + moz + ").body"; |
| me_to_moz += "to_moz_block(M)"; |
| break; |
| default: |
| throw new Error("Can't understand operator in propmap: " + prop); |
| } |
| }); |
| |
| moz_to_me += "\n})\n}"; |
| me_to_moz += "\n}\n}"; |
| |
| //moz_to_me = parse(moz_to_me).print_to_string({ beautify: true }); |
| //me_to_moz = parse(me_to_moz).print_to_string({ beautify: true }); |
| //console.log(moz_to_me); |
| |
| moz_to_me = new Function("U2", "my_start_token", "my_end_token", "from_moz", "return(" + moz_to_me + ")")( |
| exports, my_start_token, my_end_token, from_moz |
| ); |
| me_to_moz = new Function("to_moz", "to_moz_block", "to_moz_scope", "return(" + me_to_moz + ")")( |
| to_moz, to_moz_block, to_moz_scope |
| ); |
| MOZ_TO_ME[moztype] = moz_to_me; |
| def_to_moz(mytype, me_to_moz); |
| } |
| |
| 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; |
| ast.walk(new TreeWalker(function(node) { |
| if (node instanceof AST_LabelRef) { |
| for (var level = 0, parent; parent = this.parent(level); level++) { |
| if (parent instanceof AST_Scope) break; |
| if (parent instanceof AST_LabeledStatement && parent.label.name == node.name) { |
| node.thedef = parent.label; |
| break; |
| } |
| } |
| if (!node.thedef) { |
| var s = node.start; |
| js_error("Undefined label " + node.name, s.file, s.line, s.col, s.pos); |
| } |
| } |
| })); |
| return ast; |
| }; |
| |
| function set_moz_loc(mynode, moznode, myparent) { |
| var start = mynode.start; |
| var end = mynode.end; |
| if (start.pos != null && end.endpos != null) { |
| moznode.range = [start.pos, end.endpos]; |
| } |
| if (start.line) { |
| moznode.loc = { |
| start: {line: start.line, column: start.col}, |
| end: end.endline ? {line: end.endline, column: end.endcol} : null |
| }; |
| if (start.file) { |
| moznode.loc.source = start.file; |
| } |
| } |
| return moznode; |
| } |
| |
| function def_to_moz(mytype, handler) { |
| mytype.DEFMETHOD("to_mozilla_ast", function() { |
| return set_moz_loc(this, handler(this)); |
| }); |
| } |
| |
| function to_moz(node) { |
| return node != null ? node.to_mozilla_ast() : null; |
| } |
| |
| function to_moz_block(node) { |
| return { |
| type: "BlockStatement", |
| body: node.body.map(to_moz) |
| }; |
| } |
| |
| function to_moz_scope(type, node) { |
| var body = node.body.map(to_moz); |
| if (node.body[0] instanceof AST_SimpleStatement && node.body[0].body instanceof AST_String) { |
| body.unshift(to_moz(new AST_EmptyStatement(node.body[0]))); |
| } |
| return { |
| type: type, |
| body: body |
| }; |
| } |
| })(); |