[Pkg-mozext-commits] [adblock-plus] 278/464: Updated Adblock Plus rewrite scripts to work with the Reflect.parse() output (simplified processing, more relevant cases handled)
David Prévot
taffit at moszumanska.debian.org
Tue Jul 22 20:44:25 UTC 2014
This is an automated email from the git hooks/post-receive script.
taffit pushed a commit to branch master
in repository adblock-plus.
commit c188963f9a586d51d747fc14bffed4514e5f4745
Author: Wladimir Palant <trev at adblockplus.org>
Date: Fri Aug 24 13:43:35 2012 +0200
Updated Adblock Plus rewrite scripts to work with the Reflect.parse() output (simplified processing, more relevant cases handled)
---
scripts/abprewrite-module.js | 7 -
scripts/abprewrite.js | 754 ++++++++++--------------
utils/beautify.js | 1322 ++++++++++++++++++++++++++++++++++++++++++
3 files changed, 1627 insertions(+), 456 deletions(-)
diff --git a/scripts/abprewrite-module.js b/scripts/abprewrite-module.js
deleted file mode 100644
index 1139014..0000000
--- a/scripts/abprewrite-module.js
+++ /dev/null
@@ -1,7 +0,0 @@
-// This script rewrites AST to be compatible with JavaScript 1.5 and decompiles
-// the modified tree then
-
-var isModule = true;
-
-include("decompile.js");
-include("abprewrite.js");
diff --git a/scripts/abprewrite.js b/scripts/abprewrite.js
index 640ee3c..4659855 100644
--- a/scripts/abprewrite.js
+++ b/scripts/abprewrite.js
@@ -1,518 +1,374 @@
// This script rewrites AST to be compatible with JavaScript 1.5 and decompiles
// the modified tree then
-include("decompile.js");
-
-function Node(props)
-{
- for (var k in props)
- {
- this[k] = props[k];
- }
-}
-Node.prototype =
-{
- visit: function(visitor)
- {
- return walkAST(this, visitor);
- }
+// Output license header and warning - do this only once, not each time a file
+// is being processed.
+_print('/*');
+_print(' * This Source Code is subject to the terms of the Mozilla Public License');
+_print(' * version 2.0 (the "License"). You can obtain a copy of the License at');
+_print(' * http://mozilla.org/MPL/2.0/.');
+_print(' */');
+_print();
+_print('//');
+_print('// This file has been generated automatically from Adblock Plus for Firefox');
+_print('// source code. DO NOT MODIFY, change the original source code instead.');
+_print('//');
+_print('// Relevant repositories:');
+_print('// * https://hg.adblockplus.org/adblockplus/');
+_print('// * https://hg.adblockplus.org/jshydra/');
+_print('//');
+_print();
+
+include("astDecompile.js");
+include("../utils/beautify.js");
+
+// See https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API for
+// AST structure.
+
+let options = {
+ filename: null,
+ module: false,
+ varIndex: 0,
+ indent_size: 2,
+ preserve_newlines: false,
+ brace_style: "expand-strict"
};
+let global = this;
-function IdentifierExpression(varname)
+function Literal(value)
{
- Node.call(this, {
- name: varname
- });
+ return {
+ type: "Literal",
+ value: value
+ };
}
-IdentifierExpression.prototype =
-{
- __proto__: Node.prototype,
- type: "IdentifierExpression",
- precedence: 0
-};
-function LiteralExpression(constant)
+function Identifier(varname)
{
- Node.call(this, {
- objtype: typeof constant,
- value: constant
- });
+ return {
+ type: "Identifier",
+ name: varname
+ };
}
-LiteralExpression.prototype =
-{
- __proto__: Node.prototype,
- type: "LiteralExpression",
- precedence: 0
-};
-function MemberExpression(object, member, isConst)
+function Member(object, property, computed)
{
if (typeof object == "string")
- object = new IdentifierExpression(object);
-
- if (isConst)
- {
- Node.call(this, {
- container: object,
- constmember: member
- });
- }
- else
- {
- if (typeof member != "object")
- member = new LiteralExpression(member);
- Node.call(this, {
- container: object,
- member: member
- });
- }
-}
-MemberExpression.prototype =
-{
- __proto__: Node.prototype,
- type: "MemberExpression",
- precedence: 1
-};
-
-function UnaryExpression(operator, operand)
-{
- var operators = {
- __proto__: null,
- "yield": 4,
- "+": 4,
- "-": 4,
- "!": 4,
- "~": 4,
- "typeof": 4,
- "void": 4,
- "delete": 4,
- "++": 3,
- "--": 3,
- "()": 2
+ object = Identifier(object);
+ if (typeof property != "object")
+ property = Identifier(property);
+
+ return {
+ type: "MemberExpression",
+ object: object,
+ property: property,
+ computed: computed
};
-
- if (!(operator in operators))
- throw "Unknown operator";
-
- if (typeof operand != "object")
- operand = new LiteralExpression(operand);
-
- Node.call(this, {
- operator: operator,
- precedence: operators[operator],
- operand: operand
- });
}
-UnaryExpression.prototype =
-{
- __proto__: Node.prototype,
- type: "UnaryExpression"
-};
-function BinaryExpression(operator, lhs, rhs)
+function VariableDeclaration(variable, value)
{
- var operators = {
- __proto__: null,
- ",": 17,
- "||": 14,
- "&&": 13,
- "|": 12,
- "^": 11,
- "&": 10,
- "==": 9,
- "!=": 9,
- "===": 9,
- "!==": 9,
- "<": 8,
- "<=": 8,
- ">": 8,
- ">=": 8,
- "in": 8,
- "instanceof": 8,
- "<<": 7,
- ">>": 7,
- ">>>": 7,
- "+": 6,
- "-": 6,
- "*": 5,
- "/": 5,
- "%": 5
+ if (typeof variable == "string")
+ variable = Identifier(variable);
+ if (typeof value != "object")
+ value = Literal(value);
+
+ return {
+ type: "VariableDeclaration",
+ declarations: [
+ {
+ type: "VariableDeclarator",
+ id: variable,
+ init: value
+ }
+ ],
+ kind: "var"
};
-
- if (!(operator in operators))
- throw "Unknown operator";
-
- if (typeof lhs != "object")
- lhs = new LiteralExpression(lhs);
- if (typeof rhs != "object")
- rhs = new LiteralExpression(rhs);
-
- Node.call(this, {
- operator: operator,
- precedence: operators[operator],
- lhs: lhs,
- rhs: rhs
- });
}
-BinaryExpression.prototype =
-{
- __proto__: Node.prototype,
- type: "BinaryExpression"
-};
-function VarDeclaration(varname, initializer)
+function Assignment(variable, value)
{
- obj = {
- name: varname
- }
- if (typeof initializer != "undefined" && initializer != null)
- {
- if (typeof initializer == "object")
- obj.initializer = initializer;
- else
- obj.initializer = new LiteralExpression(initializer);
- }
- Node.call(this, obj);
+ if (typeof variable == "string")
+ variable = Identifier(variable);
+
+ return {
+ type: "ExpressionStatement",
+ expression: {
+ type: "AssignmentExpression",
+ left: variable,
+ right: value,
+ operator: "="
+ }
+ };
}
-VarDeclaration.prototype =
-{
- __proto__: Node.prototype,
- type: "VarDeclaration"
-};
-function VarStatement(varname, initializer)
+function LogicalExpression(left, operator, right)
{
- Node.call(this, {
- variables: [new VarDeclaration(varname, initializer)]
- });
+ if (typeof left != "object")
+ left = (typeof left == "string" ? Identifier(left) : Literal(left));
+ if (typeof right != "object")
+ right = Literal(right);
+
+ return {
+ type: "LogicalExpression",
+ left: left,
+ right: right,
+ operator: operator
+ };
}
-VarStatement.prototype =
-{
- __proto__: Node.prototype,
- type: "VarStatement",
- vartype: "var"
-};
-function ExpressionStatement(expression)
+function IncExpression(variable)
{
- Node.call(this, {
- expr: expression
- });
+ if (typeof variable != "object")
+ variable = Identifier(variable);
+
+ return {
+ type: "UpdateExpression",
+ argument: variable,
+ operator: "++",
+ prefix: true
+ };
}
-ExpressionStatement.prototype =
-{
- __proto__: Node.prototype,
- type: "ExpressionStatement"
-};
-let modifier =
+function modifyAST(ast)
{
- _filename: null,
- _tempVarCount: 0,
- _exportedSymbols: null,
+ // Do the necessary modifications
+ let func = "modify" + ast.type;
+ if (typeof global[func] == "function")
+ ast = global[func](ast);
- _shouldRemoveStatement: function(stmt)
+ // Recursive calls for any AST in properties of the current one
+ if (ast)
{
- if (stmt.type == "ExpressionStatement" && stmt.expr && stmt.expr.type == "CallExpression" && stmt.expr.func)
+ let props = [];
+ for (let prop in ast)
+ props.push(prop);
+ for (let i = 0; i < props.length; i++)
{
- funcName = decompile(stmt.expr.func);
+ let value = ast[props[i]];
+ if (!value || typeof value != "object")
+ continue;
- // Remove import calls:
- // Cu.import(...);
- if (funcName == "Cu.import" || funcName == "Components.utils.import")
- return true;
-
- // Remove timeline calls:
- // TimeLine.foobar(...);
- if (/^TimeLine\./.test(funcName))
- return true;
- }
-
- if (stmt.type == "VarStatement" && stmt.variables && stmt.variables.length == 1)
- {
- // Remove export declaration:
- // var EXPORTED_SYMBOLS = [];
- if (stmt.variables[0].name == "EXPORTED_SYMBOLS")
+ if ("type" in value)
{
- // Store exported symbols for later
- let array = stmt.variables[0].initializer;
- if (!array || array.type != "ArrayLiteral")
- throw "Unexpected: EXPORTED_SYMBOLS isn't initialized with an array literal";
- for each (let member in array.members)
+ let result = modifyAST(value);
+ if (result)
+ ast[props[i]] = result;
+ else
+ delete ast[props[i]];
+ }
+ else if (value instanceof Array)
+ {
+ for (let j = 0; j < value.length; j++)
{
- if (member.type != "LiteralExpression" || member.objtype != "string")
- throw "Unexpected value in EXPORTED_SYMBOLS array";
- this._exportedSymbols.push(member.value);
+ if (typeof value[j] == "object" && "type" in value[j])
+ {
+ let result = modifyAST(value[j]);
+ if (result)
+ value[j] = result;
+ else
+ value.splice(j--, 1);
+ }
}
- return true;
}
-
- // Remove base URL assignment:
- // var baseURL = ...;
- if (stmt.variables[0].name == "baseURL")
- return true;
-
- // Remove declarations of XPCOM shortcuts:
- // const Cc = Components.classes;
- // const Ci = Components.interfaces;
- // const Cr = Components.results;
- // const Cu = Components.utils;
- if (/^C[ciru]/.test(stmt.variables[0].name))
- return true;
}
+ }
+
+ return ast;
+}
+
+function modifyExpressionStatement(ast)
+{
+ if (ast.expression.type == "CallExpression")
+ {
+ let funcName = decompileAST(ast.expression.callee);
+
+ // Remove import calls:
+ // Cu.import(...);
+ if (funcName == "Cu.import")
+ return null;
- return false;
- },
+ // Remove timeline calls:
+ // TimeLine.foobar(...);
+ if (/^TimeLine\./.test(funcName))
+ return null;
+ }
- _shouldReplaceStatement: function(stmt)
+ if (ast.expression.type == "AssignmentExpression" && ast.expression.operator == "=" && ast.expression.left.type == "ArrayPattern")
{
- if (stmt.type == "ExpressionStatement" && stmt.expr && stmt.expr.type == "AssignmentExpression" && stmt.expr.lhs && stmt.expr.lhs.type == "ArrayLiteral")
+ // Convert destructuring assignment:
+ // [foo, bar] = [1, 2];
+ //
+ // Change into:
+ // var _tempVar44 = [1, 2];
+ // foo = _tempVar44[0];
+ // bar = _tempVar44[1];
+ let vars = ast.expression.left.elements;
+ let block = {type: "Program", body: []};
+
+ let tempVar = Identifier("_tempVar" + options.varIndex++);
+ block.body.push(VariableDeclaration(tempVar, ast.expression.right));
+
+ for (let i = 0; i < vars.length; i++)
+ if (vars[i])
+ block.body.push(Assignment(vars[i], Member(tempVar, i, true)));
+ return block;
+ }
+ return ast;
+}
+
+function modifyVariableDeclaration(ast)
+{
+ // Convert let variables:
+ // let foo = bar;
+ //
+ // Change into:
+ // var foo = bar;
+ if (ast.kind == "let")
+ ast.kind = "var";
+
+ if (ast.declarations.length == 1 && ast.declarations[0].type == "VariableDeclarator")
+ {
+ let declarator = ast.declarations[0];
+
+ // Remove timeline requires:
+ // let {Timeline} = require("timeline");
+ if (declarator.init && decompileAST(declarator.init) == 'require("timeline")')
+ return null;
+
+ // Remove declarations of XPCOM shortcuts:
+ // const Cc = Components.classes;
+ // const Ci = Components.interfaces;
+ // const Cr = Components.results;
+ // const Cu = Components.utils;
+ if (/^C[ciru]$/.test(decompileAST(declarator.id)))
+ return null;
+
+ if (declarator.id.type == "ArrayPattern")
{
// Convert destructuring assignment:
- // [foo, bar] = [1, 2];
+ // var [foo, bar] = [1, 2];
//
// Change into:
// var _tempVar44 = [1, 2];
- // foo = _tempVar44[0];
- // bar = _tempVar44[1];
- let tempVar = "_tempVar" + this._tempVarCount++;
- let result = [new VarStatement(tempVar, stmt.expr.rhs)];
- for (let i = 0; i < stmt.expr.lhs.members.length; i++)
- {
- result.push(new ExpressionStatement(new Node({
- type: "AssignmentExpression",
- precedence: 16,
- operator: "",
- lhs: stmt.expr.lhs.members[i],
- rhs: new MemberExpression(tempVar, i)
- })));
- }
- return result;
+ // var foo = _tempVar44[0];
+ // var bar = _tempVar44[1];
+ let vars = declarator.id.elements;
+ let block = {type: "Program", body: []};
+
+ let tempVar = Identifier("_tempVar" + options.varIndex++);
+ block.body.push(VariableDeclaration(tempVar, declarator.init));
+
+ for (let i = 0; i < vars.length; i++)
+ if (vars[i])
+ block.body.push(VariableDeclaration(vars[i], Member(tempVar, i, true)));
+ return block;
}
- if (stmt.type == "ForInStatement" && stmt.itertype == "for each")
+ if (declarator.id.type == "ObjectPattern")
{
- // Convert "for each" loops:
- // for each (var foo in fooList)
- // {
- // ...
- // }
- // for each (var [foo, bar] in fooList)
- // {
- // ...
- // }
+ // Convert destructuring assignment:
+ // var {foo: bar, foo2: bar2} = {foo: 1, foo2: 2};
//
// Change into:
- // for (var _loopIndex44 = 0; _loopIndex44 < fooList.length; _loopIndex44++)
- // {
- // var foo = fooList[_loopIndex44];
- // ...
- // }
- // for (var _loopIndex55 = 0; _loopIndex55 < fooList.length; _loopIndex44++)
- // {
- // var foo = fooList[_loopIndex55][0];
- // var bar = fooList[_loopIndex55][1];
- // ...
- // }
- if (!stmt.itervar || stmt.itervar.type != "VarStatement" || !stmt.itervar.variables ||
- stmt.itervar.variables.length != 1)
- {
- throw "Loop variable isn't a variable statement?";
- }
- let loopVar = stmt.itervar.variables[0];
- let loopIndex = "_loopIndex" + this._tempVarCount++;
-
- if (stmt.body.type != "BlockStatement")
- {
- let oldBody = stmt.body;
- stmt.body = new Node({
- type: "BlockStatement",
- statements: []
- });
- if (oldBody)
- stmt.body.statements.push(oldBody);
- }
-
- if (loopVar.type == "VarDeclaration" && loopVar.name)
- {
- stmt.body.statements.unshift(new VarStatement(loopVar.name, new MemberExpression(stmt.iterrange, new IdentifierExpression(loopIndex))));
- }
- else if (loopVar.type == "ArrayLiteral")
- {
- for (let i = 0; i < loopVar.members.length; i++)
- {
- if (loopVar.members[i].type != "IdentifierExpression")
- throw "Expected member of destructuring assignment in loop variable";
- stmt.body.statements.splice(i, 0, new VarStatement(loopVar.members[i].name, new MemberExpression(new MemberExpression(stmt.iterrange, new IdentifierExpression(loopIndex)), i)));
- }
- }
- else
- throw "Unexpected loop variable in for each statement";
-
- return [new Node({
- type: "ForStatement",
- init: new VarStatement(loopIndex, 0),
- cond: new BinaryExpression("<", new IdentifierExpression(loopIndex), new MemberExpression(stmt.iterrange, "length", true)),
- inc: new UnaryExpression("++", new IdentifierExpression(loopIndex)),
- body: stmt.body
- })];
- }
-
- return null;
- },
-
- _checkStatements: function(statements)
- {
- for (let i = 0; i < statements.length; i++)
- {
- if (this._shouldRemoveStatement(statements[i]))
- {
- statements.splice(i--, 1);
- }
+ // var _tempVar44 = {foo: 1, foo2: 2};
+ // var bar = _tempVar44.foo;
+ // var bar2 = _tempVar44.foo2;
+ //
+ // Simplified form;
+ // var {foo: bar} = {foo: 1};
+ //
+ // Change into:
+ // var bar = {foo: 1}.foo;
+ let vars = declarator.id.properties;
+ if (vars.length == 1)
+ return VariableDeclaration(vars[0].value, Member(declarator.init, vars[0].key, false));
else
{
- replacement = this._shouldReplaceStatement(statements[i]);
- if (replacement)
- {
- replacement.unshift(i, 1);
- statements.splice.apply(statements, replacement);
- i += replacement.length - 3;
- }
- }
- }
- },
+ let block = {type: "Program", body: []};
- visitBlockStatement: function(stmt)
- {
- this._checkStatements(stmt.statements);
- },
-
- visitProgram: function(stmt)
- {
- this._exportedSymbols = [];
- this._checkStatements(stmt.sourceElements);
- },
+ let tempVar = Identifier("_tempVar" + options.varIndex++);
+ block.body.push(VariableDeclaration(tempVar, declarator.init));
- postvisitProgram: function(stmt)
- {
- if (typeof isModule == "boolean" && isModule)
- {
- // Add patch function call at the end of the module:
- // if (typeof _patchFunc44 != "undefined")
- // (eval("(" + _patchFunc44.toString()) + ")()");
- let patchFuncName = "_patchFunc" + this._tempVarCount++;
- stmt.sourceElements.push(new Node({
- type: "IfStatement",
- cond: new BinaryExpression("!=", new UnaryExpression("typeof", new IdentifierExpression(patchFuncName)), "undefined"),
- body: new ExpressionStatement(new Node({
- type: "CallExpression",
- precedence: 2,
- func: new IdentifierExpression("eval"),
- arguments: [new BinaryExpression("+", new BinaryExpression("+", "(", new Node({
- type: "CallExpression",
- precedence: 2,
- arguments: [],
- func: new MemberExpression(patchFuncName, "toString", true),
- })), ")()")],
- }))
- }));
-
- // Add exported symbols at the end of the module:
- // window.exportedSymbol1 = exportedSymbol1;
- // window.exportedSymbol2 = exportedSymbol2;
- // window.exportedSymbol3 = exportedSymbol3;
- if (this._exportedSymbols.length > 0)
- {
- for each (let symbol in this._exportedSymbols)
- {
- stmt.sourceElements.push(new ExpressionStatement(new Node({
- type: "AssignmentExpression",
- precedence: 16,
- operator: "",
- lhs: new MemberExpression("window", symbol, true),
- rhs: new IdentifierExpression(symbol),
- })));
- }
+ for (let i = 0; i < vars.length; i++)
+ block.body.push(VariableDeclaration(vars[i].value, Member(tempVar, vars[i].key, false)));
+ return block;
}
-
- // Wrap the entire module into a function to give it an independent scope:
- // (function(_patchFunc44) {
- // ...
- // })(window.ModuleNamePatch);
- stmt.sourceElements = [new ExpressionStatement(new Node({
- type: "CallExpression",
- precedence: 2,
- arguments: [new MemberExpression("window", this._filename + "Patch", true)],
- func: new Node({
- type: "FunctionDeclaration",
- precedence: Infinity,
- name: "",
- arguments: [new IdentifierExpression(patchFuncName)],
- body: new Node({
- type: "BlockStatement",
- statements: stmt.sourceElements
- })
- })
- }))];
}
- },
-
- visitVarStatement: function(stmt)
- {
- // Change let variables into "regular" variables
- if (stmt.vartype == "let")
- stmt.vartype = "var";
}
-};
-let origOutput = output;
-let origFlush = flush;
-let origIndent = indent;
-let decompileBuffer;
-function fakeOutput(str)
-{
- decompileBuffer += str;
- return global;
-}
-function fakeFlush()
-{
- return global;
-}
-function fakeIndent()
-{
- return global;
+ return ast;
}
-function decompile(node)
+
+function modifyForInStatement(ast)
{
- decompileBuffer = "";
- [output, flush, indent] = [fakeOutput, fakeFlush, fakeIndent];
- node.visit(visitor);
- [output, flush, indent] = [origOutput, origFlush, origIndent];
- return decompileBuffer;
+ if (ast.each)
+ {
+ // Convert "for each" loops:
+ // for each (var foo in fooList)
+ // {
+ // ...
+ // }
+ //
+ // Change into:
+ // for (var _loopIndex44 = 0; _loopIndex44 < fooList.length; ++_loopIndex44)
+ // {
+ // var foo = fooList[_loopIndex44];
+ // ...
+ // }
+ let loopIndex = Identifier("_loopIndex" + options.varIndex++);
+
+ let block = ast.body;
+ if (block.type != "BlockStatement")
+ block = {type: "BlockStatement", body: (block.type == "EmptyStatement" ? [] : [block])};
+ if (ast.left.type == "VariableDeclaration")
+ block.body.unshift(VariableDeclaration(ast.left.declarations[0].id, Member(ast.right, loopIndex, true)));
+ else
+ block.body.unshift(Assignment(ast.left, Member(ast.right, loopIndex, true)));
+
+ return {
+ type: "ForStatement",
+ init: VariableDeclaration(loopIndex, 0),
+ test: LogicalExpression(loopIndex, "<", Member(ast.right, "length", false)),
+ update: IncExpression(loopIndex),
+ body: block
+ };
+ }
}
-process_js = function(ast, filename)
+process_js = function(ast, filename, args)
{
+ for each (let arg in args.split(/\s+/))
+ {
+ let match = /^(\w+)\s*=\s*(.*)/.exec(arg);
+ if (match && typeof options[match[1]] == "boolean")
+ options[match[1]] = (match[2] == "true");
+ }
+
+ options.filename = filename.replace(/.*[\\\/]/, "").replace(/\.jsm?$/, "");
+
+ // Modify AST
+ if (ast)
+ ast = modifyAST(ast);
if (!ast)
return;
- filename = filename.replace(/.*[\\\/]/, "");
- filename = filename.replace(/\.jsm?$/, "");
- modifier._filename = filename;
-
- // Output license header
- _print('/*');
- _print(' * This Source Code is subject to the terms of the Mozilla Public License');
- _print(' * version 2.0 (the "License"). You can obtain a copy of the License at');
- _print(' * http://mozilla.org/MPL/2.0/.');
- _print(' */');
- _print();
- _print('//');
- _print('// This file has been generated automatically from Adblock Plus source code');
- _print('//');
- _print();
-
- ast = makeAST(ast);
- walkAST(ast, modifier);
- walkAST(ast, visitor);
+ if (options.module)
+ {
+ // Wrap the entire module into a function to give it an independent scope.
+ // Return exported symbols:
+ //
+ // require.scopes["foobar"] = (function() {
+ // var exports = {};
+ // ...
+ // return exports;
+ // })();
+ let code = 'require.scopes["' + options.filename + '"] = (function() {\n' +
+ 'var exports = {};\n' +
+ decompileAST(ast) +
+ '})();';
+ _print(js_beautify(code, options));
+ }
+ else
+ _print(js_beautify(decompileAST(ast), options));
}
diff --git a/utils/beautify.js b/utils/beautify.js
new file mode 100644
index 0000000..dbb2f49
--- /dev/null
+++ b/utils/beautify.js
@@ -0,0 +1,1322 @@
+/*jslint onevar: false, plusplus: false */
+/*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */
+/*
+
+ JS Beautifier
+---------------
+
+
+ Written by Einar Lielmanis, <einar at jsbeautifier.org>
+ http://jsbeautifier.org/
+
+ Originally converted to javascript by Vital, <vital76 at gmail.com>
+ "End braces on own line" added by Chris J. Shull, <chrisjshull at gmail.com>
+
+ You are free to use this in any way you want, in case you find this useful or working for you.
+
+ Usage:
+ js_beautify(js_source_text);
+ js_beautify(js_source_text, options);
+
+ The options are:
+ indent_size (default 4) - indentation size,
+ indent_char (default space) - character to indent with,
+ preserve_newlines (default true) - whether existing line breaks should be preserved,
+ preserve_max_newlines (default unlimited) - maximum number of line breaks to be preserved in one chunk,
+
+ jslint_happy (default false) - if true, then jslint-stricter mode is enforced.
+
+ jslint_happy !jslint_happy
+ ---------------------------------
+ function () function()
+
+ brace_style (default "collapse") - "collapse" | "expand" | "end-expand" | "expand-strict"
+ put braces on the same line as control statements (default), or put braces on own line (Allman / ANSI style), or just put end braces on own line.
+
+ expand-strict: put brace on own line even in such cases:
+
+ var a =
+ {
+ a: 5,
+ b: 6
+ }
+ This mode may break your scripts - e.g "return { a: 1 }" will be broken into two lines, so beware.
+
+ space_before_conditional (default true) - should the space before conditional statement be added, "if(true)" vs "if (true)",
+
+ unescape_strings (default false) - should printable characters in strings encoded in \xNN notation be unescaped, "example" vs "\x65\x78\x61\x6d\x70\x6c\x65"
+
+ e.g
+
+ js_beautify(js_source_text, {
+ 'indent_size': 1,
+ 'indent_char': '\t'
+ });
+
+
+*/
+
+
+
+function js_beautify(js_source_text, options) {
+
+ var input, output, token_text, last_type, last_text, last_last_text, last_word, flags, flag_store, indent_string;
+ var whitespace, wordchar, punct, parser_pos, line_starters, digits;
+ var prefix, token_type, do_block_just_closed;
+ var wanted_newline, just_added_newline, n_newlines;
+ var preindent_string = '';
+
+
+ // Some interpreters have unexpected results with foo = baz || bar;
+ options = options ? options : {};
+
+ var opt_brace_style;
+
+ // compatibility
+ if (options.space_after_anon_function !== undefined && options.jslint_happy === undefined) {
+ options.jslint_happy = options.space_after_anon_function;
+ }
+ if (options.braces_on_own_line !== undefined) { //graceful handling of deprecated option
+ opt_brace_style = options.braces_on_own_line ? "expand" : "collapse";
+ }
+ opt_brace_style = options.brace_style ? options.brace_style : (opt_brace_style ? opt_brace_style : "collapse");
+
+
+ var opt_indent_size = options.indent_size ? options.indent_size : 4;
+ var opt_indent_char = options.indent_char ? options.indent_char : ' ';
+ var opt_preserve_newlines = typeof options.preserve_newlines === 'undefined' ? true : options.preserve_newlines;
+ var opt_max_preserve_newlines = typeof options.max_preserve_newlines === 'undefined' ? false : options.max_preserve_newlines;
+ var opt_jslint_happy = options.jslint_happy === 'undefined' ? false : options.jslint_happy;
+ var opt_keep_array_indentation = typeof options.keep_array_indentation === 'undefined' ? false : options.keep_array_indentation;
+ var opt_space_before_conditional = typeof options.space_before_conditional === 'undefined' ? true : options.space_before_conditional;
+ var opt_indent_case = typeof options.indent_case === 'undefined' ? false : options.indent_case;
+ var opt_unescape_strings = typeof options.unescape_strings === 'undefined' ? false : options.unescape_strings;
+
+ just_added_newline = false;
+
+ // cache the source's length.
+ var input_length = js_source_text.length;
+
+ function trim_output(eat_newlines) {
+ eat_newlines = typeof eat_newlines === 'undefined' ? false : eat_newlines;
+ while (output.length && (output[output.length - 1] === ' '
+ || output[output.length - 1] === indent_string
+ || output[output.length - 1] === preindent_string
+ || (eat_newlines && (output[output.length - 1] === '\n' || output[output.length - 1] === '\r')))) {
+ output.pop();
+ }
+ }
+
+ function trim(s) {
+ return s.replace(/^\s\s*|\s\s*$/, '');
+ }
+
+ // we could use just string.split, but
+ // IE doesn't like returning empty strings
+ function split_newlines(s) {
+ //return s.split(/\x0d\x0a|\x0a/);
+
+ s = s.replace(/\x0d/g, '');
+ var out = [],
+ idx = s.indexOf("\n");
+ while (idx !== -1) {
+ out.push(s.substring(0, idx));
+ s = s.substring(idx + 1);
+ idx = s.indexOf("\n");
+ }
+ if (s.length) {
+ out.push(s);
+ }
+ return out;
+ }
+
+ function force_newline() {
+ var old_keep_array_indentation = opt_keep_array_indentation;
+ opt_keep_array_indentation = false;
+ print_newline();
+ opt_keep_array_indentation = old_keep_array_indentation;
+ }
+
+ function print_newline(ignore_repeated) {
+
+ flags.eat_next_space = false;
+ if (opt_keep_array_indentation && is_array(flags.mode)) {
+ return;
+ }
+
+ ignore_repeated = typeof ignore_repeated === 'undefined' ? true : ignore_repeated;
+
+ flags.if_line = false;
+ trim_output();
+
+ if (!output.length) {
+ return; // no newline on start of file
+ }
+
+ if (output[output.length - 1] !== "\n" || !ignore_repeated) {
+ just_added_newline = true;
+ output.push("\n");
+ }
+ if (preindent_string) {
+ output.push(preindent_string);
+ }
+ for (var i = 0; i < flags.indentation_level; i += 1) {
+ output.push(indent_string);
+ }
+ if (flags.var_line && flags.var_line_reindented) {
+ output.push(indent_string); // skip space-stuffing, if indenting with a tab
+ }
+ if (flags.case_body) {
+ output.push(indent_string);
+ }
+ }
+
+
+
+ function print_single_space() {
+
+ if (last_type === 'TK_COMMENT') {
+ return print_newline();
+ }
+ if (flags.eat_next_space) {
+ flags.eat_next_space = false;
+ return;
+ }
+ var last_output = ' ';
+ if (output.length) {
+ last_output = output[output.length - 1];
+ }
+ if (last_output !== ' ' && last_output !== '\n' && last_output !== indent_string) { // prevent occassional duplicate space
+ output.push(' ');
+ }
+ }
+
+
+ function print_token() {
+ just_added_newline = false;
+ flags.eat_next_space = false;
+ output.push(token_text);
+ }
+
+ function indent() {
+ flags.indentation_level += 1;
+ }
+
+
+ function remove_indent() {
+ if (output.length && output[output.length - 1] === indent_string) {
+ output.pop();
+ }
+ }
+
+ function set_mode(mode) {
+ if (flags) {
+ flag_store.push(flags);
+ }
+ flags = {
+ previous_mode: flags ? flags.mode : 'BLOCK',
+ mode: mode,
+ var_line: false,
+ var_line_tainted: false,
+ var_line_reindented: false,
+ in_html_comment: false,
+ if_line: false,
+ in_case_statement: false, // switch(..){ INSIDE HERE }
+ in_case: false, // we're on the exact line with "case 0:"
+ case_body: false, // the indented case-action block
+ eat_next_space: false,
+ indentation_baseline: -1,
+ indentation_level: (flags ? flags.indentation_level + (flags.case_body ? 1 : 0) + ((flags.var_line && flags.var_line_reindented) ? 1 : 0) : 0),
+ ternary_depth: 0
+ };
+ }
+
+ function is_array(mode) {
+ return mode === '[EXPRESSION]' || mode === '[INDENTED-EXPRESSION]';
+ }
+
+ function is_expression(mode) {
+ return in_array(mode, ['[EXPRESSION]', '(EXPRESSION)', '(FOR-EXPRESSION)', '(COND-EXPRESSION)']);
+ }
+
+ function restore_mode() {
+ do_block_just_closed = flags.mode === 'DO_BLOCK';
+ if (flag_store.length > 0) {
+ var mode = flags.mode;
+ flags = flag_store.pop();
+ flags.previous_mode = mode;
+ }
+ }
+
+ function all_lines_start_with(lines, c) {
+ for (var i = 0; i < lines.length; i++) {
+ var line = trim(lines[i]);
+ if (line.charAt(0) !== c) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ function is_special_word(word) {
+ return in_array(word, ['case', 'return', 'do', 'if', 'throw', 'else']);
+ }
+
+ function in_array(what, arr) {
+ for (var i = 0; i < arr.length; i += 1) {
+ if (arr[i] === what) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ function look_up(exclude) {
+ var local_pos = parser_pos;
+ var c = input.charAt(local_pos);
+ while (in_array(c, whitespace) && c !== exclude) {
+ local_pos++;
+ if (local_pos >= input_length) {
+ return 0;
+ }
+ c = input.charAt(local_pos);
+ }
+ return c;
+ }
+
+ function get_next_token() {
+ var i;
+ var resulting_string;
+
+ n_newlines = 0;
+
+ if (parser_pos >= input_length) {
+ return ['', 'TK_EOF'];
+ }
+
+ wanted_newline = false;
+
+ var c = input.charAt(parser_pos);
+ parser_pos += 1;
+
+
+ var keep_whitespace = opt_keep_array_indentation && is_array(flags.mode);
+
+ if (keep_whitespace) {
+
+ //
+ // slight mess to allow nice preservation of array indentation and reindent that correctly
+ // first time when we get to the arrays:
+ // var a = [
+ // ....'something'
+ // we make note of whitespace_count = 4 into flags.indentation_baseline
+ // so we know that 4 whitespaces in original source match indent_level of reindented source
+ //
+ // and afterwards, when we get to
+ // 'something,
+ // .......'something else'
+ // we know that this should be indented to indent_level + (7 - indentation_baseline) spaces
+ //
+ var whitespace_count = 0;
+
+ while (in_array(c, whitespace)) {
+
+ if (c === "\n") {
+ trim_output();
+ output.push("\n");
+ just_added_newline = true;
+ whitespace_count = 0;
+ } else {
+ if (c === '\t') {
+ whitespace_count += 4;
+ } else if (c === '\r') {
+ // nothing
+ } else {
+ whitespace_count += 1;
+ }
+ }
+
+ if (parser_pos >= input_length) {
+ return ['', 'TK_EOF'];
+ }
+
+ c = input.charAt(parser_pos);
+ parser_pos += 1;
+
+ }
+ if (flags.indentation_baseline === -1) {
+ flags.indentation_baseline = whitespace_count;
+ }
+
+ if (just_added_newline) {
+ for (i = 0; i < flags.indentation_level + 1; i += 1) {
+ output.push(indent_string);
+ }
+ if (flags.indentation_baseline !== -1) {
+ for (i = 0; i < whitespace_count - flags.indentation_baseline; i++) {
+ output.push(' ');
+ }
+ }
+ }
+
+ } else {
+ while (in_array(c, whitespace)) {
+
+ if (c === "\n") {
+ n_newlines += ((opt_max_preserve_newlines) ? (n_newlines <= opt_max_preserve_newlines) ? 1 : 0 : 1);
+ }
+
+
+ if (parser_pos >= input_length) {
+ return ['', 'TK_EOF'];
+ }
+
+ c = input.charAt(parser_pos);
+ parser_pos += 1;
+
+ }
+
+ if (opt_preserve_newlines) {
+ if (n_newlines > 1) {
+ for (i = 0; i < n_newlines; i += 1) {
+ print_newline(i === 0);
+ just_added_newline = true;
+ }
+ }
+ }
+ wanted_newline = n_newlines > 0;
+ }
+
+
+ if (in_array(c, wordchar)) {
+ if (parser_pos < input_length) {
+ while (in_array(input.charAt(parser_pos), wordchar)) {
+ c += input.charAt(parser_pos);
+ parser_pos += 1;
+ if (parser_pos === input_length) {
+ break;
+ }
+ }
+ }
+
+ // small and surprisingly unugly hack for 1E-10 representation
+ if (parser_pos !== input_length && c.match(/^[0-9]+[Ee]$/) && (input.charAt(parser_pos) === '-' || input.charAt(parser_pos) === '+')) {
+
+ var sign = input.charAt(parser_pos);
+ parser_pos += 1;
+
+ var t = get_next_token();
+ c += sign + t[0];
+ return [c, 'TK_WORD'];
+ }
+
+ if (c === 'in') { // hack for 'in' operator
+ return [c, 'TK_OPERATOR'];
+ }
+ if (wanted_newline && last_type !== 'TK_OPERATOR'
+ && last_type !== 'TK_EQUALS'
+ && !flags.if_line && (opt_preserve_newlines || last_text !== 'var')) {
+ print_newline();
+ }
+ return [c, 'TK_WORD'];
+ }
+
+ if (c === '(' || c === '[') {
+ return [c, 'TK_START_EXPR'];
+ }
+
+ if (c === ')' || c === ']') {
+ return [c, 'TK_END_EXPR'];
+ }
+
+ if (c === '{') {
+ return [c, 'TK_START_BLOCK'];
+ }
+
+ if (c === '}') {
+ return [c, 'TK_END_BLOCK'];
+ }
+
+ if (c === ';') {
+ return [c, 'TK_SEMICOLON'];
+ }
+
+ if (c === '/') {
+ var comment = '';
+ // peek for comment /* ... */
+ var inline_comment = true;
+ if (input.charAt(parser_pos) === '*') {
+ parser_pos += 1;
+ if (parser_pos < input_length) {
+ while (parser_pos < input_length &&
+ ! (input.charAt(parser_pos) === '*' && input.charAt(parser_pos + 1) && input.charAt(parser_pos + 1) === '/')) {
+ c = input.charAt(parser_pos);
+ comment += c;
+ if (c === "\n" || c === "\r") {
+ inline_comment = false;
+ }
+ parser_pos += 1;
+ if (parser_pos >= input_length) {
+ break;
+ }
+ }
+ }
+ parser_pos += 2;
+ if (inline_comment && n_newlines === 0) {
+ return ['/*' + comment + '*/', 'TK_INLINE_COMMENT'];
+ } else {
+ return ['/*' + comment + '*/', 'TK_BLOCK_COMMENT'];
+ }
+ }
+ // peek for comment // ...
+ if (input.charAt(parser_pos) === '/') {
+ comment = c;
+ while (input.charAt(parser_pos) !== '\r' && input.charAt(parser_pos) !== '\n') {
+ comment += input.charAt(parser_pos);
+ parser_pos += 1;
+ if (parser_pos >= input_length) {
+ break;
+ }
+ }
+ if (wanted_newline) {
+ print_newline();
+ }
+ return [comment, 'TK_COMMENT'];
+ }
+
+ }
+
+ if (c === "'" || // string
+ c === '"' || // string
+ (c === '/' &&
+ ((last_type === 'TK_WORD' && is_special_word(last_text)) ||
+ (last_text === ')' && in_array(flags.previous_mode, ['(COND-EXPRESSION)', '(FOR-EXPRESSION)'])) ||
+ (last_type === 'TK_COMMA' || last_type === 'TK_COMMENT' || last_type === 'TK_START_EXPR' || last_type === 'TK_START_BLOCK' || last_type === 'TK_END_BLOCK' || last_type === 'TK_OPERATOR' || last_type === 'TK_EQUALS' || last_type === 'TK_EOF' || last_type === 'TK_SEMICOLON')))) { // regexp
+ var sep = c;
+ var esc = false;
+ var esc1 = 0;
+ var esc2 = 0;
+ resulting_string = c;
+
+ if (parser_pos < input_length) {
+ if (sep === '/') {
+ //
+ // handle regexp separately...
+ //
+ var in_char_class = false;
+ while (esc || in_char_class || input.charAt(parser_pos) !== sep) {
+ resulting_string += input.charAt(parser_pos);
+ if (!esc) {
+ esc = input.charAt(parser_pos) === '\\';
+ if (input.charAt(parser_pos) === '[') {
+ in_char_class = true;
+ } else if (input.charAt(parser_pos) === ']') {
+ in_char_class = false;
+ }
+ } else {
+ esc = false;
+ }
+ parser_pos += 1;
+ if (parser_pos >= input_length) {
+ // incomplete string/rexp when end-of-file reached.
+ // bail out with what had been received so far.
+ return [resulting_string, 'TK_STRING'];
+ }
+ }
+
+ } else {
+ //
+ // and handle string also separately
+ //
+ while (esc || input.charAt(parser_pos) !== sep) {
+ resulting_string += input.charAt(parser_pos);
+ if (esc1 && esc1 >= esc2) {
+ esc1 = parseInt(resulting_string.substr(-esc2), 16);
+ if (esc1 && esc1 >= 0x20 && esc1 <= 0x7e) {
+ esc1 = String.fromCharCode(esc1);
+ resulting_string = resulting_string.substr(0, resulting_string.length - esc2 - 2) + (((esc1 === sep) || (esc1 === '\\')) ? '\\' : '') + esc1;
+ }
+ esc1 = 0;
+ }
+ if (esc1) {
+ esc1++;
+ } else if (!esc) {
+ esc = input.charAt(parser_pos) === '\\';
+ } else {
+ esc = false;
+ if (opt_unescape_strings) {
+ if (input.charAt(parser_pos) === 'x') {
+ esc1++;
+ esc2 = 2;
+ } else if (input.charAt(parser_pos) === 'u') {
+ esc1++;
+ esc2 = 4;
+ }
+ }
+ }
+ parser_pos += 1;
+ if (parser_pos >= input_length) {
+ // incomplete string/rexp when end-of-file reached.
+ // bail out with what had been received so far.
+ return [resulting_string, 'TK_STRING'];
+ }
+ }
+ }
+
+
+
+ }
+
+ parser_pos += 1;
+
+ resulting_string += sep;
+
+ if (sep === '/') {
+ // regexps may have modifiers /regexp/MOD , so fetch those, too
+ while (parser_pos < input_length && in_array(input.charAt(parser_pos), wordchar)) {
+ resulting_string += input.charAt(parser_pos);
+ parser_pos += 1;
+ }
+ }
+ return [resulting_string, 'TK_STRING'];
+ }
+
+ if (c === '#') {
+
+
+ if (output.length === 0 && input.charAt(parser_pos) === '!') {
+ // shebang
+ resulting_string = c;
+ while (parser_pos < input_length && c !== '\n') {
+ c = input.charAt(parser_pos);
+ resulting_string += c;
+ parser_pos += 1;
+ }
+ output.push(trim(resulting_string) + '\n');
+ print_newline();
+ return get_next_token();
+ }
+
+
+
+ // Spidermonkey-specific sharp variables for circular references
+ // https://developer.mozilla.org/En/Sharp_variables_in_JavaScript
+ // http://mxr.mozilla.org/mozilla-central/source/js/src/jsscan.cpp around line 1935
+ var sharp = '#';
+ if (parser_pos < input_length && in_array(input.charAt(parser_pos), digits)) {
+ do {
+ c = input.charAt(parser_pos);
+ sharp += c;
+ parser_pos += 1;
+ } while (parser_pos < input_length && c !== '#' && c !== '=');
+ if (c === '#') {
+ //
+ } else if (input.charAt(parser_pos) === '[' && input.charAt(parser_pos + 1) === ']') {
+ sharp += '[]';
+ parser_pos += 2;
+ } else if (input.charAt(parser_pos) === '{' && input.charAt(parser_pos + 1) === '}') {
+ sharp += '{}';
+ parser_pos += 2;
+ }
+ return [sharp, 'TK_WORD'];
+ }
+ }
+
+ if (c === '<' && input.substring(parser_pos - 1, parser_pos + 3) === '<!--') {
+ parser_pos += 3;
+ c = '<!--';
+ while (input.charAt(parser_pos) !== '\n' && parser_pos < input_length) {
+ c += input.charAt(parser_pos);
+ parser_pos++;
+ }
+ flags.in_html_comment = true;
+ return [c, 'TK_COMMENT'];
+ }
+
+ if (c === '-' && flags.in_html_comment && input.substring(parser_pos - 1, parser_pos + 2) === '-->') {
+ flags.in_html_comment = false;
+ parser_pos += 2;
+ if (wanted_newline) {
+ print_newline();
+ }
+ return ['-->', 'TK_COMMENT'];
+ }
+
+ if (in_array(c, punct)) {
+ while (parser_pos < input_length && in_array(c + input.charAt(parser_pos), punct)) {
+ c += input.charAt(parser_pos);
+ parser_pos += 1;
+ if (parser_pos >= input_length) {
+ break;
+ }
+ }
+
+ if (c === ',') {
+ return [c, 'TK_COMMA'];
+ } else if (c === '=') {
+ return [c, 'TK_EQUALS'];
+ } else {
+ return [c, 'TK_OPERATOR'];
+ }
+ }
+
+ return [c, 'TK_UNKNOWN'];
+ }
+
+ //----------------------------------
+ indent_string = '';
+ while (opt_indent_size > 0) {
+ indent_string += opt_indent_char;
+ opt_indent_size -= 1;
+ }
+
+ while (js_source_text && (js_source_text.charAt(0) === ' ' || js_source_text.charAt(0) === '\t')) {
+ preindent_string += js_source_text.charAt(0);
+ js_source_text = js_source_text.substring(1);
+ }
+ input = js_source_text;
+
+ last_word = ''; // last 'TK_WORD' passed
+ last_type = 'TK_START_EXPR'; // last token type
+ last_text = ''; // last token text
+ last_last_text = ''; // pre-last token text
+ output = [];
+
+ do_block_just_closed = false;
+
+ whitespace = "\n\r\t ".split('');
+ wordchar = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$'.split('');
+ digits = '0123456789'.split('');
+
+ punct = '+ - * / % & ++ -- = += -= *= /= %= == === != !== > < >= <= >> << >>> >>>= >>= <<= && &= | || ! !! , : ? ^ ^= |= ::';
+ punct += ' <%= <% %> <?= <? ?>'; // try to be a good boy and try not to break the markup language identifiers
+ punct = punct.split(' ');
+
+ // words which should always start on new line.
+ line_starters = 'continue,try,throw,return,var,if,switch,case,default,for,while,break,function'.split(',');
+
+ // states showing if we are currently in expression (i.e. "if" case) - 'EXPRESSION', or in usual block (like, procedure), 'BLOCK'.
+ // some formatting depends on that.
+ flag_store = [];
+ set_mode('BLOCK');
+
+ parser_pos = 0;
+ while (true) {
+ var t = get_next_token();
+ token_text = t[0];
+ token_type = t[1];
+ if (token_type === 'TK_EOF') {
+ break;
+ }
+
+ switch (token_type) {
+
+ case 'TK_START_EXPR':
+
+ if (token_text === '[') {
+
+ if (last_type === 'TK_WORD' || last_text === ')') {
+ // this is array index specifier, break immediately
+ // a[x], fn()[x]
+ if (in_array(last_text, line_starters)) {
+ print_single_space();
+ }
+ set_mode('(EXPRESSION)');
+ print_token();
+ break;
+ }
+
+ if (flags.mode === '[EXPRESSION]' || flags.mode === '[INDENTED-EXPRESSION]') {
+ if (last_last_text === ']' && last_text === ',') {
+ // ], [ goes to new line
+ if (flags.mode === '[EXPRESSION]') {
+ flags.mode = '[INDENTED-EXPRESSION]';
+ if (!opt_keep_array_indentation) {
+ indent();
+ }
+ }
+ set_mode('[EXPRESSION]');
+ if (!opt_keep_array_indentation) {
+ print_newline();
+ }
+ } else if (last_text === '[') {
+ if (flags.mode === '[EXPRESSION]') {
+ flags.mode = '[INDENTED-EXPRESSION]';
+ if (!opt_keep_array_indentation) {
+ indent();
+ }
+ }
+ set_mode('[EXPRESSION]');
+
+ if (!opt_keep_array_indentation) {
+ print_newline();
+ }
+ } else {
+ set_mode('[EXPRESSION]');
+ }
+ } else {
+ set_mode('[EXPRESSION]');
+ }
+
+
+
+ } else {
+ if (last_word === 'for') {
+ set_mode('(FOR-EXPRESSION)');
+ } else if (in_array(last_word, ['if', 'while'])) {
+ set_mode('(COND-EXPRESSION)');
+ } else {
+ set_mode('(EXPRESSION)');
+ }
+ }
+
+ if (last_text === ';' || last_type === 'TK_START_BLOCK') {
+ print_newline();
+ } else if (last_type === 'TK_END_EXPR' || last_type === 'TK_START_EXPR' || last_type === 'TK_END_BLOCK' || last_text === '.') {
+ if (wanted_newline) {
+ print_newline();
+ }
+ // do nothing on (( and )( and ][ and ]( and .(
+ } else if (last_type !== 'TK_WORD' && last_type !== 'TK_OPERATOR') {
+ print_single_space();
+ } else if (last_word === 'function' || last_word === 'typeof') {
+ // function() vs function ()
+ if (opt_jslint_happy) {
+ print_single_space();
+ }
+ } else if (in_array(last_text, line_starters) || last_text === 'catch') {
+ if (opt_space_before_conditional) {
+ print_single_space();
+ }
+ }
+ print_token();
+
+ break;
+
+ case 'TK_END_EXPR':
+ if (token_text === ']') {
+ if (opt_keep_array_indentation) {
+ if (last_text === '}') {
+ // trim_output();
+ // print_newline(true);
+ remove_indent();
+ print_token();
+ restore_mode();
+ break;
+ }
+ } else {
+ if (flags.mode === '[INDENTED-EXPRESSION]') {
+ if (last_text === ']') {
+ restore_mode();
+ print_newline();
+ print_token();
+ break;
+ }
+ }
+ }
+ }
+ restore_mode();
+ print_token();
+ break;
+
+ case 'TK_START_BLOCK':
+
+ if (last_word === 'do') {
+ set_mode('DO_BLOCK');
+ } else {
+ set_mode('BLOCK');
+ }
+ if (opt_brace_style === "expand" || opt_brace_style === "expand-strict") {
+ var empty_braces = false;
+ if (opt_brace_style === "expand-strict") {
+ empty_braces = (look_up() === '}');
+ if (!empty_braces) {
+ print_newline(true);
+ }
+ } else {
+ if (last_type !== 'TK_OPERATOR') {
+ if (last_text === '=' || (is_special_word(last_text) && last_text !== 'else')) {
+ print_single_space();
+ } else {
+ print_newline(true);
+ }
+ }
+ }
+ print_token();
+ if (!empty_braces) {
+ indent();
+ }
+ } else {
+ if (last_type !== 'TK_OPERATOR' && last_type !== 'TK_START_EXPR') {
+ if (last_type === 'TK_START_BLOCK') {
+ print_newline();
+ } else {
+ print_single_space();
+ }
+ } else {
+ // if TK_OPERATOR or TK_START_EXPR
+ if (is_array(flags.previous_mode) && last_text === ',') {
+ if (last_last_text === '}') {
+ // }, { in array context
+ print_single_space();
+ } else {
+ print_newline(); // [a, b, c, {
+ }
+ }
+ }
+ indent();
+ print_token();
+ }
+
+ break;
+
+ case 'TK_END_BLOCK':
+ restore_mode();
+ if (opt_brace_style === "expand" || opt_brace_style === "expand-strict") {
+ if (last_text !== '{') {
+ print_newline();
+ }
+ print_token();
+ } else {
+ if (last_type === 'TK_START_BLOCK') {
+ // nothing
+ if (just_added_newline) {
+ remove_indent();
+ } else {
+ // {}
+ trim_output();
+ }
+ } else {
+ if (is_array(flags.mode) && opt_keep_array_indentation) {
+ // we REALLY need a newline here, but newliner would skip that
+ opt_keep_array_indentation = false;
+ print_newline();
+ opt_keep_array_indentation = true;
+
+ } else {
+ print_newline();
+ }
+ }
+ print_token();
+ }
+ break;
+
+ case 'TK_WORD':
+
+ // no, it's not you. even I have problems understanding how this works
+ // and what does what.
+ if (do_block_just_closed) {
+ // do {} ## while ()
+ print_single_space();
+ print_token();
+ print_single_space();
+ do_block_just_closed = false;
+ break;
+ }
+
+ prefix = 'NONE';
+
+ if (token_text === 'function') {
+ if (flags.var_line && last_type !== 'TK_EQUALS' ) {
+ flags.var_line_reindented = true;
+ }
+ if ((just_added_newline || last_text === ';') && last_text !== '{'
+ && last_type !== 'TK_BLOCK_COMMENT' && last_type !== 'TK_COMMENT') {
+ // make sure there is a nice clean space of at least one blank line
+ // before a new function definition
+ n_newlines = just_added_newline ? n_newlines : 0;
+ if (!opt_preserve_newlines) {
+ n_newlines = 1;
+ }
+
+ for (var i = 0; i < 2 - n_newlines; i++) {
+ print_newline(false);
+ }
+ }
+ if (last_type === 'TK_WORD') {
+ if (last_text === 'get' || last_text === 'set' || last_text === 'new' || last_text === 'return') {
+ print_single_space();
+ } else {
+ print_newline();
+ }
+ } else if (last_type === 'TK_OPERATOR' || last_text === '=') {
+ // foo = function
+ print_single_space();
+ } else if (is_expression(flags.mode)) {
+ //ää print nothing
+ } else {
+ print_newline();
+ }
+
+ print_token();
+ last_word = token_text;
+ break;
+ }
+
+ if (token_text === 'case' || (token_text === 'default' && flags.in_case_statement)) {
+ if (last_text === ':' || flags.case_body) {
+ // switch cases following one another
+ remove_indent();
+ } else {
+ // case statement starts in the same line where switch
+ if (!opt_indent_case) {
+ flags.indentation_level--;
+ }
+ print_newline();
+ if (!opt_indent_case) {
+ flags.indentation_level++;
+ }
+ }
+ print_token();
+ flags.in_case = true;
+ flags.in_case_statement = true;
+ flags.case_body = false;
+ break;
+ }
+
+ if (last_type === 'TK_END_BLOCK') {
+
+ if (!in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) {
+ prefix = 'NEWLINE';
+ } else {
+ if (opt_brace_style === "expand" || opt_brace_style === "end-expand" || opt_brace_style === "expand-strict") {
+ prefix = 'NEWLINE';
+ } else {
+ prefix = 'SPACE';
+ print_single_space();
+ }
+ }
+ } else if (last_type === 'TK_SEMICOLON' && (flags.mode === 'BLOCK' || flags.mode === 'DO_BLOCK')) {
+ prefix = 'NEWLINE';
+ } else if (last_type === 'TK_SEMICOLON' && is_expression(flags.mode)) {
+ prefix = 'SPACE';
+ } else if (last_type === 'TK_STRING') {
+ prefix = 'NEWLINE';
+ } else if (last_type === 'TK_WORD') {
+ if (last_text === 'else') {
+ // eat newlines between ...else *** some_op...
+ // won't preserve extra newlines in this place (if any), but don't care that much
+ trim_output(true);
+ }
+ prefix = 'SPACE';
+ } else if (last_type === 'TK_START_BLOCK') {
+ prefix = 'NEWLINE';
+ } else if (last_type === 'TK_END_EXPR') {
+ print_single_space();
+ prefix = 'NEWLINE';
+ }
+
+ if (in_array(token_text, line_starters) && last_text !== ')') {
+ if (last_text === 'else') {
+ prefix = 'SPACE';
+ } else {
+ prefix = 'NEWLINE';
+ }
+
+ }
+
+ if (flags.if_line && last_type === 'TK_END_EXPR') {
+ flags.if_line = false;
+ }
+ if (in_array(token_text.toLowerCase(), ['else', 'catch', 'finally'])) {
+ if (last_type !== 'TK_END_BLOCK' || opt_brace_style === "expand" || opt_brace_style === "end-expand" || opt_brace_style === "expand-strict") {
+ print_newline();
+ } else {
+ trim_output(true);
+ print_single_space();
+ }
+ } else if (prefix === 'NEWLINE') {
+ if (is_special_word(last_text)) {
+ // no newline between 'return nnn'
+ print_single_space();
+ } else if (last_type !== 'TK_END_EXPR') {
+ if ((last_type !== 'TK_START_EXPR' || token_text !== 'var') && last_text !== ':') {
+ // no need to force newline on 'var': for (var x = 0...)
+ if (token_text === 'if' && last_word === 'else' && last_text !== '{') {
+ // no newline for } else if {
+ print_single_space();
+ } else {
+ flags.var_line = false;
+ flags.var_line_reindented = false;
+ print_newline();
+ }
+ }
+ } else if (in_array(token_text, line_starters) && last_text !== ')') {
+ flags.var_line = false;
+ flags.var_line_reindented = false;
+ print_newline();
+ }
+ } else if (is_array(flags.mode) && last_text === ',' && last_last_text === '}') {
+ print_newline(); // }, in lists get a newline treatment
+ } else if (prefix === 'SPACE') {
+ print_single_space();
+ }
+ print_token();
+ last_word = token_text;
+
+ if (token_text === 'var') {
+ flags.var_line = true;
+ flags.var_line_reindented = false;
+ flags.var_line_tainted = false;
+ }
+
+ if (token_text === 'if') {
+ flags.if_line = true;
+ }
+ if (token_text === 'else') {
+ flags.if_line = false;
+ }
+
+ break;
+
+ case 'TK_SEMICOLON':
+
+ print_token();
+ flags.var_line = false;
+ flags.var_line_reindented = false;
+ if (flags.mode === 'OBJECT') {
+ // OBJECT mode is weird and doesn't get reset too well.
+ flags.mode = 'BLOCK';
+ }
+ break;
+
+ case 'TK_STRING':
+
+ if (last_type === 'TK_END_EXPR' && in_array(flags.previous_mode, ['(COND-EXPRESSION)', '(FOR-EXPRESSION)'])) {
+ print_single_space();
+ } else if (last_type === 'TK_COMMENT' || last_type === 'TK_STRING' || last_type === 'TK_START_BLOCK' || last_type === 'TK_END_BLOCK' || last_type === 'TK_SEMICOLON') {
+ print_newline();
+ } else if (last_type === 'TK_WORD') {
+ print_single_space();
+ }
+ print_token();
+ break;
+
+ case 'TK_EQUALS':
+ if (flags.var_line) {
+ // just got an '=' in a var-line, different formatting/line-breaking, etc will now be done
+ flags.var_line_tainted = true;
+ }
+ print_single_space();
+ print_token();
+ print_single_space();
+ break;
+
+ case 'TK_COMMA':
+ if (flags.var_line) {
+ if (is_expression(flags.mode) || last_type === 'TK_END_BLOCK' ) {
+ // do not break on comma, for(var a = 1, b = 2)
+ flags.var_line_tainted = false;
+ }
+ if (flags.var_line_tainted) {
+ print_token();
+ flags.var_line_reindented = true;
+ flags.var_line_tainted = false;
+ print_newline();
+ break;
+ } else {
+ flags.var_line_tainted = false;
+ }
+
+ print_token();
+ print_single_space();
+ break;
+ }
+
+ if (last_type === 'TK_COMMENT') {
+ print_newline();
+ }
+
+ if (last_type === 'TK_END_BLOCK' && flags.mode !== "(EXPRESSION)") {
+ print_token();
+ if (flags.mode === 'OBJECT' && last_text === '}') {
+ print_newline();
+ } else {
+ print_single_space();
+ }
+ } else {
+ if (flags.mode === 'OBJECT') {
+ print_token();
+ print_newline();
+ } else {
+ // EXPR or DO_BLOCK
+ print_token();
+ print_single_space();
+ }
+ }
+ break;
+
+
+ case 'TK_OPERATOR':
+
+ var space_before = true;
+ var space_after = true;
+
+ if (is_special_word(last_text)) {
+ // "return" had a special handling in TK_WORD. Now we need to return the favor
+ print_single_space();
+ print_token();
+ break;
+ }
+
+ // hack for actionscript's import .*;
+ if (token_text === '*' && last_type === 'TK_UNKNOWN' && !last_last_text.match(/^\d+$/)) {
+ print_token();
+ break;
+ }
+
+ if (token_text === ':' && flags.in_case) {
+ if (opt_indent_case) {
+ flags.case_body = true;
+ }
+ print_token(); // colon really asks for separate treatment
+ print_newline();
+ flags.in_case = false;
+ break;
+ }
+
+ if (token_text === '::') {
+ // no spaces around exotic namespacing syntax operator
+ print_token();
+ break;
+ }
+
+ if (in_array(token_text, ['--', '++', '!']) || (in_array(token_text, ['-', '+']) && (in_array(last_type, ['TK_START_BLOCK', 'TK_START_EXPR', 'TK_EQUALS', 'TK_OPERATOR']) || in_array(last_text, line_starters)))) {
+ // unary operators (and binary +/- pretending to be unary) special cases
+
+ space_before = false;
+ space_after = false;
+
+ if (last_text === ';' && is_expression(flags.mode)) {
+ // for (;; ++i)
+ // ^^^
+ space_before = true;
+ }
+ if (last_type === 'TK_WORD' && in_array(last_text, line_starters)) {
+ space_before = true;
+ }
+
+ if (flags.mode === 'BLOCK' && (last_text === '{' || last_text === ';')) {
+ // { foo; --i }
+ // foo(); --bar;
+ print_newline();
+ }
+ } else if (token_text === '.') {
+ // decimal digits or object.property
+ space_before = false;
+
+ } else if (token_text === ':') {
+ if (flags.ternary_depth === 0) {
+ if (flags.mode === 'BLOCK') {
+ flags.mode = 'OBJECT';
+ }
+ space_before = false;
+ } else {
+ flags.ternary_depth -= 1;
+ }
+ } else if (token_text === '?') {
+ flags.ternary_depth += 1;
+ }
+ if (space_before) {
+ print_single_space();
+ }
+
+ print_token();
+
+ if (space_after) {
+ print_single_space();
+ }
+
+ break;
+
+ case 'TK_BLOCK_COMMENT':
+
+ var lines = split_newlines(token_text);
+ var j; // iterator for this case
+
+ if (all_lines_start_with(lines.slice(1), '*')) {
+ // javadoc: reformat and reindent
+ print_newline();
+ output.push(lines[0]);
+ for (j = 1; j < lines.length; j++) {
+ print_newline();
+ output.push(' ');
+ output.push(trim(lines[j]));
+ }
+
+ } else {
+
+ // simple block comment: leave intact
+ if (lines.length > 1) {
+ // multiline comment block starts with a new line
+ print_newline();
+ } else {
+ // single-line /* comment */ stays where it is
+ if (last_type === 'TK_END_BLOCK') {
+ print_newline();
+ } else {
+ print_single_space();
+ }
+
+ }
+
+ for (j = 0; j < lines.length; j++) {
+ output.push(lines[j]);
+ output.push("\n");
+ }
+
+ }
+ if (look_up('\n') !== '\n') {
+ print_newline();
+ }
+ break;
+
+ case 'TK_INLINE_COMMENT':
+ print_single_space();
+ print_token();
+ if (is_expression(flags.mode)) {
+ print_single_space();
+ } else {
+ force_newline();
+ }
+ break;
+
+ case 'TK_COMMENT':
+
+ if (last_text === ',' && !wanted_newline) {
+ trim_output(true);
+ }
+ if (last_type !== 'TK_COMMENT') {
+ if (wanted_newline) {
+ print_newline();
+ } else {
+ print_single_space();
+ }
+ }
+ print_token();
+ print_newline();
+ break;
+
+ case 'TK_UNKNOWN':
+ if (is_special_word(last_text)) {
+ print_single_space();
+ }
+ print_token();
+ break;
+ }
+
+ last_last_text = last_text;
+ last_type = token_type;
+ last_text = token_text;
+ }
+
+ var sweet_code = preindent_string + output.join('').replace(/[\r\n ]+$/, '');
+ return sweet_code;
+
+}
+
+// Add support for CommonJS. Just put this file somewhere on your require.paths
+// and you will be able to `var js_beautify = require("beautify").js_beautify`.
+if (typeof exports !== "undefined") {
+ exports.js_beautify = js_beautify;
+}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-mozext/adblock-plus.git
More information about the Pkg-mozext-commits
mailing list