pax_global_header00006660000000000000000000000064127051513010014505gustar00rootroot0000000000000052 comment=104e6202a38ab8e9ecec6a5faa91e2124212d8d1 jshydra-master/000077500000000000000000000000001270515130100140065ustar00rootroot00000000000000jshydra-master/.gitignore000066400000000000000000000000311270515130100157700ustar00rootroot00000000000000/mozilla*/ /jstest/ *.pycjshydra-master/.hgignore000066400000000000000000000000351270515130100156070ustar00rootroot00000000000000^mozilla.*/ ^jstest/ \.pyc$ jshydra-master/README000066400000000000000000000035671270515130100147010ustar00rootroot00000000000000JSHydra static analysis tool © 2009 Joshua Cranmer Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Like most Linux/Unix programs, ./configure && make should work to build the system. You can also pass configure options to change which repository to download from, or even use an existing mozilla-central checkout and build. The source code for SpiderMonkey is required, since this uses internal APIs. If you have your own repository, a revision newer than 2cf0bbe3772a is required, since that revision changed the parse APIs. However, a newer revision could potentially break the code. The code is not known to work with all JS features; the only code that probably does not work is E4X code. If you find a bug in the program, feel free to contact me on irc.mozilla.org (nick: jcranmer) or email me at . Since this program uses bleeding-edge versions of SpiderMonkey, some bugs may be due to broken code there. jshydra-master/__init__.py000066400000000000000000000000001270515130100161050ustar00rootroot00000000000000jshydra-master/abp_rewrite.py000077500000000000000000000016761270515130100167000ustar00rootroot00000000000000#!/usr/bin/env python # coding: utf-8 # This Source Code is subject to the terms of the Mozilla Public License # version 2.0 (the "License"). You can obtain a copy of the License at # http://mozilla.org/MPL/2.0/. import sys import os import subprocess import utils def doRewrite(files, args): application = utils.ensureJSShell() env = { 'LD_LIBRARY_PATH': os.path.relpath(os.path.dirname(application)), } baseDir = os.path.dirname(utils.__file__) command = [ application, os.path.join(baseDir, 'jshydra.js'), os.path.join(baseDir, 'scripts', 'abprewrite.js'), '--arg', ' '.join(args) ] + files return subprocess.check_output(command, env=env).replace('\r', '') if __name__ == '__main__': try: scriptArgsStart = sys.argv.index('--arg') except ValueError: scriptArgsStart = len(sys.argv) print doRewrite(sys.argv[1:scriptArgsStart], sys.argv[scriptArgsStart + 1:]) jshydra-master/autotest.py000077500000000000000000000033531270515130100162370ustar00rootroot00000000000000#!/usr/bin/env python # coding: utf-8 # This Source Code is subject to the terms of the Mozilla Public License # version 2.0 (the "License"). You can obtain a copy of the License at # http://mozilla.org/MPL/2.0/. import sys import os import subprocess import re import difflib import utils def run_tests(): application = utils.ensureJSShell() env = { 'LD_LIBRARY_PATH': os.path.relpath(os.path.dirname(application)), } baseDir = os.path.dirname(utils.__file__) testDir = os.path.join(baseDir, 'autotest') for file in os.listdir(testDir): if not re.search(r'^test_.*\.js$', file): continue file = os.path.join(testDir, file) handle = open(file, 'r') name = None arguments = None for line in handle: match = re.search(r'^//\s*([A-Za-z]+):\s*(.*?)\s*$', line) if match and match.group(1).lower() == 'name': name = match.group(2) elif match and match.group(1).lower() == 'arguments': arguments = match.group(2).split(' ') handle.close() if arguments == None: continue command = [application, os.path.join(baseDir, 'jshydra.js'), file] + arguments out = subprocess.check_output(command, stderr=subprocess.STDOUT, env=env).replace('\r', '') expected = open(file + '.expected', 'r').read().replace('\r', '') if out == expected: print '%s passed' % name else: print '%s failed! Log:' % name for line in difflib.unified_diff(expected.split('\n'), out.split('\n'), fromfile=file + '.expected', tofile=file + '.output'): print line print if __name__ == '__main__': run_tests() jshydra-master/autotest/000077500000000000000000000000001270515130100156565ustar00rootroot00000000000000jshydra-master/autotest/abprewrite_source.js000066400000000000000000000022301270515130100217350ustar00rootroot00000000000000const Cc = Components.classes const Ci = Components.interfaces; const Cu = Components.utils; const Cr = Components.results; const Cl = Components.unknown; Cu.import("foo/bar.jsm"); let {Utils} = require("utils"); let {Filter, BlockingFilter} = require("filterClasses"); let foo; let bar = 2; var bas; const FOO = "FOO"; let [a, b] = foo(); [a, b] = [1, 2]; let {x: y} = foo(); let {k1: v1, k2: v2} = foo(); for (let v of fooList) alert(v); for (let [a, b] of fooList) { a += b; b -= a; } for (let [a, b] of fooList); for (k of fooList) alert(k); let a = function() { return 1; }; let b = { get foo() { return 1; } }; function foo() { return {foo: 1, bar: 2}; } if (a == b) foo(); else if (a == c) bar(); else bas(); if (a == b); for (let a = 0; a < b.length; a++) foo(); for (var a = 0; a < b.length; a++); for (let a in b) foo(); for (var a in b); while (a==b) foo(); while (a==b); function genFunc() { for (var i = 0; i < 10; i++) { yield i; } } var a = function() { for (var i = 0; i < 10; i++) { yield i; } }; let x = (y) => y + 1; x = y => y + 1; x = (a, b) => this[a] + b; x = (a, b) => { return () => 1; } jshydra-master/autotest/test_abprewrite.js000066400000000000000000000001701270515130100214150ustar00rootroot00000000000000// Arguments: --trueast autotest/abprewrite_source.js // Name: ABP rewriting test include("../scripts/abprewrite.js"); jshydra-master/autotest/test_abprewrite.js.expected000066400000000000000000000055561270515130100232320ustar00rootroot00000000000000/* * This file is part of Adblock Plus , * Copyright (C) 2006-2016 Eyeo GmbH * * Adblock Plus is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License version 3 as * published by the Free Software Foundation. * * Adblock Plus is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Adblock Plus. If not, see . */ // // This file has been generated automatically, relevant repositories: // * https://hg.adblockplus.org/jshydra/ // var Cl = Components.unknown; var Utils = require("utils").Utils; var _tempVar0 = require("filterClasses"); var Filter = _tempVar0.Filter; var BlockingFilter = _tempVar0.BlockingFilter; var foo; var bar = 2; var bas; var FOO = "FOO"; var _tempVar1 = foo(); var a = _tempVar1[0]; var b = _tempVar1[1]; var _tempVar2 = [1, 2]; a = _tempVar2[0]; b = _tempVar2[1]; var y = foo().x; var _tempVar3 = foo(); var v1 = _tempVar3.k1; var v2 = _tempVar3.k2; for (var _loopIndex4 = 0; _loopIndex4 < fooList.length; ++_loopIndex4) { var v = fooList[_loopIndex4]; alert(v); } for (var _loopIndex5 = 0; _loopIndex5 < fooList.length; ++_loopIndex5) { var _tempVar6 = fooList[_loopIndex5]; var a = _tempVar6[0]; var b = _tempVar6[1]; a += b; b -= a; } for (var _loopIndex7 = 0; _loopIndex7 < fooList.length; ++_loopIndex7) { var _tempVar8 = fooList[_loopIndex7]; var a = _tempVar8[0]; var b = _tempVar8[1]; } for (var _loopIndex9 = 0; _loopIndex9 < fooList.length; ++_loopIndex9) { k = fooList[_loopIndex9]; alert(k); } var a = function() { return 1; }; var b = { get foo() { return 1; } }; function foo() { return { foo: 1, bar: 2 }; } if (a == b) { foo(); } else if (a == c) { bar(); } else { bas(); } if (a == b) {} for (var a = 0; a < b.length; a++) { foo(); } for (var a = 0; a < b.length; a++) {} for (var a in b) { foo(); } for (var a in b) {} while (a == b) { foo(); } while (a == b) {} function genFunc() { var _generatorResult10 = []; for (var i = 0; i < 10; i++) { _generatorResult10.push(i); } return _generatorResult10; } var a = function() { var _generatorResult10 = []; for (var i = 0; i < 10; i++) { _generatorResult10.push(i); } return _generatorResult10; }; var x = function(y) { return y + 1; }; x = function(y) { return y + 1; }; x = function(a, b) { return this[a] + b; }.bind(this); x = function(a, b) { return function() { return 1; }; }.bind(this); jshydra-master/autotest/test_abprewrite_module.js000066400000000000000000000002211270515130100227570ustar00rootroot00000000000000// Arguments: --trueast --arg module=true autotest/abprewrite_source.js // Name: ABP module rewriting test include("../scripts/abprewrite.js"); jshydra-master/autotest/test_abprewrite_module.js.expected000066400000000000000000000063251270515130100245720ustar00rootroot00000000000000/* * This file is part of Adblock Plus , * Copyright (C) 2006-2016 Eyeo GmbH * * Adblock Plus is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License version 3 as * published by the Free Software Foundation. * * Adblock Plus is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Adblock Plus. If not, see . */ // // This file has been generated automatically, relevant repositories: // * https://hg.adblockplus.org/jshydra/ // require.scopes["abprewrite_source"] = (function() { var exports = {}; var Cl = Components.unknown; var Utils = require("utils").Utils; var _tempVar0 = require("filterClasses"); var Filter = _tempVar0.Filter; var BlockingFilter = _tempVar0.BlockingFilter; var foo; var bar = 2; var bas; var FOO = "FOO"; var _tempVar1 = foo(); var a = _tempVar1[0]; var b = _tempVar1[1]; var _tempVar2 = [1, 2]; a = _tempVar2[0]; b = _tempVar2[1]; var y = foo().x; var _tempVar3 = foo(); var v1 = _tempVar3.k1; var v2 = _tempVar3.k2; for (var _loopIndex4 = 0; _loopIndex4 < fooList.length; ++_loopIndex4) { var v = fooList[_loopIndex4]; alert(v); } for (var _loopIndex5 = 0; _loopIndex5 < fooList.length; ++_loopIndex5) { var _tempVar6 = fooList[_loopIndex5]; var a = _tempVar6[0]; var b = _tempVar6[1]; a += b; b -= a; } for (var _loopIndex7 = 0; _loopIndex7 < fooList.length; ++_loopIndex7) { var _tempVar8 = fooList[_loopIndex7]; var a = _tempVar8[0]; var b = _tempVar8[1]; } for (var _loopIndex9 = 0; _loopIndex9 < fooList.length; ++_loopIndex9) { k = fooList[_loopIndex9]; alert(k); } var a = function() { return 1; }; var b = { get foo() { return 1; } }; function foo() { return { foo: 1, bar: 2 }; } if (a == b) { foo(); } else if (a == c) { bar(); } else { bas(); } if (a == b) {} for (var a = 0; a < b.length; a++) { foo(); } for (var a = 0; a < b.length; a++) {} for (var a in b) { foo(); } for (var a in b) {} while (a == b) { foo(); } while (a == b) {} function genFunc() { var _generatorResult10 = []; for (var i = 0; i < 10; i++) { _generatorResult10.push(i); } return _generatorResult10; } var a = function() { var _generatorResult10 = []; for (var i = 0; i < 10; i++) { _generatorResult10.push(i); } return _generatorResult10; }; var x = function(y) { return y + 1; }; x = function(y) { return y + 1; }; x = function(a, b) { return this[a] + b; }.bind(this); x = function(a, b) { return function() { return 1; }; }.bind(this); return exports; })(); jshydra-master/autotest/test_comments.js.expected000066400000000000000000000002101270515130100226710ustar00rootroot00000000000000process_js: // Processes an AST tree test_object: // Documenting an object! someMethod: /** * This method does absolutely nothing. */ jshydra-master/autotest/test_globals.js.expected000066400000000000000000000001411270515130100224720ustar00rootroot00000000000000Global variables: glob at 6:0 Global constants: LS at 7:0 Global functions: process_js at 9:9 jshydra-master/autotest/test_trueast.js.expected000066400000000000000000000032341270515130100225440ustar00rootroot00000000000000Program @ 0:0: + sourceElements: [ ExpressionStatement @ 4:0: + expr: CallExpression @ 4:0: + precedence: 2 + func: IdentifierExpression @ 4:0: + precedence: 0 + name: include + arguments: [ LiteralExpression @ 4:8: + precedence: 0 + objtype: string + value: ../utils/astml.js ] FunctionDeclaration @ 6:9: + precedence: Infinity + name: process_js + arguments: [ Parameter @ 6:20: + precedence: 0 + name: pn Parameter @ 6:24: + precedence: 0 + name: file ] + body: BlockStatement @ 6:30: + statements: [ VarStatement @ 7:2: + vartype: var + variables: [ VarDeclaration @ 7:6: + precedence: 0 + name: ast + initializer: CallExpression @ 7:12: + precedence: 2 + func: IdentifierExpression @ 7:12: + precedence: 0 + name: makeAST + arguments: [ IdentifierExpression @ 7:20: + precedence: 0 + name: pn ] ] ExpressionStatement @ 8:2: + expr: CallExpression @ 8:2: + precedence: 2 + func: IdentifierExpression @ 8:2: + precedence: 0 + name: dump_trueast + arguments: [ IdentifierExpression @ 8:15: + precedence: 0 + name: ast ] ] ] jshydra-master/autotest/~test_comments.js000066400000000000000000000014021270515130100212730ustar00rootroot00000000000000// Arguments: autotest/test_comments.js // Name: Comment association test // This comment is associated with only code, so I don't see this. include("../utils/cleanast.js"); include("../utils/comments.js"); // Processes an AST tree function process_js(ast, file) { let objects = clean_ast(ast); associate_comments(file, objects); for each (let f in objects.functions) { if (f.comment) _print(f.name + ": " + f.comment); } for each (let o in objects.objects) { if (o.comment) _print(o.name + ": " + o.comment); for (let m in o.functions) { _print(m + ": " + o.functions[m].comment); } } } // Documenting an object! var test_object = { /** * This method does absolutely nothing. */ someMethod: function () {} }; jshydra-master/autotest/~test_globals.js000066400000000000000000000011741270515130100210770ustar00rootroot00000000000000// Arguments: autotest/test_globals.js // Name: Global information test include("../utils/cleanast.js"); var glob = this; const LS = "foobar"; function process_js(ast) { let toplevel = clean_ast(ast); _print("Global variables:"); for each (let v in toplevel.variables) { _print("\t" + v.name + " at " + v.loc.line + ":" + v.loc.column); } _print("Global constants:"); for each (let v in toplevel.constants) { _print("\t" + v.name + " at " + v.loc.line + ":" + v.loc.column); } _print("Global functions:"); for each (let v in toplevel.functions) { _print("\t" + v.name + " at " + v.loc.line + ":" + v.loc.column); } } jshydra-master/autotest/~test_trueast.js000066400000000000000000000002541270515130100211410ustar00rootroot00000000000000// Arguments: autotest/test_trueast.js // Name: Simple asts include("../utils/astml.js"); function process_js(pn, file) { let ast = makeAST(pn); dump_trueast(ast); } jshydra-master/jshydra.js000066400000000000000000000020521270515130100160070ustar00rootroot00000000000000var include = function(file) { if (typeof include.dirStack == "undefined") include.dirStack = []; if (include.dirStack.length && !/^([a-zA-Z]:)?[\/\\]/.test(file)) file = include.dirStack[include.dirStack.length - 1] + "/../" + file; while (/\/[^.\/][^\/]*\/\.\.(?=\/)/.test(file)) file = file.replace(/\/[^.\/][^\/]*\/\.\.(?=\/)/, ""); include.dirStack.push(file); try { load(file); } finally { include.dirStack.pop(); } } var _print = print; (function(scriptArgs) { let scriptArg = ""; for (var i = 0; i < scriptArgs.length; i++) { if (scriptArgs[i] == "--trueast") scriptArgs.splice(i--, 1); else if (scriptArgs[i] == "--arg" && i < scriptArgs.length - 1) { scriptArg = scriptArgs[i + 1]; scriptArgs.splice(i--, 2); } } if (!scriptArgs.length) throw Error("No script to execute"); include(scriptArgs[0]); for (var i = 1; i < scriptArgs.length; i++) process_js(Reflect.parse(read(scriptArgs[i])), scriptArgs[i], scriptArg); })(this.arguments || this.scriptArgs); jshydra-master/scripts/000077500000000000000000000000001270515130100154755ustar00rootroot00000000000000jshydra-master/scripts/abprewrite.js000066400000000000000000000333371270515130100202100ustar00rootroot00000000000000// This script rewrites AST to be compatible with JavaScript 1.5 and decompiles // the modified tree then include("../scripts/astDecompile.js"); include("../utils/beautify.js"); let headerPrinted = false; // 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", source_repo: "" }; let global = this; function Literal(value) { return { type: "Literal", value: value }; } function Identifier(varname) { return { type: "Identifier", name: varname }; } function Member(object, property, computed) { if (typeof object == "string") object = Identifier(object); if (typeof property != "object") property = Identifier(property); return { type: "MemberExpression", object: object, property: property, computed: computed }; } function VariableDeclaration(variable, value) { 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" }; } function Assignment(variable, value) { if (typeof variable == "string") variable = Identifier(variable); return { type: "ExpressionStatement", expression: { type: "AssignmentExpression", left: variable, right: value, operator: "=" } }; } function LogicalExpression(left, operator, right) { 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 }; } function IncExpression(variable) { if (typeof variable != "object") variable = Identifier(variable); return { type: "UpdateExpression", argument: variable, operator: "++", prefix: true }; } function ensureBlock(ast) { if (ast.type == "BlockStatement") return ast; else return {type: "BlockStatement", body: (ast.type == "EmptyStatement" ? [] : [ast])}; } function modifyAST(ast) { // Do the necessary modifications let func = "modify" + ast.type; if (typeof global[func] == "function") ast = global[func](ast); // Recursive calls for any AST in properties of the current one if (ast) { let props = []; for (let prop in ast) props.push(prop); for (let i = 0; i < props.length; i++) { let value = ast[props[i]]; if (!value || typeof value != "object") continue; if ("type" in value) { 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 (value[j] && typeof value[j] == "object" && "type" in value[j]) { let result = modifyAST(value[j]); if (result) value[j] = result; else value.splice(j--, 1); } } } } } 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; } if (ast.expression.type == "AssignmentExpression" && ast.expression.operator == "=" && ast.expression.left.type == "ArrayPattern") { // 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 and const variables: // let foo = bar; // const bas = 4; // // Change into: // var foo = bar; // var bas = 4; if (ast.kind == "let" || ast.kind == "const") ast.kind = "var"; if (ast.declarations.length == 1 && ast.declarations[0].type == "VariableDeclarator") { let declarator = ast.declarations[0]; // 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: // var [foo, bar] = [1, 2]; // // Change into: // var _tempVar44 = [1, 2]; // 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 (declarator.id.type == "ObjectPattern") { // Convert destructuring assignment: // var {foo: bar, foo2: bar2} = {foo: 1, foo2: 2}; // // Change into: // 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 { 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++) block.body.push(VariableDeclaration(vars[i].value, Member(tempVar, vars[i].key, false))); return block; } } } return ast; } function modifyForStatement(ast) { // Make sure that the loop body is always wrapped in a block ast.body = ensureBlock(ast.body); return ast; } function modifyWhileStatement(ast) { // Make sure that the loop body is always wrapped in a block ast.body = ensureBlock(ast.body); return ast; } function modifyIfStatement(ast) { // Make sure that the statements are always wrapped in a block ast.consequent = ensureBlock(ast.consequent); if (ast.alternate && ast.alternate.type != "IfStatement") ast.alternate = ensureBlock(ast.alternate); return ast; } function modifyForInStatement(ast) { if (ast.each) { print("Use for (.. of ..) instead of for each (..)!\n"); throw new Error("Use for (.. of ..) instead of for each (..)!"); } // Make sure that the loop body is always wrapped in a block ast.body = ensureBlock(ast.body); return ast; } function modifyForOfStatement(ast) { // Convert "for of" loops: // for (var foo of fooList) // { // ... // } // // Change into: // for (var _loopIndex44 = 0; _loopIndex44 < fooList.length; ++_loopIndex44) // { // var foo = fooList[_loopIndex44]; // ... // } let loopIndex = Identifier("_loopIndex" + options.varIndex++); let block = ensureBlock(ast.body); 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 }; } function modifyLetStatement(ast) { if (ast.body.type == "ForStatement" && ast.body.init == null) { // Convert back "for" loops written as "let" statements: // let (foo = 0) for (; foo < bar; ++foo) // { // ... // } // // Change into: // for (let foo = 0; foo < bar; ++foo) // { // ... // } ast.body.init = { type: "VariableDeclaration", declarations: [], kind: "let" }; for (let i = 0; i < ast.head.length; i++) { ast.head[i].type = "VariableDeclarator"; ast.body.init.declarations.push(ast.head[i]); } return modifyForStatement(ast.body); } return ast; } function modifyFunctionExpression(ast) { if (ast.expression) { print("Use arrow functions instead of function expressions!\n"); throw new Error("Use arrow functions instead of function expressions!"); } if (ast.generator) { // Convert generators: // function() // { // ... // yield "foo"; // ... // } // // Change into: // function() // { // var _generatorResult44 = []; // ... // _generatorResult44.push("foo"); // ... // return _generatorResult44; // } // // Note: yield statements are converted in modifyYieldExpression(). if (!("generatorVar" in options)) options.generatorVar = Identifier("_generatorResult" + options.varIndex++); ast.generator = false; ast.body.body.unshift(VariableDeclaration(options.generatorVar, { type: "ArrayExpression", elements: null })); ast.body.body.push({ type: "ReturnStatement", argument: options.generatorVar }); } return ast; } function modifyFunctionDeclaration(ast) { return modifyFunctionExpression(ast); } function modifyArrowExpression(ast) { if (ast.body.type != "BlockStatement") { // Convert expressions to block statements. // (a) => a + 1 // // Change into: // (a) => { return a + 1; } ast.body = { type: "BlockStatement", body: [ { type: "ReturnStatement", argument: ast.body } ] }; } // Now convert the arrow expression into a normal // function expression. ast.type = "FunctionExpression"; ast.expression = false; // We want to avoid the .bind call if |this| isn't actually used. // This is not necessarily always correct, but should be good enough. var body = decompileAST(ast.body); if (/((\bthis\b)|=>)/.test(body)) { return { type: "CallExpression", callee: Member(ast, "bind"), arguments: [ { type: "ThisExpression" } ] }; } return ast; } function modifyYieldExpression(ast) { // Convert generators into functions returning arrays: // yield "foo"; // // Change into: // _generatorResult44.push("foo"); if (ast.argument) { return { type: "CallExpression", callee: Member(options.generatorVar, "push"), arguments: [ast.argument] }; } else return null; } process_js = function(ast, filename, args) { for (let arg of args.split(/\s+/)) { let match = /^(\w+)\s*=\s*(.*)/.exec(arg); if (match && typeof options[match[1]] == "boolean") options[match[1]] = (match[2] == "true"); else if (match && typeof options[match[1]] == "string") options[match[1]] = match[2]; } if (!headerPrinted) { // Output license header and warning - do this only once, not each time a file // is being processed. _print('/*'); _print(' * This file is part of Adblock Plus ,'); _print(' * Copyright (C) 2006-2016 Eyeo GmbH'); _print(' *'); _print(' * Adblock Plus is free software: you can redistribute it and/or modify'); _print(' * it under the terms of the GNU General Public License version 3 as'); _print(' * published by the Free Software Foundation.'); _print(' *'); _print(' * Adblock Plus is distributed in the hope that it will be useful,'); _print(' * but WITHOUT ANY WARRANTY; without even the implied warranty of'); _print(' * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the'); _print(' * GNU General Public License for more details.'); _print(' *'); _print(' * You should have received a copy of the GNU General Public License'); _print(' * along with Adblock Plus. If not, see .'); _print(' */'); _print(); _print('//'); _print('// This file has been generated automatically, relevant repositories:'); if (options.source_repo) _print('// * ' + options.source_repo); _print('// * https://hg.adblockplus.org/jshydra/'); _print('//'); _print(); headerPrinted = true; } options.filename = filename.replace(/.*[\\\/]/, "").replace(/\.jsm?$/, ""); // Modify AST if (ast) ast = modifyAST(ast); if (!ast) return; 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' + decompileAST(ast).replace(/^("use strict";\n)?/, "$1var exports = {};\n") + 'return exports;\n' + '})();\n'; _print(js_beautify(code, options)); } else _print(js_beautify(decompileAST(ast), options)); } jshydra-master/scripts/ast.js000066400000000000000000000002111270515130100166140ustar00rootroot00000000000000// This just dumps out an ast for your viewing pleasure. include("../utils/dumpast.js"); function process_js(ast) { dump_ast(ast); } jshydra-master/scripts/astDecompile.js000066400000000000000000000324701270515130100204520ustar00rootroot00000000000000let global = this; function decompileAST(ast) { let func = global["decompile" + ast.type]; if (!func) throw "Unknown type " + ast.type; return func(ast); } function decompileProgram(ast) { return [decompileAST(stmt) for each (stmt in ast.body)].join('\n'); } /* Statements */ function decompileEmptyStatement(ast) { return ";" } function decompileBlockStatement(ast) { return '{\n' + [decompileAST(stmt) for each (stmt in ast.body)].join('\n') + '\n}\n'; } function decompileExpressionStatement(ast) { return decompileAST(ast.expression) + ";"; } function decompileIfStatement(ast) { let str = "if (" + decompileAST(ast.test) + ")\n"; str += decompileAST(ast.consequent); if (ast.alternate) str += " else\n" + decompileAST(ast.alternate); return str; } function decompileLabeledStatement(ast) { return ast.label.name + ": " + decompileAST(ast.body); } function decompileBreakStatement(ast) { return "break" + (ast.label ? " " + ast.label.name : "") + ";"; } function decompileContinueStatement(ast) { return "continue" + (ast.label ? " " + ast.label.name : "") + ";"; } function decompileWithStatement(ast) { return "with (" + decompileAST(ast.object) + ") " + decompileAST(ast.body); } function decompileSwitchStatement(ast) { let str = "switch (" + decompileAST(ast.discriminant) + ") {\n"; let cases = []; for each (let scase in ast.cases) { let casestr = scase.test ? "case " + decompileAST(scase.test) : "default"; casestr += ":\n"; casestr += [decompileAST(stmt) for each (stmt in scase.consequent)] .join('\n'); cases.push(casestr); } str += cases.join('\n') + '\n}\n'; return str; } function decompileReturnStatement(ast) { return "return" + (ast.argument ? " " + decompileAST(ast.argument) : "") + ";"; } function decompileThrowStatement(ast) { return "throw " + decompileAST(ast.argument) + ";"; } function decompileTryStatement(ast) { let str = "try " + decompileAST(ast.block); let handlers = []; if (ast.handler && "type" in ast.handler) handlers.push(ast.handler); else if (ast.handlers) handlers = ast.handlers; let handler_strs = []; for each (let handler in handlers) { let handler_str = "catch (" + decompileAST(handler.param); if (handler.guard) handler_str += " if " + decompileAST(handler.guard); handler_str += ") " + decompileAST(handler.body); handler_strs.push(handler_str); } str += handler_strs.join(""); if (ast.finalizer) str += " finally " + decompileAST(ast.finalizer); return str; } function decompileWhileStatement(ast) { return "while (" + decompileAST(ast.test) + ") " + decompileAST(ast.body); } function decompileDoWhileStatement(ast) { return "do " + decompileAST(ast.body) + " while (" + decompileAST(ast.test) + ");"; } function decompileForStatement(ast) { let str = "for ("; if (ast.init) { if (ast.init.type == "VariableDeclaration") str += decompileAST(ast.init); else str += decompileAST(ast.init) + ";"; } else { str += ";"; } if (ast.test) str += decompileAST(ast.test); str += ";"; if (ast.update) str += decompileAST(ast.update); str += ") "; return str + decompileAST(ast.body); } function decompileForInStatement(ast) { let str = "for"; if (ast.each) str += " each"; str += "("; if (ast.left.type == "VariableDeclaration") str += decompileVariableDeclaration(ast.left, true); else str += decompileAST(ast.left); str += " in " + decompileExpr(ast.right, ast) + ") "; str += decompileAST(ast.body); return str; } function decompileForOfStatement(ast) { let str = "for ("; if (ast.left.type == "VariableDeclaration") str += decompileVariableDeclaration(ast.left, true); else str += decompileAST(ast.left); str += " of " + decompileExpr(ast.right, ast) + ") "; str += decompileAST(ast.body); return str; } function decompileLetStatement(ast) { let str = "let ("; str += [d ? decompileAST(d) : ' ' for each (d in ast.head)].join(', '); str += ") " + decompileAST(ast.body); return str; } function decompileDebuggerStatement(ast) { return "debugger;"; } function decompileFunctionDeclaration(ast, init, name_ast) { let str = (init ? init : "function") + " "; if (ast.id) str += ast.id.name; else if (name_ast) str += decompileAST(name_ast); str += "("; str += [decompileAST(param) for each (param in ast.params)].join(', '); str += ") " + decompileAST(ast.body); return str; } function decompileVariableDeclaration(ast, excludeSemi) { let inits = []; for each (let initializer in ast.declarations) { inits.push(decompileAST(initializer)); } return ast.kind + " " + inits.join(', ') + (excludeSemi ? "" : ";"); } function decompileVariableDeclarator(ast) { if (ast.init) return decompileAST(ast.id) + " = " + decompileAST(ast.init); return decompileAST(ast.id); } /* Expressions */ let precedence = { "SequenceExpression": 0, "AssignmentExpression": 1, "YieldExpression": 2, "ConditionalExpression": 3, "||": 4, "&&": 5, "|": 6, "^": 7, "&": 8, "==": 9, "!=": 9, "===": 9, "!==": 9, "<=": 10, ">=": 10, "<": 10, ">": 10, "in": 10, "instanceof": 10, "ForInStatement": 10, "<<": 11, ">>": 11, ">>>": 11, "+": 12, "-": 12, "*": 13, "/": 13, "%": 13, "UnaryExpression": 14, "UpdateExpression": 15, "NewExpression": 16, "CallExpression": 17, "MemberExpression": 17, "FunctionExpression": 18 /* Everything else is 19 */ }; function getPrecedence(expr) { if (expr.type in precedence) return precedence[expr.type]; else if (expr.operator && expr.operator in precedence) return precedence[expr.operator]; return 19; } function decompileExpr(expr, par, forceParen) { if (getPrecedence(expr) < getPrecedence(par) || (forceParen && getPrecedence(expr) == getPrecedence(par)) || (expr.type == "FunctionExpression" && par.type == "CallExpression")) return "(" + decompileAST(expr) + ")"; else return decompileAST(expr); } function decompileThisExpression(ast) { return "this"; } function decompileArrayExpression(ast) { if (ast.elements) return "[" + [el ? decompileAST(el) : "" for each (el in ast.elements)]. join(", ") + "]"; return "[]"; } function decompileObjectExpression(ast) { let props = []; for each (let prop in ast.properties) { if (prop.kind == "init") props.push(decompileAST(prop.key) + ": " + decompileAST(prop.value)); else if (prop.kind == "get" || prop.kind == "set") props.push(decompileFunctionDeclaration(prop.value, prop.kind, prop.key)); else throw "Unknown kind " + prop.kind; } return "{\n" + props.join(",\n") + "}"; } function decompileFunctionExpression(ast) { return decompileFunctionDeclaration(ast); } function decompileArrowExpression(ast) { let str = "(" + ast.params.map(decompileAST).join(", ") + ")"; str += " => " + decompileAST(ast.body); return str; } function decompileSequenceExpression(ast) { return "(" + [decompileExpr(e, ast) for each (e in ast.expressions)].join(", ") + ")"; } function decompileUnaryExpression(ast) { if (ast.prefix) return ast.operator + " " + decompileExpr(ast.argument, ast); throw "ER, wtf?"; } function decompileBinaryExpression(ast) { return decompileExpr(ast.left, ast) + " " + ast.operator + " " + decompileExpr(ast.right, ast, true); } function decompileAssignmentExpression(ast) { return decompileExpr(ast.left, ast, true) + " " + ast.operator + " " + decompileExpr(ast.right, ast); } function decompileUpdateExpression(ast) { let before = "", after = ast.operator; if (ast.prefix) { before = after; after = ""; } return before + decompileExpr(ast.argument, ast) + after; } function decompileLogicalExpression(ast) { return decompileExpr(ast.left, ast) + " " + ast.operator + " " + decompileExpr(ast.right, ast, true); } function decompileConditionalExpression(ast) { return decompileExpr(ast.test, ast) + " ? " + decompileExpr(ast.consequent, ast) + " : " + decompileExpr(ast.alternate, ast); } function decompileNewExpression(ast) { let str = "new " + decompileAST(ast.callee, ast) + "("; if (ast.arguments) str += [decompileAST(arg) for each (arg in ast.arguments)].join(", "); str += ")"; return str; } function decompileCallExpression(ast) { return decompileExpr(ast.callee, ast) + "(" + [decompileAST(param) for each (param in ast.arguments)] + ")"; } function decompileMemberExpression(ast) { function isIdentifier(ast2) { let val = decompileAST(ast2); if (val.length == 0) return false; if (!(val[0] == '_' || val[0] == '$' || (val[0] >= 'a' && val[0] <= 'z') || (val[0] >= 'A' && val[0] <= 'Z'))) return false; for (let i = 1; i < val.length; i++) { if (!(val[i] == '_' || val[i] == '$' || (val[i] >= 'a' && val[i] <= 'z') || (val[i] >= 'A' && val[i] <= 'Z') || (val[i] >= '0' && val[i] <= '9'))) return false; } return true; } return decompileExpr(ast.object, ast) + (ast.computed ? '[' + decompileAST(ast.property) + ']' : !isIdentifier(ast.property) ? '["' + sanitize(decompileAST(ast.property), '"') + '"]' : '.' + ast.property.name); } function decompileYieldExpression(ast) { return "yield" + (ast.argument ? " " + decompileAST(ast.argument) : ""); } function decompileComprehensionExpression(ast, paren) { let str = (paren ? paren.l : "[") + decompileAST(ast.body); for each (let block in ast.blocks) { str += (block.each ? " for each " : " for ") str += "(" + decompileAST(block.left) + " in "; str += decompileAST(block.right) + ")"; } if (ast.filter) str += " if (" + decompileAST(ast.filter) + ")"; return str + (paren ? paren.r : "]"); } function decompileGeneratorExpression(ast) { return decompileComprehensionExpression(ast, {l: "(", r: ")"}); } function decompileGraphExpression(ast) { return "#" + ast.index + "=" + decompileAST(ast.expression); } function decompileGraphIndexExpression(ast) { return "#" + ast.index; } function decompileLetExpression(ast) { return decompileLetStatement(ast); } /* Patterns */ function decompileObjectPattern(ast) { let str = "{"; str += [decompileAST(p.key) + ": " + decompileAST(p.value) for each (p in ast.properties)].join(', '); return str + "}"; } function decompileArrayPattern(ast) { return "[" + [e ? decompileAST(e) : ' ' for each (e in ast.elements)].join(', ') + "]"; } function decompileIdentifier(ast) { return ast.name; } function sanitize(str, q) { function replace(x) { if (x == q) return '\\' + q; if (x == '\\') return '\\\\'; if (x == '\b') return '\\b'; if (x == '\f') return '\\f'; if (x == '\n') return '\\n'; if (x == '\r') return '\\r'; if (x == '\t') return '\\t'; if (x == '\v') return '\\v'; let val = x.charCodeAt(0) if (x < ' ') return '\\x' + (val - val % 16) / 16 + (val % 16); return x; } return [replace(x) for each (x in str)].join(''); } function decompileLiteral(ast) { if (typeof ast.value == "string") return '"' + sanitize(ast.value, '"') + '"'; if (ast.value === null) return "null"; return ast.value; } /* E4X */ function decompileXMLDefaultDeclaration(ast) { return "default xml namespace = " + decompileAST(ast.namespace) + ";"; } function decompileXMLAnyName(ast) { return "*"; } function decompileXMLQualifiedIdentifier(ast) { let str = decompileAST(ast.left) + "::"; if (ast.computed) str += "["; str += decompileAST(ast.right); if (ast.computed) str += "]"; return str; } function decompileXMLFunctionQualifiedIdentifier(ast) { let str = "function::"; if (ast.computed) str += "["; str += decompileAST(ast.right); if (ast.computed) str += "]"; return str; } function decompileXMLAttributeSelector(ast) { return "@" + decompileAST(ast.attribute); } function decompileXMLFilterExpression(ast) { return decompileAST(ast.left) + ".(" + decompileAST(ast.right) + ")"; } function decompileXMLElement(ast) { return [decompileAST(xml) for each (xml in ast.contents)].join(''); } function decompileXMLList(ast) { return "<>" + [decompileAST(xml) for each (xml in ast.contents)].join("") + ""; } function decompileXMLEscape(ast) { return "{" + decompileAST(ast.expression) + "}"; } function decompileXMLText(ast) { return ast.text; } function tagJoin(strings) { let str = strings[0]; for (let i = 1; i < strings.length; i++) str += (i % 2 ? ' ' : '=') + strings[i]; return str; } function decompileXMLStartTag(ast) { return "<" + tagJoin([decompileAST(xml) for each (xml in ast.contents)]) + ">"; } function decompileXMLEndTag(ast) { return ""; } function decompileXMLPointTag(ast) { return "<" + tagJoin([decompileAST(xml) for each (xml in ast.contents)]) + "/>"; } function decompileXMLName(ast) { if (typeof ast.contents == "string") return ast.contents + " "; return [decompileAST(xml) for each (xml in ast.contents)].join(''); } function decompileXMLAttribute(ast) { return '"' + ast.value + '"'; } function decompileXMLCdata(ast) { return ""; } function decompileXMLComment(ast) { return ""; } function decompileXMLProcessingInstruction(ast) { return ""; } function process_js(ast) { _print(decompileAST(ast)); } jshydra-master/scripts/basic.js000066400000000000000000000004051270515130100171130ustar00rootroot00000000000000// Run ../jshydra basic.js basic.js: it should work. // This is a simple test just to make sure that something isn't borking with // jshydra. _print("HI!"); function process_js(ast) { for (let f in ast) { _print(f + ": "+ ast[f]); } _print(uneval(ast)); } jshydra-master/scripts/decompile.js000066400000000000000000000270411270515130100200000ustar00rootroot00000000000000// Decompile a JS file. This will be painful. include("../utils/dumpast.js"); include("../utils/astml.js"); let visitor = { _visitArray: function (arr, pre, post, comma) { if (pre === undefined) pre = '('; if (post === undefined) post = ')'; if (comma === undefined) comma = ', '; output(pre); for each (let arg in arr) { arg.visit(this); output(comma); } if (arr.length > 0) unwrite(comma.length); output(post); }, _visitMaybeBlock: function (body) { if (body.type == "BlockStatement") { output(" "); body.visit(this); } else { flush().indent(); body.visit(this); unindent(); } }, _visitNeedBlock: function (stmt, noFlush) { if (stmt.type == "EmptyStatement") { output("{}") if (!noFlush) flush(); } else if (stmt.type == "ReturnStatement") { output("{").flush().indent(); stmt.visit(this); unindent().output("}"); if (!noFlush) flush(); } else stmt.visit(this); }, visitProgram: function (program) {}, visitFunctionDeclaration: function (func) { output("function "); if (func.name) output(func.name); this._visitArray(func.arguments, '(', ') '); this._visitNeedBlock(func.body, true); return true; }, visitParameter: function (p) { output(p.name); }, visitBlockStatement: function (stmt) { output("{").flush().indent(); }, postvisitBlockStatement: function (stmt) { output("}").unindent().flush(); }, visitVarStatement: function (stmt) { output(stmt.vartype).output(" "); this._visitArray(stmt.variables, '', ''); if (!this._noFlush) output(';').flush(); this._noFlush = false; return true; }, visitVarDeclaration: function (decl) { output(decl.name); if ("initializer" in decl) output(" = "); }, visitLetStatement: function (stmt) { output("let "); this._visitArray(stmt.variables, '(', ')'); if (!this._noFlush) output(';').flush(); this._noFlush = false; return true; }, visitExpressionStatement: function (stmt) {}, postvisitExpressionStatement: function (stmt) { output(";").flush(); }, visitEmptyStatement: function (stmt) { output(";").flush(); }, visitIfStatement: function (stmt) { output("if ("); stmt.cond.visit(this); output(")"); this._visitMaybeBlock(stmt.body); if (stmt.elsebody) { output(" else"); this._visitMaybeBlock(stmt.elsebody); } return true; }, visitDoWhileStatement: function (stmt) { output("do"); this._visitMaybeBlock(stmt.body); output("while ("); stmt.cond.visit(this); output(");").flush(); return true; }, visitWhileStatement: function (stmt) { output("while ("); stmt.cond.visit(this); output(")"); this._visitMaybeBlock(stmt.body); return true; }, visitForStatement: function (stmt) { output("for ("); stmt.init.visit(this); stmt.cond.visit(this); if (stmt.cond.type != "EmptyStatement") output("; "); stmt.inc.visit(this); output(")"); this._visitMaybeBlock(stmt.body); return true; }, visitForInStatement: function (stmt) { output(stmt.itertype).output(" ("); this._noFlush = true; stmt.itervar.visit(this); output(" in "); stmt.iterrange.visit(this); output(")"); this._visitMaybeBlock(stmt.body); return true; }, visitContinueStatement: function (stmt) { output("continue"); if ("label" in stmt) output(" ").output(stmt.label); output(";").flush(); }, visitBreakStatement: function (stmt) { output("break"); if ("label" in stmt) output(" ").output(stmt.label); output(";").flush(); }, visitReturnStatement: function (stmt) { output("return "); }, postvisitReturnStatement: function (stmt) { output(";").flush(); }, visitWithStatement: function (stmt) { output("with ("); stmt.variable.visit(this); output(")"); this._visitMaybeBlock(stmt.body); return true; }, visitLabeledStatement: function (stmt) { output(stmt.label).output(": "); }, visitSwitchStatement: function (stmt) { output("switch ("); stmt.expr.visit(this); output(") {").flush().indent(); this._visitArray(stmt.cases, '', '', ''); output("}").unindent().flush(); return true; }, visitSwitchCase: function (stmt) { if ("expr" in stmt) { output("case "); stmt.expr.visit(this); output(": "); } else output("default: "); stmt.body.visit(this); return true; }, visitThrowStatement: function (stmt) { output("throw "); }, postvisitThrowStatement: function (stmt) { output(";").flush(); }, visitTryStatement: function (stmt) { output("try "); this._visitNeedBlock(stmt.body); this._visitArray(stmt.catchers, '', '', '\n' + indentStr); if (stmt.fin) { output("finally "); this._visitNeedBlock(stmt.fin); } return true; }, visitCatchStatement: function (stmt) { output("catch ("); stmt.variable.visit(this); if ("cond" in stmt) { output(" if "); stmt.cond.visit(this); } output(")"); this._visitNeedBlock(stmt.body); return true; }, visitDebuggerStatement: function (stmt) { output("debugger;").flush(); }, visitThisExpression: function (expr) { output("this"); }, visitMemberExpression: function (expr) { let needparen = expr.precedence + 1 < expr.container.precedence; if (needparen) output("("); expr.container.visit(this); if (needparen) output(")"); if ("constmember" in expr && /^[_a-zA-Z]\w*$/.test(expr.constmember)) output(".").output(expr.constmember); else { output("["); expr.member.visit(this); output("]"); } return true; }, visitNewExpression: function (expr) { let needparen = expr.precedence < expr.constructor.precedence; output("new "); if (needparen) output("("); expr.constructor.visit(this); if (needparen) output(")"); this._visitArray(expr.arguments); return true; }, visitCallExpression: function (expr) { let needparen = expr.precedence < expr.func.precedence; if (needparen) output("("); expr.func.visit(this); if (needparen) output(")"); this._visitArray(expr.arguments); return true; }, visitLiteralExpression: function (expr) { switch (expr.objtype) { case "string": output('"').output(sanitize(expr.value, '"')).output('"'); break; case "number": case "boolean": case "regex": output(expr.value.toString()); break; case "null": output("null"); break; default: throw "Unknown literal " + expr.objtype; }; }, visitObjectLiteral: function (obj) { output('{').flush().indent(); this._visitArray(obj.setters, '', '', ',\n' + indentStr); flush().output('}').unindent(); return true; }, visitPropertyLiteral: function (prop) { if ("proptype" in prop) { if (prop.value.type == "LiteralExpression") { prop.property.visit(this); output(" ").output(prop.proptype).output(": "); prop.value.visit(this); return true; } if (prop.proptype == "getter") output("get "); else if (prop.proptype == "setter") output("set "); else throw "Unknown type: " + prop.proptype; prop.property.visit(this); if (prop.value.type != "FunctionDeclaration") throw "Expection function, found: " + prop.value.type; if (prop.value.name) { output(" ").output(prop.value.name); } this._visitArray(prop.value.arguments, '(', ') '); this._visitNeedBlock(prop.value.body, true); return true; } prop.property.visit(this); output(": "); prop.value.visit(this); return true; }, visitArrayLiteral: function (arr) { this._visitArray(arr.members, '[', ']', ', '); return true; }, visitArrayComprehensionExpression: function (arrcomp) { output('['); let enp = arrcomp.element.precedence > 16; if (enp) output("("); arrcomp.element.visit(this); if (enp) output(")"); output(" ").output(arrcomp.itertype).output("("); arrcomp.itervar.visit(this); output(" in "); arrcomp.iterrange.visit(this); output(")"); if ("iterif" in arrcomp) { output(" if ("); arrcomp.iterif.visit(this); output(")"); } output("]"); return true; }, visitIdentifierExpression: function (expr) { output(expr.name); if ("initializer" in expr) { output(" = "); expr.initializer.visit(this); return true; } }, visitPostfixExpression: function (expr) {}, postvisitPostfixExpression: function (expr) { output(expr.operator); }, visitUnaryExpression: function (expr) { if (expr.operator != '()') { output(expr.operator); if (expr.operator.length > 1) output(" "); } let np = expr.precedence < expr.operand.precedence; if (expr.operator == '()' || np) { output("("); expr.operand.visit(this); output(")"); return true; } }, visitBinaryExpression: function (expr) { let lhp = expr.precedence < expr.lhs.precedence; let rhp = expr.precedence < expr.rhs.precedence; if (lhp) output("("); expr.lhs.visit(this); if (lhp) output(")"); output(" ").output(expr.operator).output(" "); if (rhp) output("("); expr.rhs.visit(this); if (rhp) output(")"); return true; }, visitConditionalExpression: function (expr) { let lhp = expr.precedence < expr.cond.precedence; let mhp = expr.precedence < expr.iftrue.precedence; let rhp = expr.precedence < expr.iffalse.precedence; if (lhp) output("("); expr.cond.visit(this); if (lhp) output(")"); output(" ? "); if (mhp) output("("); expr.iftrue.visit(this); if (mhp) output(")"); output(" : "); if (rhp) output("("); expr.iffalse.visit(this); if (rhp) output(")"); return true; }, visitAssignmentExpression: function (expr) { let lhp = expr.precedence < expr.lhs.precedence; let rhp = expr.precedence < expr.rhs.precedence; if (lhp) output("("); expr.lhs.visit(this); if (lhp) output(")"); output(" ").output(expr.operator).output("= "); if (rhp) output("("); expr.rhs.visit(this); if (rhp) output(")"); return true; }, }; /* Reminder */ for (let f in structure) { if (!("visit" + f in visitor)) throw "Please visit " + f; } function process_js(ast) { if (!ast) return; ast = makeAST(ast); walkAST(ast, visitor); } /* Output functions */ let buffer = "", indentStr = ""; function output(str) { buffer += str; return global; } function unwrite(numChars) { buffer = buffer.substring(0, buffer.length - numChars); return global; } function flush() { _print(buffer); buffer = indentStr; return global; } function indent() { indentStr += " "; buffer = " " + buffer; return global; } function unindent() { indentStr = indentStr.substring(2); buffer = buffer.substring(2); return global; } function sanitize(str, q) { function replace(x) { if (x == q) return '\\' + q; if (x == '\\') return '\\\\'; if (x == '\b') return '\\b'; if (x == '\f') return '\\f'; if (x == '\n') return '\\n'; if (x == '\r') return '\\r'; if (x == '\t') return '\\t'; if (x == '\v') return '\\v'; let val = x.charCodeAt(0) if (x < ' ') return '\\x' + (val - val % 16) / 16 + (val % 16); return x; } return [replace(x) for each (x in str)].join(''); } jshydra-master/scripts/doxygen.js000066400000000000000000000047641270515130100175230ustar00rootroot00000000000000// This is a complex script used for producing doxygen-readable input /* The following is a sample doxygen input file: FILE doxygen.js // Documentation for thing 0:0 VARIABLE variable1 // More documentation 1:0 FUNCTION function ARGS a b c // Yet more documentation 25:0 CLASS clazz INHERITS base1 base2 40:2 CLASS VARIABLE clazzvar 41:2 CLASS METHOD clazzfunc ARGS 52:2 CLASS GETTER vara ARGS // Some Constant 101:0 CONSTANT const1 VALUE 10 */ include("../utils/dumpast.js"); include("../utils/cleanast.js"); include("../utils/comments.js"); include("../utils/jstypes.js"); function process_js(ast, f) { _print("FILE " + f); function loc(l) { return l.line + ":" + l.column; } let toplevel = clean_ast(ast); associate_comments(f, toplevel); for each (let v in toplevel.variables) { if (v.comment) _print(v.comment); _print(loc(v.loc) + " VARIABLE " + v.name); } for each (let v in toplevel.constants) { if (v.comment) _print(v.comment); _print(loc(v.loc) + " CONST " + v.name); } for each (let v in toplevel.objects) { divine_inheritance(v, toplevel.constants); if (v.comment) _print(v.comment); let inherits = v.inherits ? (" INHERITS " + v.inherits.join(", ")) : ""; _print(loc(v.loc) + " CLASS " + v.name + inherits); let attrs = { METHOD: v.functions, VARIABLE: v.variables, GETTER: v.getters, SETTER: v.setters }; for (let attr in attrs) { for (let name in attrs[attr]) { if (attrs[attr][name].comment) _print(attrs[attr][name].comment); _print(loc(attrs[attr][name].loc) + " CLASS " + attr + " " + name); } } _print("CLASS END"); } for each (let v in toplevel.classes) { divine_inheritance(v, toplevel.constants); if (v.constructor && v.constructor.comment) _print(v.constructor.comment); if (v.comment) _print(v.comment); let inherits = v.inherits ? (" INHERITS " + v.inherits.join(", ")) : ""; _print(loc(v.loc) + " CLASS " + v.name + inherits); let attrs = { METHOD: v.functions, VARIABLE: v.variables, GETTER: v.getters, SETTER: v.setters }; for (let attr in attrs) { for (let name in attrs[attr]) { if (attrs[attr][name].comment) _print(attrs[attr][name].comment); _print(loc(attrs[attr][name].loc) + " CLASS " + attr + " " + name); } } _print("CLASS END"); } for each (let v in toplevel.functions) { if (v.comment) _print(v.comment); _print(loc(v.loc) + " FUNCTION " + v.name); } } jshydra-master/scripts/dxr.js000066400000000000000000000045401270515130100166330ustar00rootroot00000000000000// This is a simple test to test global magic include("../utils/cleanast.js"); include("../utils/dumpast.js"); include("../utils/jstypes.js"); function process_js(ast, f) { function loc(l) { return f + ":" + l.line + ":" + l.column; } let toplevel = clean_ast(ast); _print("Global variables:"); for each (let v in toplevel.variables) { _print("\t" + v.name + " at " + f + ":" + v.loc.line + ":" + v.loc.column); } _print("Global constants:"); for each (let v in toplevel.constants) { _print("\t" + v.name + " at " + f + ":" + v.loc.line + ":" + v.loc.column); } _print("Global objects:"); for each (let v in toplevel.objects) { divine_inheritance(v, toplevel.constants); _print("\t" + v.name + " at " + f + ":" + v.loc.line + ":" + v.loc.column); if (v.inherits) { _print("\tInherits from " + v.inherits.join(", ")); } _print("\tFunctions:"); for (let name in v.functions) { _print("\t\t" + name + " at " + loc(v.functions[name].loc)); } _print("\tVariables:"); for (let name in v.variables) { _print("\t\t" + name + " at " + loc(v.variables[name].loc)); } _print("\tGetters:"); for (let name in v.getters) { _print("\t\t" + name + " at " + loc(v.getters[name].loc)); } _print("\tSetters:"); for (let name in v.setters) { _print("\t\t" + name + " at " + loc(v.setters[name].loc)); } } _print("Global classes:"); for each (let v in toplevel.classes) { divine_inheritance(v, toplevel.constants); _print("\t" + v.name + " at " + f + ":" + v.loc.line + ":" + v.loc.column); if (v.inherits) { _print("\tInherits from " + v.inherits.join(", ")); } _print("\tFunctions:"); for (let name in v.functions) { _print("\t\t" + name + " at " + loc(v.functions[name].loc)); } _print("\tVariables:"); for (let name in v.variables) { _print("\t\t" + name + " at " + loc(v.variables[name].loc)); } _print("\tGetters:"); for (let name in v.getters) { _print("\t\t" + name + " at " + loc(v.getters[name].loc)); } _print("\tSetters:"); for (let name in v.setters) { _print("\t\t" + name + " at " + loc(v.setters[name].loc)); } } _print("Global functions:"); for each (let v in toplevel.functions) { _print("\t" + v.name + " at " + f + ":" + v.loc.line + ":" + v.loc.column); } } jshydra-master/scripts/findInterfaces.js000066400000000000000000000032651270515130100207650ustar00rootroot00000000000000// This is a simple script to find all interfaces that a JS code uses, at least // via Components.interfaces. include("../utils/cleanast.js"); include("../utils/dumpast.js"); function visit(root_ast, func) { function v_r(ast, func) { if (ast == null) return; func(ast); for each (let child in ast.kids) v_r(child, func); } function sanitize(ast) { if (ast == null) return null; if (ast.op == JSOP_NAME && ast.atom in aliases) { ast = sanitize(aliases[ast.atom]); ast.expanded = true; } let sanitized_ast = { kids: [] }; for (let key in ast) { if (key == 'kids') { for each (let kid in ast.kids) { sanitized_ast.kids.push(sanitize(kid)); } } else { sanitized_ast[key] = ast[key]; } } return sanitized_ast; } v_r(sanitize(root_ast), func); } let filename; function process_js(ast, f) { filename = f; let global = clean_ast(ast); for each (let c in global.constants) { mark_globals(c); } //_print(uneval(aliases)); for each (let v in global.variables) { visit(v.init, find_interfaces); } for each (let statement in global.code) visit(statement, find_interfaces); //_print(uneval(global)); } let aliases = {}; function mark_globals(constant) { aliases[constant.name] = constant.init; } function find_interfaces(ast) { if (ast.op == JSOP_GETPROP && ast.kids[0]) { let check = ast.kids[0]; if (check.atom == "interfaces" && check.kids[0] && check.kids[0].atom == "Components") { _print("Interface " + ast.atom + " used at " + loc2str(ast)); } else if (ast.atom && ast.atom == "nsIMimeStreamConverter") { _print(uneval(ast)); } } } function loc2str(ast) { return filename + ":" + ast.line + ":" + ast.column; } jshydra-master/scripts/outASTML.js000066400000000000000000000001771270515130100174500ustar00rootroot00000000000000include("../utils/astml.js"); function process_js(pn, file) { dump_ast(pn); let ast = makeAST(pn); dump_trueast(ast); } jshydra-master/utils.py000066400000000000000000000033071270515130100155230ustar00rootroot00000000000000# coding: utf-8 # This Source Code is subject to the terms of the Mozilla Public License # version 2.0 (the "License"). You can obtain a copy of the License at # http://mozilla.org/MPL/2.0/. from contextlib import closing import os import platform from StringIO import StringIO import sys import urllib import zipfile JSSHELL_DIR = "mozilla-esr31" JSSHELL_URL = ("https://ftp.mozilla.org/pub/mozilla.org/firefox/nightly" "/2015/02/2015-02-25-00-22-19-%s/jsshell-%%s.zip" % JSSHELL_DIR) JSSHELL_SUPPORTED_PLATFORMS = { "win32": "win32", "linux2": { "i686": "linux-i686", "x86_64": "linux-x86_64" }, "darwin": "mac" } def ensureJSShell(): baseDir = os.path.dirname(__file__) try: build = JSSHELL_SUPPORTED_PLATFORMS[sys.platform] if isinstance(build, dict): build = build[platform.machine()] except KeyError: raise Exception('Platform %s (%s) not supported by JS shell' % ( sys.platform, platform.machine() )) shell_dir = os.path.join(baseDir, JSSHELL_DIR + "-" + build) if not os.path.exists(shell_dir): os.makedirs(shell_dir) if sys.platform == 'win32': path = os.path.join(shell_dir, 'js.exe') else: path = os.path.join(shell_dir, 'js') if os.path.exists(path): return path with closing(urllib.urlopen(JSSHELL_URL % build)) as response: data = response.read() with zipfile.ZipFile(StringIO(data)) as zip: zip.extractall(shell_dir) if not os.path.exists(path): raise Exception('Downloaded package didn\'t contain JS shell executable') try: os.chmod(path, 0700) except: pass return path jshydra-master/utils/000077500000000000000000000000001270515130100151465ustar00rootroot00000000000000jshydra-master/utils/astml.js000066400000000000000000000462511270515130100166340ustar00rootroot00000000000000// Output an JsonML codec for the AST // Explanation of a node: // { // type: The type of the node // location: "line:col-line:col" // } /** * Node formats: * Program * sourceElements: Array of elements (functions, statements) * FunctionDeclaration * name: Name of the function * arguments: Array of arguments * body: Array of elements in function body * VarStatement * variables: Variables being initialized * VarDeclaration * name: Name of variable * initializer: Initial value of variable * CallExpression * func: Name of the function being called * arguments: Array of arguments * IdentifierExpression * name: Name of identifier * LiteralExpression * objtype: "null", "boolean", "numeric", "string", "regex" * value: Value of the literal * BinaryExpression * operator: operator (e.g., '|', '+') + lhs, rhs: left-hand, right-hand expressions for the operator */ include("../utils/dumpast.js"); function makeAST(pn) { let ast = shellNode(pn, "Program"); ast.sourceElements = parseToAst(pn).statements; return ast; } // Broken things: // * Generators (i for (i in foo), not array comp) // * let {a: x, b: y} = baz(); // * let (x = 5, y = 12) {} (really!) // * function ( {a: 1, b: 2} ) // * E4x let structure = { // Program : SourceElement* "Program": [ "sourceElements" ], // SourceElement : FunctionDeclaration | Statement // FunctionDeclaration : function [name] ( Parameter * ) { SourceElement * } "FunctionDeclaration": [ "arguments", "body" ], "Parameter": [ ], // name: Parameter name // Statements "BlockStatement": [ "statements" ], "VarStatement": [ "variables" ], "VarDeclaration": [ "initializer" ], // name: name of variable "LetStatement": [ "variables", "body" ], "EmptyStatement": [], "ExpressionStatement": [ "expr" ], "IfStatement": [ "cond", "body", "elsebody" ], "DoWhileStatement": [ "cond", "body" ], "WhileStatement": [ "cond", "body" ], "ForStatement": [ "init", "cond", "inc", "body" ], "ForInStatement": [ "itervar", "iterrange", "body" ], // itertype: for (each) "ContinueStatement": [ ], // label: label to break to "BreakStatement": [ ], // label: label to break to "ReturnStatement": [ "expr" ], "WithStatement": [ "variable", "body" ], "LabeledStatement": [ "body" ], // label: label of statement "SwitchStatement": [ "expr", "cases" ], "SwitchCase": [ "expr", "body"], // default: no expr "ThrowStatement": [ "expr" ], "TryStatement": [ "body", "catchers", "fin" ], "CatchStatement": [ "variable", "cond", "body" ], "DebuggerStatement": [ ], // Expressions (all have a precedence attribute, 0 (primary) -17) "ThisExpression": [], "LiteralExpression": [], // objtype: typeof literal, value: value "ObjectLiteral": [ "setters" ], "PropertyLiteral": [ "property", "value" ], // proptype: getter, setter, not "ArrayLiteral": [ "members" ], "ArrayComprehensionExpression": [ "element", "itervar", "iterrange", "iterif" ], // itertype "IdentifierExpression": [], // name: name of node "MemberExpression": [ "container", "member"], //constmember if constant "NewExpression": [ "constructor", "arguments" ], "CallExpression": [ "func", "arguments" ], "PostfixExpression": [ "operand" ], // operator // XXX: jorendorff says yield is weird precedence // For now, it's an unary with precedence = 16 "UnaryExpression": [ "operand" ], // operator "BinaryExpression": [ "lhs", "rhs" ], // operator "ConditionalExpression": [ "cond", "iftrue", "iffalse" ], "AssignmentExpression": [ "lhs", "rhs" ], // operator }; function walkAST(ast, visitor) { function astVisitor(node) { let info = structure[node.type]; if (!info) throw "Need to define " + node.type; let cback = "visit" + node.type; let deep = false; if (cback in visitor) deep = visitor[cback](node); if (!deep) { for each (let part in info) { let piece = node[part]; if (piece instanceof Array) { [astVisitor(x) for each (x in piece)]; } else if (piece) { astVisitor(piece); } } } cback = "post" + cback; if (cback in visitor) visitor[cback](node); } astVisitor(ast); } function getLocation(pn) { return pn.line + ":" + pn.column; } function shellNode(pn, type) { function visit(visitor) { return walkAST(this, visitor); } return {type: type, location: getLocation(pn), visit: visit }; } function binaryNode(pn, operator, precedence) { let ast = shellNode(pn, "BinaryExpression"); ast.precedence = precedence; ast.operator = operator; ast.lhs = parseToAst(pn.kids[0]); ast.rhs = parseToAst(pn.kids[1]); for (let i = 2; i < pn.kids.length; i++) { let sup = shellNode(pn.kids[i], "BinaryExpression"); sup.precedence = precedence; sup.operator = operator; sup.lhs = ast; sup.rhs = parseToAst(pn.kids[i]); ast = sup; } return ast; } function parseToAst(pn) { if (!pn) return pn; try { return global["convert" + decode_type(pn.type)](pn); } catch (e if e instanceof TypeError) { dump_ast(pn); throw e; //throw "Unexpected token " + decode_type(pn.type); } } // Nodes that I don't see in output // TOK_ERROR, TOK_EOL, TOK_ELSE, TOK_FINALLY, TOK_SEQ // TOK_XMLSTAGO - TOK_XMLLIST are XML and thus ignored function convertTOK_SEMI(pn) { let ast = shellNode(pn, "ExpressionStatement"); if (pn.kids[0]) ast.expr = parseToAst(pn.kids[0]); else { ast.type = "EmptyStatement"; } return ast; } function convertTOK_COMMA(pn) { if (pn.kids.length == 0) { let ast = shellNode(pn, "EmptyExpression"); ast.precedence = 17; return ast; } else { return binaryNode(pn, ",", 17); } } function convertTOK_ASSIGN(pn) { let ast = shellNode(pn, "AssignmentExpression"); ast.precedence = 16; ast.lhs = parseToAst(pn.kids[0]); ast.rhs = parseToAst(pn.kids[1]); switch (pn.op) { case JSOP_NOP: ast.operator = ''; break; case JSOP_BITOR: ast.operator = '|'; break; case JSOP_BITXOR: ast.operator = '^'; break; case JSOP_BITAND: ast.operator = '&'; break; case JSOP_LSH: ast.operator = '<<'; break; case JSOP_RSH: ast.operator = '>>'; break; case JSOP_URSH: ast.operator = '>>>'; break; case JSOP_ADD: ast.operator = '+'; break; case JSOP_SUB: ast.operator = '-'; break; case JSOP_MUL: ast.operator = '*'; break; case JSOP_DIV: ast.operator = '/'; break; case JSOP_MOD: ast.operator = '%'; break; default: throw "Unexpected operator " + decode_op(pn.op); }; return ast; } function convertTOK_HOOK(pn) { let ast = shellNode(pn, "ConditionalExpression"); ast.precedence = 15; ast.cond = parseToAst(pn.kids[0]); ast.iftrue = parseToAst(pn.kids[1]); ast.iffalse = parseToAst(pn.kids[2]); return ast; } function convertTOK_COLON(pn) { if (pn.kids.length == 1) { let ast = shellNode(pn, "LabeledStatement"); ast.label = pn.atom; ast.body = parseToAst(pn.kids[0]); return ast; } let ast = shellNode(pn, "PropertyLiteral"); ast.property = parseToAst(pn.kids[0]); ast.value = parseToAst(pn.kids[1]); if (pn.op == JSOP_GETTER) ast.proptype = "getter"; else if (pn.op == JSOP_SETTER) ast.proptype = "setter"; return ast; } function convertTOK_OR(pn) { return binaryNode(pn, "||", 14); } function convertTOK_AND(pn) { return binaryNode(pn, "&&", 13); } function convertTOK_BITOR(pn) { return binaryNode(pn, "|", 12); } function convertTOK_BITXOR(pn) { return binaryNode(pn, "^", 11); } function convertTOK_BITAND(pn) { return binaryNode(pn, "&", 10); } function convertTOK_EQOP(pn) { switch (pn.op) { case JSOP_EQ: return binaryNode(pn, "==", 9); case JSOP_NE: return binaryNode(pn, "!=", 9); case JSOP_STRICTEQ: return binaryNode(pn, "===", 9); case JSOP_STRICTNE: return binaryNode(pn, "!==", 9); } throw "Unknown operator: " + decode_op(pn.op); } function convertTOK_RELOP(pn) { switch (pn.op) { case JSOP_LT: return binaryNode(pn, "<", 8); case JSOP_LE: return binaryNode(pn, "<=", 8); case JSOP_GT: return binaryNode(pn, ">", 8); case JSOP_GE: return binaryNode(pn, ">=", 8); } throw "Unknown operator: " + decode_op(pn.op); } function convertTOK_SHOP(pn) { switch (pn.op) { case JSOP_LSH: return binaryNode(pn, "<<", 7); case JSOP_RSH: return binaryNode(pn, ">>", 7); case JSOP_URSH: return binaryNode(pn, ">>>", 7); } throw "Unknown operator: " + decode_op(pn.op); } function convertTOK_PLUS(pn) { return binaryNode(pn, "+", 6); } function convertTOK_MINUS(pn) { return binaryNode(pn, "-", 6); } function convertTOK_STAR(pn) { return binaryNode(pn, "*", 5); } function convertTOK_DIVOP(pn) { switch (pn.op) { case JSOP_MUL: return binaryNode(pn, "*", 5); case JSOP_DIV: return binaryNode(pn, "/", 5); case JSOP_MOD: return binaryNode(pn, "%", 5); } throw "Unknown operator: " + decode_op(pn.op); } function convertTOK_UNARYOP(pn) { let ast = shellNode(pn, "UnaryExpression"); ast.precedence = 4; ast.operand = parseToAst(pn.kids[0]); switch (pn.op) { case JSOP_NEG: ast.operator = "-"; break; case JSOP_POS: ast.operator = "+"; break; case JSOP_NOT: ast.operator = "!"; break; case JSOP_BITNOT: ast.operator = "~"; break; case JSOP_TYPEOF: ast.operator = "typeof"; break; case JSOP_VOID: ast.operator = "void"; break; case JSOP_TYPEOFEXPR: ast.operator = "typeof"; break; default: throw "Unknown operator: " + decode_op(pn.op); } return ast; } function convertTOK_INC(pn) { return convertPrePost(pn, '++'); } function convertTOK_DEC(pn) { return convertPrePost(pn, '--'); } function convertPrePost(pn, op) { let ast = shellNode(pn, "UnaryExpression"); ast.precedence = 3; ast.operator = op; ast.operand = parseToAst(pn.kids[0]); switch (pn.op) { case JSOP_INCNAME: case JSOP_INCPROP: case JSOP_INCELEM: case JSOP_DECNAME: case JSOP_DECPROP: case JSOP_DECELEM: /*ast.type = "PrefixExpression";*/ break; case JSOP_NAMEINC: case JSOP_PROPINC: case JSOP_ELEMINC: case JSOP_NAMEDEC: case JSOP_PROPDEC: case JSOP_ELEMDEC: ast.type = "PostfixExpression"; break; default: throw "Unknown operator: " + decode_op(pn.op); } return ast; } function convertTOK_DOT(pn) { let ast = shellNode(pn, "MemberExpression"); ast.precedence = 1; ast.container = parseToAst(pn.kids[0]); ast.member = shellNode(pn, "LiteralExpression"); ast.member.objtype = "string"; ast.member.value = pn.atom; ast.constmember = pn.atom; return ast; } function convertTOK_LB(pn) { let ast = shellNode(pn, "MemberExpression"); ast.precedence = 1; ast.container = parseToAst(pn.kids[0]); ast.member = parseToAst(pn.kids[1]); return ast; } function convertTOK_RB(pn) { let ast = shellNode(pn, "ArrayLiteral"); ast.precedence = 0; ast.members = [parseToAst(x) for each (x in pn.kids)]; return ast; } /* Returns a list */ function convertTOK_LC(pn) { let ast = shellNode(pn, "BlockStatement"); ast.statements = [parseToAst(x) for each (x in pn.kids)]; if (ast.statements.length == 0) { return shellNode(pn, "EmptyStatement"); } return ast; } function convertTOK_RC(pn) { let ast = shellNode(pn, "ObjectLiteral"); ast.setters = [parseToAst(x) for each (x in pn.kids)]; return ast; } function convertTOK_LP(pn) { if (pn.op != JSOP_CALL && pn.op != JSOP_APPLY) { let ast = shellNode(pn, "LetStatement"); ast.variables = [parseToAst(x) for each (x in pn.kids)]; return ast; } let ast = shellNode(pn, "CallExpression"); ast.precedence = 2; ast.func = parseToAst(pn.kids[0]); ast.arguments = []; for (let i = 1; i < pn.kids.length; i++) ast.arguments[i - 1] = parseToAst(pn.kids[i]); return ast; } function convertTOK_RP(pn) { let ast = shellNode(pn, "UnaryExpression"); ast.precedence = 2; ast.operand = parseToAst(pn.kids[0]); ast.operator = "()"; return ast; } function convertTOK_NAME(pn) { let ast = shellNode(pn, "IdentifierExpression"); ast.precedence = 0; ast.name = pn.atom; if (pn.kids.length > 0 && pn.kids[0]) { ast.initializer = parseToAst(pn.kids[0]); } return ast; } function convertTOK_NUMBER(pn) { let ast = shellNode(pn, "LiteralExpression"); ast.precedence = 0; ast.objtype = "number"; ast.value = pn.value; return ast; } function convertTOK_STRING(pn) { let ast = shellNode(pn, "LiteralExpression"); ast.precedence = 0; ast.objtype = "string"; ast.value = pn.atom; return ast; } function convertTOK_REGEXP(pn) { let ast = shellNode(pn, "LiteralExpression"); ast.precedence = 0; ast.objtype = "regex"; ast.value = pn.value; return ast; } function convertTOK_PRIMARY(pn) { let ast = shellNode(pn, "LiteralExpression"); ast.precedence = 0; switch (pn.op) { case JSOP_ZERO: ast.objtype = "number"; ast.value = 0; break; case JSOP_ONE: ast.objtype = "number"; ast.value = 1; break; case JSOP_NULL: ast.objtype = "null"; ast.value = null; break; case JSOP_FALSE: ast.objtype = "boolean"; ast.value = false; break; case JSOP_TRUE: ast.objtype = "boolean"; ast.value = true; break; case JSOP_THIS: return shellNode(pn, "ThisExpression"); default: throw "Unknown operand: " + decode_op(pn.op); } return ast; } function convertTOK_FUNCTION(pn) { let ast = shellNode(pn, "FunctionDeclaration"); // Precedence needs to be highest -> always wrapped ast.precedence = 1.0 / 0.0; ast.name = pn.name; if (pn.kids[0].type == TOK_UPVARS) pn = pn.kids[0]; let args = []; if (pn.kids[0].type == TOK_ARGSBODY) { pn = pn.kids[0]; while (pn.kids.length > 1) { let argNode = parseToAst(pn.kids.shift()); argNode.type = "Parameter"; args.push(argNode); } } ast.arguments = args; ast.body = parseToAst(pn.kids[0]); return ast; } function convertTOK_IF(pn) { let ast = shellNode(pn, "IfStatement"); ast.cond = parseToAst(pn.kids[0]); ast.body = parseToAst(pn.kids[1]); if (pn.kids[1]) ast.elsebody = parseToAst(pn.kids[2]); return ast; } function convertTOK_SWITCH(pn) { let ast = shellNode(pn, "SwitchStatement"); ast.expr = parseToAst(pn.kids[0]); let rhs = parseToAst(pn.kids[1]); if (rhs instanceof Array) ast.cases = rhs; else ast.cases = rhs.statements; return ast; } function convertTOK_CASE(pn) { let ast = shellNode(pn, "SwitchCase"); ast.expr = parseToAst(pn.kids[0]); ast.body = parseToAst(pn.kids[1]); return ast; } function convertTOK_DEFAULT(pn) { let ast = shellNode(pn, "SwitchCase"); ast.body = parseToAst(pn.kids[1]); return ast; } function convertTOK_WHILE(pn) { let ast = shellNode(pn, "WhileStatement"); ast.cond = parseToAst(pn.kids[0]); ast.body = parseToAst(pn.kids[1]); return ast; } function convertTOK_DO(pn) { let ast = shellNode(pn, "DoWhileStatement"); ast.body = parseToAst(pn.kids[0]); ast.cond = parseToAst(pn.kids[1]); return ast; } function convertTOK_FOR(pn) { let ast = shellNode(pn, "ForStatement"); let expr = parseToAst(pn.kids[0]); if (expr.type == "Forehead") { ast.init = expr.init; ast.cond = expr.condition; ast.inc = expr.increment; } else { ast.type = "ForInStatement"; ast.itervar = expr.lhs; ast.iterrange = expr.rhs; ast.itertype = (pn.iflags & 0x2 ? "for each" : "for"); } ast.body = parseToAst(pn.kids[1]); return ast; } function convertTOK_BREAK(pn) { let ast = shellNode(pn, "BreakStatement"); if (pn.atom) ast.label = pn.atom; return ast; } function convertTOK_CONTINUE(pn) { let ast = shellNode(pn, "ContinueStatement"); if (pn.atom) ast.label = pn.atom; return ast; } function convertTOK_IN(pn) { return binaryNode(pn, "in", 8); } function convertTOK_VAR(pn) { let ast = shellNode(pn, "VarStatement"); if (pn.op == JSOP_DEFCONST) ast.vartype = "const"; else ast.vartype = "var"; ast.variables = [parseToAst(x) for each (x in pn.kids)]; for each (let x in ast.variables) { if (x.type == "LetStatement") return x; if (x.type == "IdentifierExpression") x.type = "VarDeclaration"; } return ast; } function convertTOK_WITH(pn) { let ast = shellNode(pn, "WithStatement"); ast.variable = parseToAst(pn.kids[0]); ast.body = parseToAst(pn.kids[1]); return ast; } function convertTOK_RETURN(pn) { let ast = shellNode(pn, "ReturnStatement"); ast.expr = parseToAst(pn.kids[0]); return ast; } function convertTOK_NEW(pn) { let ast = shellNode(pn, "NewExpression"); ast.precedence = 1; ast.constructor = parseToAst(pn.kids[0]); ast.arguments = []; for (let i = 1; i < pn.kids.length; i++) ast.arguments.push(parseToAst(pn.kids[i])); return ast; } function convertTOK_DELETE(pn) { let ast = shellNode(pn, "UnaryExpression"); ast.precedence = 4; ast.operator = "delete"; ast.operand = parseToAst(pn.kids[0]); return ast; } function convertTOK_DEFSHARP(pn) { let ast = shellNode(pn, "SharpDefinitionExpression"); ast.expr = parseToAst(pn.kids[0]); ast.sharpnum = pn.number; return ast; } function convertTOK_USESHARP(pn) { let ast = shellNode(pn, "SharpExpression"); ast.sharpnum = pn.number; return ast; } function convertTOK_TRY(pn) { let ast = shellNode(pn, "TryStatement"); ast.body = parseToAst(pn.kids[0]); if (pn.kids[1]) ast.catchers = parseToAst(pn.kids[1]); else ast.catchers = []; if (pn.kids[2]) ast.fin = parseToAst(pn.kids[2]); return ast; } function convertTOK_CATCH(pn) { let ast = shellNode(pn, "CatchStatement"); ast.variable = parseToAst(pn.kids[0]); if (pn.kids[1]) ast.cond = parseToAst(pn.kids[1]); ast.body = parseToAst(pn.kids[2]); return ast; } function convertTOK_THROW(pn) { let ast = shellNode(pn, "ThrowStatement"); ast.expr = parseToAst(pn.kids[0]); return ast; } function convertTOK_INSTANCEOF(pn) { return binaryNode(pn, "instanceof", 8); } function convertTOK_DEBUGGER(pn) { return shellNode(pn, "DebuggerStatement"); } // XML OPS function convertTOK_YIELD(pn) { let ast = shellNode(pn, "UnaryExpression"); ast.operand = parseToAst(pn.kids[0]); ast.precedence = 16; ast.operator = "yield"; return ast; } function convertTOK_ARRAYCOMP(pn) { let ast = parseToAst(pn.kids[0]); ast.precedence = 0; ast.type = "ArrayComprehensionExpression"; if ("expr" in ast.body) ast.element = ast.body.expr; else { ast.element = ast.body.body.expr; ast.iterif = ast.body.cond; } delete ast.body; return ast; } function convertTOK_ARRAYPUSH(pn) { let ast = shellNode(pn, "ArrayPush"); ast.expr = parseToAst(pn.kids[0]); return ast; } function convertTOK_LEXICALSCOPE(pn) { return parseToAst(pn.kids[0]); } function convertTOK_LET(pn) { let ast = convertTOK_VAR(pn); if (ast.type == "VarStatement") ast.vartype = "let"; return ast; } function convertTOK_FORHEAD(pn) { let ast = shellNode(pn, "Forehead"); ast.init = pn.kids[0] ? parseToAst(pn.kids[0]) : shellNode(pn, "EmptyStatement"); ast.condition = pn.kids[1] ? parseToAst(pn.kids[1]) : shellNode(pn, "EmptyStatement"); ast.increment = pn.kids[2] ? parseToAst(pn.kids[2]) : shellNode(pn, "EmptyStatement"); return ast; } function convertTOK_RESERVED(pn) { return [parseToAst(x) for each (x in pn.kids)]; } jshydra-master/utils/beautify.js000066400000000000000000001347441270515130100173310ustar00rootroot00000000000000/*jslint onevar: false, plusplus: false */ /*jshint curly:true, eqeqeq:true, laxbreak:true, noempty:false */ /* JS Beautifier --------------- Written by Einar Lielmanis, http://jsbeautifier.org/ Originally converted to javascript by Vital, "End braces on own line" added by Chris J. Shull, 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) === '') { 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; } jshydra-master/utils/cleanast.js000066400000000000000000000156451270515130100173110ustar00rootroot00000000000000/** * A brief description of some nodes. * * Scope block information: * variables (Variable[]): a list of variables declared in the block * functions (Function[]): a list of functions declared in the block * constants (Variable[]): a list of constants declared in the block * classes (Class[]): a list of classes declared in the block * objects (Class[]): a list of objects declared in the block * code (Statement[]): a list of statements in the block */ /** * Takes the node rooted at the AST and decomposes it into readable sections. */ function clean_ast(ast) { assert(ast.type == TOK_LC); let info = { variables: [], constants: [], objects: [], classes: [], functions: [], code: [] }; for each (let statement in ast.kids) { if (statement.op == JSOP_DEFVAR) { let ret = make_variables(statement); info.variables = info.variables.concat(ret.vars); info.objects = info.objects.concat(ret.objs); } else if (statement.op == JSOP_DEFCONST) { let ret = make_variables(statement); info.constants = info.constants.concat(ret.vars); info.objects = info.objects.concat(ret.objs); } else if (statement.type == TOK_FUNCTION) { info.functions.push(make_function(statement)); } else if (prototype_assign(statement)) { let obj = make_class(statement); merge_class(info, obj); } else { info.code.push(statement); } } return info; } /** * Visits the AST using the given function as a parameter. * The parameter will take in a single argument, the AST node. */ function visit(root_ast, func, to_expand) { function v_r(ast, func) { if (ast == null) return; if (func(ast)) return; for each (let child in ast.kids) v_r(child, func); } function sanitize(ast) { if (ast == null) return null; if (ast.op == JSOP_NAME && ast.atom in to_expand) { ast = sanitize(to_expand[ast.atom]); ast.expanded = true; } let sanitized_ast = { kids: [] }; for (let key in ast) { if (key == 'kids') { for each (let kid in ast.kids) { sanitized_ast.kids.push(sanitize(kid)); } } else { sanitized_ast[key] = ast[key]; } } return sanitized_ast; } if (to_expand) v_r(sanitize(root_ast), func); else v_r(root_ast, func); } function prototype_assign(statement) { if (statement.type != TOK_SEMI || !statement.kids[0]) return false; statement = statement.kids[0]; if (statement.type != TOK_ASSIGN || !statement.kids[0]) return false; statement = statement.kids[0]; // Statement is either prototype or a property of prototype if (statement.op != JSOP_SETPROP) return false; if (statement.atom == "prototype") return true; if (statement.kids[0] && statement.kids[0] == "prototype") return true; // Or not! return false; } function make_class(class_root) { let clazz = {}; class_root = class_root.kids[0]; let lhs = class_root.kids[0], rhs = class_root.kids[1]; if (lhs.atom == "prototype") { clazz.init = rhs; clazz = make_object(clazz); } else { clazz.functions = {}; clazz.functions[lhs.atom] = make_function(rhs); lhs = lhs.kids[0]; } clazz.name = lhs.kids[0].atom; return clazz; } function merge_class(info_list, obj) { let name = obj.name; for (let i = 0; i < info_list.functions.length; i++) { if (info_list.functions[i].name == name) { obj.constructor = info_list.functions[i]; // remove the constructor from the list of global functions info_list.functions.splice(i, 1); break; } } if (obj.constructor) obj.loc = obj.constructor.loc; let oldObj = null; for (let i = 0; i < info_list.classes.length; i++) { if (info_list.classes[i].name == name) { oldObj = info_list.classes[i]; break; } } if (oldObj) { for (let prop in obj) { if (!(prop in oldObj)) { oldObj[prop] = obj[prop]; } else if (typeof obj[prop] == "object") { for (let item in obj[prop]) oldObj[prop][item] = obj[prop][item]; } } } else { info_list.classes = info_list.classes.concat(obj); } } function make_variables(var_root) { assert(var_root.op == JSOP_DEFVAR || var_root.op == JSOP_DEFCONST); let variables = []; let objects = []; for each (let name in var_root.kids) { let v = { name: name.atom }; v.init = (name.kids.length > 0 ? name.kids[0] : null); v.loc = get_location(var_root); if (v.init && v.init.op == JSOP_NEWINIT && v.init.kids[0] && v.init.kids[0].type == TOK_COLON) objects.push(make_object(v)); else variables.push(v); } return { vars: variables, objs: objects }; } function make_object(stub) { stub.variables = {}; stub.functions = {}; stub.getters = {}; stub.setters = {}; let ast = stub.init; let proto = stub.init.op == JSOP_GETPROP && stub.init.atom == 'prototype'; delete stub['init']; if (proto) { stub.inherits = [ast.kids[0].atom]; return stub; } for each (let init in ast.kids) { if (init.type != TOK_COLON) { dump_ast(init); } assert(init.type == TOK_COLON); if (init.kids[0].type == TOK_NAME) { let name = init.kids[0].atom; let value = init.kids[1]; if (init.op == JSOP_GETTER) stub.getters[name] = make_function(value); else if (init.op == JSOP_SETTER) stub.setters[name] = make_function(value); else if (value.type == TOK_FUNCTION) stub.functions[name] = make_function(value); else if (name == '__proto__') { let supername; if (value.op == JSOP_NEW) supername = value.kids[0].atom; else if (value.op == JSOP_GETPROP && value.atom == 'prototype') supername = value.kids[0].atom; else assert(false); if ('inherits' in stub) stub.inherits.push(supoername); else stub.inherits = [supername]; } else stub.variables[name] = { loc: get_location(value), init: value }; } else { dump_ast(init); } } return stub; } function make_function(func_root) { assert(func_root.type == TOK_FUNCTION); let stmts = func_root.kids[0]; if (stmts.type == TOK_UPVARS) stmts = stmts.kids[0]; if (stmts.type == TOK_ARGSBODY) stmts = stmts.kids[stmts.kids.length - 1]; if (stmts.type == TOK_RETURN) { // This is a lambda function. For simplicity's sake, I'm going to turn this // into a regular function by wrapping with TOK_LC (consumers of functions // will find this easier to use) let newtop = { fakeNode: true, line: stmts.line, col: stmts.col, type: TOK_LC, op: JSOP_NOP, kids: [stmts]}; stmts = newtop; } assert(stmts.type == TOK_LC); return { name: func_root.name, body: stmts, loc: get_location(func_root)}; } function assert(cmd) { if (!cmd) { throw new Error("Assertion failed"); } } function get_location(ast_node) { return { line: ast_node.line, column: ast_node.column }; } jshydra-master/utils/comments.js000066400000000000000000000056121270515130100173350ustar00rootroot00000000000000/** * This processes comments. */ function associate_comments(filename, scopeObject) { // Read the script and give us line stuff let file = read_file(filename).split(/\r\n|[\r\n]/); // make file 1-based to avoid off-by-one errors... file.unshift(""); // Now, get us a sorted list of all important AST locations let locations = [{loc: {line: 0, column: -1}}]; function add_func(func) { locations.push({loc: func.loc, obj: func, commentWanted: true}); // The following will get us to the last line of the function if (func.body.kids.length == 0) return; let last = func.body.kids[func.body.kids.length - 1]; while (last.kids[last.kids.length - 1] && last.kids[last.kids.length - 1].line > last.line) last = last.kids[last.kids.length - 1]; locations.push({loc: {line: last.line, column: last.column}}); } for each (let v in scopeObject.variables) locations.push({loc: v.loc, obj: v, commentWanted: true}); for each (let v in scopeObject.constants) locations.push({loc: v.loc, obj: v, commentWanted: true}); for each (let v in scopeObject.functions) add_func(v); for each (let v in scopeObject.code) locations.push({loc: {line: v.line, column: v.column}, obj: v}); for each (let o in scopeObject.objects) { locations.push({loc: o.loc, obj: o, commentWanted: true}); for each (let x in o.variables) locations.push({loc: x.loc, obj: x, commentWanted: true}); for each (let x in o.functions) add_func(x); for each (let x in o.getters) add_func(x); for each (let x in o.setters) add_func(x); } for each (let o in scopeObject.classes) { locations.push({loc: o.loc, obj: o, commentWanted: true}); for each (let x in o.variables) locations.push({loc: x.loc, obj: x, commentWanted: true}); for each (let x in o.functions) add_func(x); for each (let x in o.getters) add_func(x); for each (let x in o.setters) add_func(x); } locations.sort(function (a, b) { if (a.loc.line == b.loc.line) return a.loc.column - b.loc.column; return a.loc.line - b.loc.line; }); // With that list done, let's find comments in the range. for (let i = 1; i < locations.length; i++) { if (!locations[i].commentWanted) continue; let comment = find_comments(locations[i - 1].loc, locations[i].loc, file); if (comment) locations[i].obj.comment = comment; } } let comment_regex = /\/\*[\s\S]*?\*\/|\/\/.*?\n/mg; function find_comments(start, end, file) { let lines = []; lines[0] = file[start.line].substring(start.column + 1).trim(); for (let l = start.line + 1; l < end.line; l++) { lines.push(file[l].trim()); } lines.push(file[end.line].substring(0, end.column).trim()); let goop = lines.join("\n"); let match; lines = []; while ((match = comment_regex.exec(goop)) != null) { lines.push(match); } return lines.join("\n"); } jshydra-master/utils/dumpast.js000066400000000000000000000034721270515130100171670ustar00rootroot00000000000000/** * Dumps the tree of the ast rooted at the given point. */ function dump_ast(ast, prefix) { if (ast == null) return; if (!prefix) prefix = ""; let str = prefix + "+ "; for (let key in ast) { if (key == 'column' || key == 'line' || key == 'kids') continue; let val = (key == 'op' ? decode_op(ast[key]) : key == 'type' ? decode_type(ast[key]) : key == 'flags' ? ('0x' + ast[key].toString(16)) : ast[key]); str += key + ": " + val + "; "; } str += ast.line + ":" + ast.column; _print(str); prefix += " "; for each (let kid in ast.kids) { dump_ast(kid, prefix); } } var global = this; var optable = null, toktable; function decode_op(opcode) { if (!optable) { optable = []; for (let key in global) { if (key.indexOf("JSOP_") == 0) { optable[global[key]] = key; } } } if (opcode in optable) return optable[opcode]; return opcode; } function decode_type(opcode) { if (!toktable) { toktable = []; for (let key in global) { if (key.indexOf("TOK_") == 0) { toktable[global[key]] = key; } } } if (opcode in toktable) return toktable[opcode]; return opcode; } function dump_trueast(ast, prefix) { if (ast == null) return; if (!prefix) prefix = ""; let str = prefix + "+ "; _print(prefix + ast.type + " @ " + ast.location + ":"); for (let key in ast) { if (key == 'type' || key == 'location' || key == 'visit') continue; let val = ast[key]; if (val instanceof Array) { _print(prefix + " + " + key + ": ["); for each (let kind in val) { dump_trueast(kind, prefix + " "); } _print(prefix + " ]"); } else if (val instanceof Object && "type" in val) { _print(prefix + " + " + key + ":"); dump_trueast(val, prefix + " "); } else { _print(prefix + " + " + key + ": " + val); } } } jshydra-master/utils/jstypes.js000066400000000000000000000022311270515130100172030ustar00rootroot00000000000000/** * This file presents various methods to create a JS typing system. */ function divine_inheritance(clazz, constants) { let aliases = {}; for each (let c in constants) { aliases[c.name] = c.init; } // First, do we have a QueryInterface variable? if ("QueryInterface" in clazz.variables) { // Yes, it's a function, but the variable means that we found a XPCOMUtils // utility. This'll be easy! let xpcom = clazz.variables.QueryInterface.init; assert(xpcom.op == JSOP_CALL && xpcom.kids[0].atom == "generateQI"); if (!clazz.inherits) clazz.inherits = []; for each (let iface in xpcom.kids[1].kids) clazz.inherits.push(iface.atom); return; } if ("QueryInterface" in clazz.functions) { if (!clazz.inherits) clazz.inherits = []; function findInterfaces(ast) { if (ast.op == JSOP_GETPROP && ast.kids[0]) { let check = ast.kids[0]; if (check.atom == "interfaces" && check.kids[0] && check.kids[0].atom == "Components") { clazz.inherits.push(ast.atom); } } } visit(clazz.functions.QueryInterface.body, findInterfaces, aliases); return; } }