import * as acorn from "acorn"; /** * @license * JavaScript Interpreter * * Copyright 2013 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * @fileoverview Interpreting JavaScript in JavaScript. * @author fraser@google.com (Neil Fraser) */ 'use strict'; /** * Create a new interpreter. * @param {string|!Object} code Raw JavaScript text or AST. * @param {Function=} opt_initFunc Optional initialization function. Used to * define APIs. When called it is passed the interpreter object and the * global scope object. * @param {Number} Bitburner-specific number used for determining exception line numbers * @constructor */ var Interpreter = function(code, opt_initFunc, lineOffset=0) { this.sourceCode = code; this.sourceCodeLineOffset = lineOffset; if (typeof code === 'string') { code = acorn.parse(code, Interpreter.PARSE_OPTIONS); } this.ast = code; this.initFunc_ = opt_initFunc; this.paused_ = false; this.polyfills_ = []; // Unique identifier for native functions. Used in serialization. this.functionCounter_ = 0; // Map node types to our step function names; a property lookup is faster // than string concatenation with "step" prefix. this.stepFunctions_ = Object.create(null); var stepMatch = /^step([A-Z]\w*)$/; var m; for (var methodName in this) { if ((typeof this[methodName] === 'function') && (m = methodName.match(stepMatch))) { this.stepFunctions_[m[1]] = this[methodName].bind(this); } } // Create and initialize the global scope. this.global = this.createScope(this.ast, null); // Run the polyfills. this.ast = acorn.parse(this.polyfills_.join('\n'), Interpreter.PARSE_OPTIONS); this.polyfills_ = undefined; // Allow polyfill strings to garbage collect. this.stripLocations_(this.ast, undefined, undefined); var state = new Interpreter.State(this.ast, this.global); state.done = false; this.stateStack = [state]; this.run(); this.value = undefined; // Point at the main program. this.ast = code; var state = new Interpreter.State(this.ast, this.global); state.done = false; this.stateStack.length = 0; this.stateStack[0] = state; // Get a handle on Acorn's node_t object. It's tricky to access. this.nodeConstructor = state.node.constructor; // Preserve publicly properties from being pruned/renamed by JS compilers. // Add others as needed. this['stateStack'] = this.stateStack; }; /** * @const {!Object} Configuration used for all Acorn parsing. */ Interpreter.PARSE_OPTIONS = { ecmaVersion: 5, locations: true }; /** * Property descriptor of readonly properties. */ Interpreter.READONLY_DESCRIPTOR = { configurable: true, enumerable: true, writable: false }; /** * Property descriptor of non-enumerable properties. */ Interpreter.NONENUMERABLE_DESCRIPTOR = { configurable: true, enumerable: false, writable: true }; /** * Property descriptor of readonly, non-enumerable properties. */ Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR = { configurable: true, enumerable: false, writable: false }; /** * Property descriptor of variables. */ Interpreter.VARIABLE_DESCRIPTOR = { configurable: false, enumerable: true, writable: true }; /** * Unique symbol for indicating that a step has encountered an error, has * added it to the stack, and will be thrown within the user's program. * When STEP_ERROR is thrown in the JS-Interpreter, the error can be ignored. */ Interpreter.STEP_ERROR = {}; /** * Unique symbol for indicating that a reference is a variable on the scope, * not an object property. */ Interpreter.SCOPE_REFERENCE = {}; /** * Unique symbol for indicating, when used as the value of the value * parameter in calls to setProperty and friends, that the value * should be taken from the property descriptor instead. */ Interpreter.VALUE_IN_DESCRIPTOR = {}; /** * For cycle detection in array to string and error conversion; * see spec bug github.com/tc39/ecma262/issues/289 * Since this is for atomic actions only, it can be a class property. */ Interpreter.toStringCycles_ = []; /** * Determine error/exception line number in Bitburner source code * @param {Object} AST Node that causes Error/Exception */ Interpreter.prototype.getErrorLineNumber = function(node) { var code = this.sourceCode; if (node == null || node.start == null) {return NaN;} try { code = code.substring(0, node.start); return (code.match(/\n/g) || []).length + 1 - this.sourceCodeLineOffset; } catch(e) { return NaN; } } /** * Generate the appropriate line number error message for Bitburner * @param {Number} lineNumber */ Interpreter.prototype.getErrorLineNumberMessage = function(lineNumber) { if (isNaN(lineNumber)) { return " (Unknown line number)"; } else if (lineNumber <= 0) { return " (Error occurred in an imported function)"; } else { return " (Line Number " + lineNumber + ". This line number is probably incorrect " + "if your script is importing any functions. This is being worked on)"; } } /** * Add more code to the interpreter. * @param {string|!Object} code Raw JavaScript text or AST. */ Interpreter.prototype.appendCode = function(code) { var state = this.stateStack[0]; if (!state || state.node['type'] !== 'Program') { throw Error('Expecting original AST to start with a Program node.'); } if (typeof code === 'string') { code = acorn.parse(code, Interpreter.PARSE_OPTIONS); } if (!code || code['type'] !== 'Program') { throw Error('Expecting new AST to start with a Program node.'); } this.populateScope_(code, state.scope); // Append the new program to the old one. for (var i = 0, node; (node = code['body'][i]); i++) { state.node['body'].push(node); } state.done = false; }; /** * Execute one step of the interpreter. * @return {boolean} True if a step was executed, false if no more instructions. */ Interpreter.prototype.step = function() { var stack = this.stateStack; var state = stack[stack.length - 1]; if (!state) { return false; } var node = state.node, type = node['type']; if (type === 'Program' && state.done) { return false; } else if (this.paused_) { return true; } try { var nextState = this.stepFunctions_[type](stack, state, node); } catch (e) { // Eat any step errors. They have been thrown on the stack. if (e !== Interpreter.STEP_ERROR) { // Uh oh. This is a real error in the JS-Interpreter. Rethrow. throw e; } } if (nextState) { stack.push(nextState); } if (!node['end']) { // This is polyfill code. Keep executing until we arrive at user code. return this.step(); } return true; }; /** * Execute the interpreter to program completion. Vulnerable to infinite loops. * @return {boolean} True if a execution is asynchronously blocked, * false if no more instructions. */ Interpreter.prototype.run = function() { while (!this.paused_ && this.step()) {} return this.paused_; }; /** * Initialize the global scope with buitin properties and functions. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initGlobalScope = function(scope) { // Initialize uneditable global properties. this.setProperty(scope, 'NaN', NaN, Interpreter.READONLY_DESCRIPTOR); this.setProperty(scope, 'Infinity', Infinity, Interpreter.READONLY_DESCRIPTOR); this.setProperty(scope, 'undefined', undefined, Interpreter.READONLY_DESCRIPTOR); this.setProperty(scope, 'window', scope, Interpreter.READONLY_DESCRIPTOR); this.setProperty(scope, 'this', scope, Interpreter.READONLY_DESCRIPTOR); this.setProperty(scope, 'self', scope); // Editable. // Create the objects which will become Object.prototype and // Function.prototype, which are needed to bootstrap everything else. this.OBJECT_PROTO = new Interpreter.Object(null); this.FUNCTION_PROTO = new Interpreter.Object(this.OBJECT_PROTO); // Initialize global objects. this.initFunction(scope); this.initObject(scope); // Unable to set scope's parent prior (OBJECT did not exist). // Note that in a browser this would be 'Window', whereas in Node.js it would // be 'Object'. This interpreter is closer to Node in that it has no DOM. scope.proto = this.OBJECT_PROTO; this.setProperty(scope, 'constructor', this.OBJECT, Interpreter.NONENUMERABLE_DESCRIPTOR); this.initArray(scope); this.initString(scope); this.initBoolean(scope); this.initNumber(scope); this.initDate(scope); this.initRegExp(scope); this.initError(scope); this.initMath(scope); this.initJSON(scope); // Initialize global functions. var thisInterpreter = this; var func = this.createNativeFunction( function(x) {throw EvalError("Can't happen");}, false); func.eval = true; this.setProperty(scope, 'eval', func); this.setProperty(scope, 'parseInt', this.createNativeFunction(parseInt, false)); this.setProperty(scope, 'parseFloat', this.createNativeFunction(parseFloat, false)); this.setProperty(scope, 'isNaN', this.createNativeFunction(isNaN, false)); this.setProperty(scope, 'isFinite', this.createNativeFunction(isFinite, false)); var strFunctions = [ [escape, 'escape'], [unescape, 'unescape'], [decodeURI, 'decodeURI'], [decodeURIComponent, 'decodeURIComponent'], [encodeURI, 'encodeURI'], [encodeURIComponent, 'encodeURIComponent'] ]; for (var i = 0; i < strFunctions.length; i++) { var wrapper = (function(nativeFunc) { return function(str) { try { return nativeFunc(str); } catch (e) { // decodeURI('%xy') will throw an error. Catch and rethrow. thisInterpreter.throwException(thisInterpreter.URI_ERROR, e.message); } }; })(strFunctions[i][0]); this.setProperty(scope, strFunctions[i][1], this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); } // Preserve publicly properties from being pruned/renamed by JS compilers. // Add others as needed. this['OBJECT'] = this.OBJECT; this['OBJECT_PROTO'] = this.OBJECT_PROTO; this['FUNCTION'] = this.FUNCTION; this['FUNCTION_PROTO'] = this.FUNCTION_PROTO; this['ARRAY'] = this.ARRAY; this['ARRAY_PROTO'] = this.ARRAY_PROTO; this['REGEXP'] = this.REGEXP; this['REGEXP_PROTO'] = this.REGEXP_PROTO; this['DATE'] = this.DATE; this['DATE_PROTO'] = this.DATE_PROTO; // The following properties are obsolete. Do not use. this['UNDEFINED'] = undefined; this['NULL'] = null; this['NAN'] = NaN; this['TRUE'] = true; this['FALSE'] = false; this['STRING_EMPTY'] = ''; this['NUMBER_ZERO'] = 0; this['NUMBER_ONE'] = 1; // Run any user-provided initialization. if (this.initFunc_) { this.initFunc_(this, scope); } }; /** * Initialize the Function class. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initFunction = function(scope) { var thisInterpreter = this; var wrapper; var identifierRegexp = /^[A-Za-z_$][\w$]*$/; // Function constructor. wrapper = function(var_args) { if (thisInterpreter.calledWithNew()) { // Called as new Function(). var newFunc = this; } else { // Called as Function(). var newFunc = thisInterpreter.createObjectProto(thisInterpreter.FUNCTION_PROTO); } if (arguments.length) { var code = String(arguments[arguments.length - 1]); } else { var code = ''; } var argsStr = Array.prototype.slice.call(arguments, 0, -1).join(',').trim(); if (argsStr) { var args = argsStr.split(/\s*,\s*/); for (var i = 0; i < args.length; i++) { var name = args[i]; if (!identifierRegexp.test(name)) { thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, 'Invalid function argument: ' + name); } } argsStr = args.join(', '); } // Interestingly, the scope for constructed functions is the global scope, // even if they were constructed in some other scope. newFunc.parentScope = thisInterpreter.global; // Acorn needs to parse code in the context of a function or else 'return' // statements will be syntax errors. try { var ast = acorn.parse('(function(' + argsStr + ') {' + code + '})', Interpreter.PARSE_OPTIONS); } catch (e) { // Acorn threw a SyntaxError. Rethrow as a trappable error. thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, 'Invalid code: ' + e.message); } if (ast['body'].length !== 1) { // Function('a', 'return a + 6;}; {alert(1);'); thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, 'Invalid code in function body.'); } newFunc.node = ast['body'][0]['expression']; thisInterpreter.setProperty(newFunc, 'length', newFunc.node['length'], Interpreter.READONLY_DESCRIPTOR); return newFunc; }; wrapper.id = this.functionCounter_++; this.FUNCTION = this.createObjectProto(this.FUNCTION_PROTO); this.setProperty(scope, 'Function', this.FUNCTION); // Manually setup type and prototype because createObj doesn't recognize // this object as a function (this.FUNCTION did not exist). this.setProperty(this.FUNCTION, 'prototype', this.FUNCTION_PROTO); this.FUNCTION.nativeFunc = wrapper; // Configure Function.prototype. this.setProperty(this.FUNCTION_PROTO, 'constructor', this.FUNCTION, Interpreter.NONENUMERABLE_DESCRIPTOR); this.FUNCTION_PROTO.nativeFunc = function() {}; this.FUNCTION_PROTO.nativeFunc.id = this.functionCounter_++; this.setProperty(this.FUNCTION_PROTO, 'length', 0, Interpreter.READONLY_DESCRIPTOR); var boxThis = function(value) { // In non-strict mode 'this' must be an object. if ((!value || !value.isObject) && !thisInterpreter.getScope().strict) { if (value === undefined || value === null) { // 'Undefined' and 'null' are changed to global object. value = thisInterpreter.global; } else { // Primitives must be boxed in non-strict mode. var box = thisInterpreter.createObjectProto( thisInterpreter.getPrototype(value)); box.data = value; value = box; } } return value; }; wrapper = function(thisArg, args) { var state = thisInterpreter.stateStack[thisInterpreter.stateStack.length - 1]; // Rewrite the current 'CallExpression' to apply a different function. state.func_ = this; // Assign the 'this' object. state.funcThis_ = boxThis(thisArg); // Bind any provided arguments. state.arguments_ = []; if (args !== null && args !== undefined) { if (args.isObject) { state.arguments_ = thisInterpreter.arrayPseudoToNative(args); } else { thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, 'CreateListFromArrayLike called on non-object'); } } state.doneExec_ = false; }; this.setNativeFunctionPrototype(this.FUNCTION, 'apply', wrapper); wrapper = function(thisArg /*, var_args */) { var state = thisInterpreter.stateStack[thisInterpreter.stateStack.length - 1]; // Rewrite the current 'CallExpression' to call a different function. state.func_ = this; // Assign the 'this' object. state.funcThis_ = boxThis(thisArg); // Bind any provided arguments. state.arguments_ = []; for (var i = 1; i < arguments.length; i++) { state.arguments_.push(arguments[i]); } state.doneExec_ = false; }; this.setNativeFunctionPrototype(this.FUNCTION, 'call', wrapper); this.polyfills_.push( // Polyfill copied from: // developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_objects/Function/bind "Object.defineProperty(Function.prototype, 'bind',", "{configurable: true, writable: true, value:", "function(oThis) {", "if (typeof this !== 'function') {", "throw TypeError('What is trying to be bound is not callable');", "}", "var aArgs = Array.prototype.slice.call(arguments, 1),", "fToBind = this,", "fNOP = function() {},", "fBound = function() {", "return fToBind.apply(this instanceof fNOP", "? this", ": oThis,", "aArgs.concat(Array.prototype.slice.call(arguments)));", "};", "if (this.prototype) {", "fNOP.prototype = this.prototype;", "}", "fBound.prototype = new fNOP();", "return fBound;", "}", "});", ""); // Function has no parent to inherit from, so it needs its own mandatory // toString and valueOf functions. wrapper = function() { return this.toString(); }; this.setNativeFunctionPrototype(this.FUNCTION, 'toString', wrapper); this.setProperty(this.FUNCTION, 'toString', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); wrapper = function() { return this.valueOf(); }; this.setNativeFunctionPrototype(this.FUNCTION, 'valueOf', wrapper); this.setProperty(this.FUNCTION, 'valueOf', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); }; /** * Initialize the Object class. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initObject = function(scope) { var thisInterpreter = this; var wrapper; // Object constructor. wrapper = function(value) { if (value === undefined || value === null) { // Create a new object. if (thisInterpreter.calledWithNew()) { // Called as new Object(). return this; } else { // Called as Object(). return thisInterpreter.createObjectProto(thisInterpreter.OBJECT_PROTO); } } if (!value.isObject) { // Wrap the value as an object. var box = thisInterpreter.createObjectProto( thisInterpreter.getPrototype(value)); box.data = value; return box; } // Return the provided object. return value; }; this.OBJECT = this.createNativeFunction(wrapper, true); // Throw away the created prototype and use the root prototype. this.setProperty(this.OBJECT, 'prototype', this.OBJECT_PROTO); this.setProperty(this.OBJECT_PROTO, 'constructor', this.OBJECT, Interpreter.NONENUMERABLE_DESCRIPTOR); this.setProperty(scope, 'Object', this.OBJECT); /** * Checks if the provided value is null or undefined. * If so, then throw an error in the call stack. * @param {Interpreter.Value} value Value to check. */ var throwIfNullUndefined = function(value) { if (value === undefined || value === null) { thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "Cannot convert '" + value + "' to object"); } }; // Static methods on Object. wrapper = function(obj) { throwIfNullUndefined(obj); var props = obj.isObject ? obj.properties : obj; return thisInterpreter.arrayNativeToPseudo( Object.getOwnPropertyNames(props)); }; this.setProperty(this.OBJECT, 'getOwnPropertyNames', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); wrapper = function(obj) { throwIfNullUndefined(obj); if (obj.isObject) { obj = obj.properties; } return thisInterpreter.arrayNativeToPseudo(Object.keys(obj)); }; this.setProperty(this.OBJECT, 'keys', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); wrapper = function(proto) { // Support for the second argument is the responsibility of a polyfill. if (proto === null) { return thisInterpreter.createObjectProto(null); } if (proto === undefined || !proto.isObject) { thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, 'Object prototype may only be an Object or null'); } return thisInterpreter.createObjectProto(proto); }; this.setProperty(this.OBJECT, 'create', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); // Add a polyfill to handle create's second argument. this.polyfills_.push( "(function() {", "var create_ = Object.create;", "Object.create = function(proto, props) {", "var obj = create_(proto);", "props && Object.defineProperties(obj, props);", "return obj;", "};", "})();", ""); wrapper = function(obj, prop, descriptor) { prop = String(prop); if (!obj || !obj.isObject) { thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, 'Object.defineProperty called on non-object'); } if (!descriptor || !descriptor.isObject) { thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, 'Property description must be an object'); } if (!obj.properties[prop] && obj.preventExtensions) { thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, "Can't define property '" + prop + "', object is not extensible"); } // The polyfill guarantees no inheritance and no getter functions. // Therefore the descriptor properties map is the native object needed. thisInterpreter.setProperty(obj, prop, Interpreter.VALUE_IN_DESCRIPTOR, descriptor.properties); return obj; }; this.setProperty(this.OBJECT, 'defineProperty', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); this.polyfills_.push( // Flatten the descriptor to remove any inheritance or getter functions. "(function() {", "var defineProperty_ = Object.defineProperty;", "Object.defineProperty = function(obj, prop, d1) {", "var d2 = {};", "if ('configurable' in d1) d2.configurable = d1.configurable;", "if ('enumerable' in d1) d2.enumerable = d1.enumerable;", "if ('writable' in d1) d2.writable = d1.writable;", "if ('value' in d1) d2.value = d1.value;", "if ('get' in d1) d2.get = d1.get;", "if ('set' in d1) d2.set = d1.set;", "return defineProperty_(obj, prop, d2);", "};", "})();", "Object.defineProperty(Object, 'defineProperties',", "{configurable: true, writable: true, value:", "function(obj, props) {", "var keys = Object.keys(props);", "for (var i = 0; i < keys.length; i++) {", "Object.defineProperty(obj, keys[i], props[keys[i]]);", "}", "return obj;", "}", "});", ""); wrapper = function(obj, prop) { if (!obj || !obj.isObject) { thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, 'Object.getOwnPropertyDescriptor called on non-object'); } prop = String(prop); if (!(prop in obj.properties)) { return undefined; } var descriptor = Object.getOwnPropertyDescriptor(obj.properties, prop); var getter = obj.getter[prop]; var setter = obj.setter[prop]; if (getter || setter) { descriptor.get = getter; descriptor.set = setter; delete descriptor.value; delete descriptor.writable; } // Preserve value, but remove it for the nativeToPseudo call. var value = descriptor.value; var hasValue = 'value' in descriptor; delete descriptor.value; var pseudoDescriptor = thisInterpreter.nativeToPseudo(descriptor); if (hasValue) { thisInterpreter.setProperty(pseudoDescriptor, 'value', value); } return pseudoDescriptor; }; this.setProperty(this.OBJECT, 'getOwnPropertyDescriptor', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); wrapper = function(obj) { throwIfNullUndefined(obj); return thisInterpreter.getPrototype(obj); }; this.setProperty(this.OBJECT, 'getPrototypeOf', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); wrapper = function(obj) { return Boolean(obj) && !obj.preventExtensions; }; this.setProperty(this.OBJECT, 'isExtensible', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); wrapper = function(obj) { if (obj && obj.isObject) { obj.preventExtensions = true; } return obj; }; this.setProperty(this.OBJECT, 'preventExtensions', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); // Instance methods on Object. this.setNativeFunctionPrototype(this.OBJECT, 'toString', Interpreter.Object.prototype.toString); this.setNativeFunctionPrototype(this.OBJECT, 'toLocaleString', Interpreter.Object.prototype.toString); this.setNativeFunctionPrototype(this.OBJECT, 'valueOf', Interpreter.Object.prototype.valueOf); wrapper = function(prop) { throwIfNullUndefined(this); if (!this.isObject) { return this.hasOwnProperty(prop); } return String(prop) in this.properties; }; this.setNativeFunctionPrototype(this.OBJECT, 'hasOwnProperty', wrapper); wrapper = function(prop) { throwIfNullUndefined(this); if (!this.isObject) { return this.propertyIsEnumerable(prop); } return Object.prototype.propertyIsEnumerable.call(this.properties, prop); }; this.setNativeFunctionPrototype(this.OBJECT, 'propertyIsEnumerable', wrapper); wrapper = function(obj) { while (true) { // Note, circular loops shouldn't be possible. obj = thisInterpreter.getPrototype(obj); if (!obj) { // No parent; reached the top. return false; } if (obj === this) { return true; } } }; this.setNativeFunctionPrototype(this.OBJECT, 'isPrototypeOf', wrapper); }; /** * Initialize the Array class. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initArray = function(scope) { var thisInterpreter = this; var wrapper; // Array constructor. wrapper = function(var_args) { if (thisInterpreter.calledWithNew()) { // Called as new Array(). var newArray = this; } else { // Called as Array(). var newArray = thisInterpreter.createObjectProto(thisInterpreter.ARRAY_PROTO); } var first = arguments[0]; if (arguments.length === 1 && typeof first === 'number') { if (isNaN(Interpreter.legalArrayLength(first))) { thisInterpreter.throwException(thisInterpreter.RANGE_ERROR, 'Invalid array length'); } newArray.properties.length = first; } else { for (var i = 0; i < arguments.length; i++) { newArray.properties[i] = arguments[i]; } newArray.properties.length = i; } return newArray; }; this.ARRAY = this.createNativeFunction(wrapper, true); this.ARRAY_PROTO = this.ARRAY.properties['prototype']; this.setProperty(scope, 'Array', this.ARRAY); // Static methods on Array. wrapper = function(obj) { return obj && obj.class === 'Array'; }; this.setProperty(this.ARRAY, 'isArray', this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); // Instance methods on Array. wrapper = function() { return Array.prototype.pop.call(this.properties); }; this.setNativeFunctionPrototype(this.ARRAY, 'pop', wrapper); wrapper = function(var_args) { return Array.prototype.push.apply(this.properties, arguments); }; this.setNativeFunctionPrototype(this.ARRAY, 'push', wrapper); wrapper = function() { return Array.prototype.shift.call(this.properties); }; this.setNativeFunctionPrototype(this.ARRAY, 'shift', wrapper); wrapper = function(var_args) { return Array.prototype.unshift.apply(this.properties, arguments); }; this.setNativeFunctionPrototype(this.ARRAY, 'unshift', wrapper); wrapper = function() { Array.prototype.reverse.call(this.properties); return this; }; this.setNativeFunctionPrototype(this.ARRAY, 'reverse', wrapper); wrapper = function(index, howmany /*, var_args*/) { var list = Array.prototype.splice.apply(this.properties, arguments); return thisInterpreter.arrayNativeToPseudo(list); }; this.setNativeFunctionPrototype(this.ARRAY, 'splice', wrapper); wrapper = function(opt_begin, opt_end) { var list = Array.prototype.slice.call(this.properties, opt_begin, opt_end); return thisInterpreter.arrayNativeToPseudo(list); }; this.setNativeFunctionPrototype(this.ARRAY, 'slice', wrapper); wrapper = function(opt_separator) { return Array.prototype.join.call(this.properties, opt_separator); }; this.setNativeFunctionPrototype(this.ARRAY, 'join', wrapper); wrapper = function(var_args) { var list = []; var length = 0; // Start by copying the current array. var iLength = thisInterpreter.getProperty(this, 'length'); for (var i = 0; i < iLength; i++) { if (thisInterpreter.hasProperty(this, i)) { var element = thisInterpreter.getProperty(this, i); list[length] = element; } length++; } // Loop through all arguments and copy them in. for (var i = 0; i < arguments.length; i++) { var value = arguments[i]; if (thisInterpreter.isa(value, thisInterpreter.ARRAY)) { var jLength = thisInterpreter.getProperty(value, 'length'); for (var j = 0; j < jLength; j++) { if (thisInterpreter.hasProperty(value, j)) { list[length] = thisInterpreter.getProperty(value, j); } length++; } } else { list[length] = value; } } return thisInterpreter.arrayNativeToPseudo(list); }; this.setNativeFunctionPrototype(this.ARRAY, 'concat', wrapper); wrapper = function(searchElement, opt_fromIndex) { return Array.prototype.indexOf.apply(this.properties, arguments); }; this.setNativeFunctionPrototype(this.ARRAY, 'indexOf', wrapper); wrapper = function(searchElement, opt_fromIndex) { return Array.prototype.lastIndexOf.apply(this.properties, arguments); }; this.setNativeFunctionPrototype(this.ARRAY, 'lastIndexOf', wrapper); wrapper = function() { Array.prototype.sort.call(this.properties); return this; }; this.setNativeFunctionPrototype(this.ARRAY, 'sort', wrapper); this.polyfills_.push( // Polyfill copied from: // developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/every "Object.defineProperty(Array.prototype, 'every',", "{configurable: true, writable: true, value:", "function(callbackfn, thisArg) {", "if (!this || typeof callbackfn !== 'function') throw TypeError();", "var T, k;", "var O = Object(this);", "var len = O.length >>> 0;", "if (arguments.length > 1) T = thisArg;", "k = 0;", "while (k < len) {", "if (k in O && !callbackfn.call(T, O[k], k, O)) return false;", "k++;", "}", "return true;", "}", "});", // Polyfill copied from: // developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/filter "Object.defineProperty(Array.prototype, 'filter',", "{configurable: true, writable: true, value:", "function(fun/*, thisArg*/) {", "if (this === void 0 || this === null || typeof fun !== 'function') throw TypeError();", "var t = Object(this);", "var len = t.length >>> 0;", "var res = [];", "var thisArg = arguments.length >= 2 ? arguments[1] : void 0;", "for (var i = 0; i < len; i++) {", "if (i in t) {", "var val = t[i];", "if (fun.call(thisArg, val, i, t)) res.push(val);", "}", "}", "return res;", "}", "});", // Polyfill copied from: // https://tc39.github.io/ecma262/#sec-array.prototype.find // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find "if (!Array.prototype.find) {", "Object.defineProperty(Array.prototype, 'find', {", "value: function(predicate) {", "if (this == null) {", "throw new TypeError('\"this\" is null or not defined');", "}", "var o = Object(this);", "var len = o.length >>> 0;", "if (typeof predicate !== 'function') {", "throw new TypeError('predicate must be a function');", "}", "var thisArg = arguments[1];", "var k = 0;", "while (k < len) {", "var kValue = o[k];", "if (predicate.call(thisArg, kValue, k, o)) {", "return kValue;", "}", "k++;", "}", "return undefined;", "},", "configurable: true,", "writable: true", "});", "}", // Poly fill copied from: // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex "if (!Array.prototype.findIndex) {", "Object.defineProperty(Array.prototype, 'findIndex', {", "value: function(predicate) {", "if (this == null) {", "throw new TypeError('\"this\" is null or not defined');", "}", "var o = Object(this);", "var len = o.length >>> 0;", "if (typeof predicate !== 'function') {", "throw new TypeError('predicate must be a function');", "}", "var thisArg = arguments[1];", "var k = 0;", "while (k < len) {", "var kValue = o[k];", "if (predicate.call(thisArg, kValue, k, o)) {", "return k;", "}", "k++;", "}", "return -1;", "},", "configurable: true,", "writable: true", "});", "}", // Polyfill copied from: // developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach "Object.defineProperty(Array.prototype, 'forEach',", "{configurable: true, writable: true, value:", "function(callback, thisArg) {", "if (!this || typeof callback !== 'function') throw TypeError();", "var T, k;", "var O = Object(this);", "var len = O.length >>> 0;", "if (arguments.length > 1) T = thisArg;", "k = 0;", "while (k < len) {", "if (k in O) callback.call(T, O[k], k, O);", "k++;", "}", "}", "});", // Polyfill copied from: // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes#Polyfill "Object.defineProperty(Array.prototype, 'includes', {", "value: function(searchElement, fromIndex) {", "if (this == null) {", "throw new TypeError('\"this\" is null or not defined');", "}", "// 1. Let O be ? ToObject(this value).", "var o = Object(this);", "// 2. Let len be ? ToLength(? Get(O, \"length\")).", "var len = o.length >>> 0;", "// 3. If len is 0, return false.", "if (len === 0) {", "return false;", "}", "// 4. Let n be ? ToInteger(fromIndex).", "// (If fromIndex is undefined, this step produces the value 0.)", "var n = fromIndex | 0;", "// 5. If n ≥ 0, then", "// a. Let k be n.", "// 6. Else n < 0,", "// a. Let k be len + n.", "// b. If k < 0, let k be 0.", "var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);", "function sameValueZero(x, y) {", "return x === y || (typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y));", "}", "// 7. Repeat, while k < len", "while (k < len) {", "// a. Let elementK be the result of ? Get(O, ! ToString(k)).", "// b. If SameValueZero(searchElement, elementK) is true, return true.", "if (sameValueZero(o[k], searchElement)) {", "return true;", "}", "// c. Increase k by 1. ", "k++;", "}", "// 8. Return false", "return false;", "}", "});", // Polyfill copied from: // developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/map "Object.defineProperty(Array.prototype, 'map',", "{configurable: true, writable: true, value:", "function(callback, thisArg) {", "if (!this || typeof callback !== 'function') new TypeError;", "var T, A, k;", "var O = Object(this);", "var len = O.length >>> 0;", "if (arguments.length > 1) T = thisArg;", "A = new Array(len);", "k = 0;", "while (k < len) {", "if (k in O) A[k] = callback.call(T, O[k], k, O);", "k++;", "}", "return A;", "}", "});", // Polyfill copied from: // developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce "Object.defineProperty(Array.prototype, 'reduce',", "{configurable: true, writable: true, value:", "function(callback /*, initialValue*/) {", "if (!this || typeof callback !== 'function') throw TypeError();", "var t = Object(this), len = t.length >>> 0, k = 0, value;", "if (arguments.length === 2) {", "value = arguments[1];", "} else {", "while (k < len && !(k in t)) k++;", "if (k >= len) {", "throw TypeError('Reduce of empty array with no initial value');", "}", "value = t[k++];", "}", "for (; k < len; k++) {", "if (k in t) value = callback(value, t[k], k, t);", "}", "return value;", "}", "});", // Polyfill copied from: // developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/ReduceRight "Object.defineProperty(Array.prototype, 'reduceRight',", "{configurable: true, writable: true, value:", "function(callback /*, initialValue*/) {", "if (null === this || 'undefined' === typeof this || 'function' !== typeof callback) throw TypeError();", "var t = Object(this), len = t.length >>> 0, k = len - 1, value;", "if (arguments.length >= 2) {", "value = arguments[1];", "} else {", "while (k >= 0 && !(k in t)) k--;", "if (k < 0) {", "throw TypeError('Reduce of empty array with no initial value');", "}", "value = t[k--];", "}", "for (; k >= 0; k--) {", "if (k in t) value = callback(value, t[k], k, t);", "}", "return value;", "}", "});", // Polyfill copied from: // developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/some "Object.defineProperty(Array.prototype, 'some',", "{configurable: true, writable: true, value:", "function(fun/*, thisArg*/) {", "if (!this || typeof fun !== 'function') throw TypeError();", "var t = Object(this);", "var len = t.length >>> 0;", "var thisArg = arguments.length >= 2 ? arguments[1] : void 0;", "for (var i = 0; i < len; i++) {", "if (i in t && fun.call(thisArg, t[i], i, t)) {", "return true;", "}", "}", "return false;", "}", "});", "(function() {", "var sort_ = Array.prototype.sort;", "Array.prototype.sort = function(opt_comp) {", // Fast native sort. "if (typeof opt_comp !== 'function') {", "return sort_.call(this);", "}", // Slow bubble sort. "for (var i = 0; i < this.length; i++) {", "var changes = 0;", "for (var j = 0; j < this.length - i - 1; j++) {", "if (opt_comp(this[j], this[j + 1]) > 0) {", "var swap = this[j];", "this[j] = this[j + 1];", "this[j + 1] = swap;", "changes++;", "}", "}", "if (!changes) break;", "}", "return this;", "};", "})();", "Object.defineProperty(Array.prototype, 'toLocaleString',", "{configurable: true, writable: true, value:", "function() {", "var out = [];", "for (var i = 0; i < this.length; i++) {", "out[i] = (this[i] === null || this[i] === undefined) ? '' : this[i].toLocaleString();", "}", "return out.join(',');", "}", "});", ""); }; /** * Initialize the String class. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initString = function(scope) { var thisInterpreter = this; var wrapper; // String constructor. wrapper = function(value) { value = String(value); if (thisInterpreter.calledWithNew()) { // Called as new String(). this.data = value; return this; } else { // Called as String(). return value; } }; this.STRING = this.createNativeFunction(wrapper, true); this.setProperty(scope, 'String', this.STRING); // Static methods on String. this.setProperty(this.STRING, 'fromCharCode', this.createNativeFunction(String.fromCharCode, false), Interpreter.NONENUMERABLE_DESCRIPTOR); // Instance methods on String. // Methods with exclusively primitive arguments. var functions = ['charAt', 'charCodeAt', 'concat', 'indexOf', 'lastIndexOf', 'slice', 'substr', 'substring', 'toLocaleLowerCase', 'toLocaleUpperCase', 'toLowerCase', 'toUpperCase', 'trim']; for (var i = 0; i < functions.length; i++) { this.setNativeFunctionPrototype(this.STRING, functions[i], String.prototype[functions[i]]); } wrapper = function(compareString, locales, options) { locales = locales ? thisInterpreter.pseudoToNative(locales) : undefined; options = options ? thisInterpreter.pseudoToNative(options) : undefined; return String(this).localeCompare(compareString, locales, options); }; this.setNativeFunctionPrototype(this.STRING, 'localeCompare', wrapper); wrapper = function(separator, limit) { if (thisInterpreter.isa(separator, thisInterpreter.REGEXP)) { separator = separator.data; } var jsList = String(this).split(separator, limit); return thisInterpreter.arrayNativeToPseudo(jsList); }; this.setNativeFunctionPrototype(this.STRING, 'split', wrapper); wrapper = function(regexp) { if (thisInterpreter.isa(regexp, thisInterpreter.REGEXP)) { regexp = regexp.data; } var m = String(this).match(regexp); return m && thisInterpreter.arrayNativeToPseudo(m); }; this.setNativeFunctionPrototype(this.STRING, 'match', wrapper); wrapper = function(regexp) { if (thisInterpreter.isa(regexp, thisInterpreter.REGEXP)) { regexp = regexp.data; } return String(this).search(regexp); }; this.setNativeFunctionPrototype(this.STRING, 'search', wrapper); wrapper = function(substr, newSubstr) { // Support for function replacements is the responsibility of a polyfill. if (thisInterpreter.isa(substr, thisInterpreter.REGEXP)) { substr = substr.data; } return String(this).replace(substr, newSubstr); }; this.setNativeFunctionPrototype(this.STRING, 'replace', wrapper); // Add a polyfill to handle replace's second argument being a function. this.polyfills_.push( "(function() {", "var replace_ = String.prototype.replace;", "String.prototype.replace = function(substr, newSubstr) {", "if (typeof newSubstr !== 'function') {", // string.replace(string|regexp, string) "return replace_.call(this, substr, newSubstr);", "}", "var str = this;", "if (substr instanceof RegExp) {", // string.replace(regexp, function) "var subs = [];", "var m = substr.exec(str);", "while (m) {", "m.push(m.index, str);", "var inject = newSubstr.apply(null, m);", "subs.push([m.index, m[0].length, inject]);", "m = substr.global ? substr.exec(str) : null;", "}", "for (var i = subs.length - 1; i >= 0; i--) {", "str = str.substring(0, subs[i][0]) + subs[i][2] + " + "str.substring(subs[i][0] + subs[i][1]);", "}", "} else {", // string.replace(string, function) "var i = str.indexOf(substr);", "if (i !== -1) {", "var inject = newSubstr(str.substr(i, substr.length), i, str);", "str = str.substring(0, i) + inject + " + "str.substring(i + substr.length);", "}", "}", "return str;", "};", "})();", // Polyfill copied from: // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith "if (!String.prototype.endsWith) {", "String.prototype.endsWith = function(search, this_len) {", "if (this_len === undefined || this_len > this.length) {", "this_len = this.length;", "}", "return this.substring(this_len - search.length, this_len) === search;", "};", "}", //Polyfill copied from: // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes "if (!String.prototype.includes) {", "String.prototype.includes = function(search, start) {", "'use strict';", "if (typeof start !== 'number') {", "start = 0;", "}", " ", "if (start + search.length > this.length) {", "return false;", "} else {", "return this.indexOf(search, start) !== -1;", "}", "};", "}", // Polyfill copied from: // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith "if (!String.prototype.startsWith) {", "String.prototype.startsWith = function(search, pos) {", "return this.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;", "};", "}", ""); }; /** * Initialize the Boolean class. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initBoolean = function(scope) { var thisInterpreter = this; var wrapper; // Boolean constructor. wrapper = function(value) { value = Boolean(value); if (thisInterpreter.calledWithNew()) { // Called as new Boolean(). this.data = value; return this; } else { // Called as Boolean(). return value; } }; this.BOOLEAN = this.createNativeFunction(wrapper, true); this.setProperty(scope, 'Boolean', this.BOOLEAN); }; /** * Initialize the Number class. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initNumber = function(scope) { var thisInterpreter = this; var wrapper; // Number constructor. wrapper = function(value) { value = Number(value); if (thisInterpreter.calledWithNew()) { // Called as new Number(). this.data = value; return this; } else { // Called as Number(). return value; } }; this.NUMBER = this.createNativeFunction(wrapper, true); this.setProperty(scope, 'Number', this.NUMBER); var numConsts = ['MAX_VALUE', 'MIN_VALUE', 'NaN', 'NEGATIVE_INFINITY', 'POSITIVE_INFINITY']; for (var i = 0; i < numConsts.length; i++) { this.setProperty(this.NUMBER, numConsts[i], Number[numConsts[i]], Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); } // Instance methods on Number. wrapper = function(fractionDigits) { try { return Number(this).toExponential(fractionDigits); } catch (e) { // Throws if fractionDigits isn't within 0-20. thisInterpreter.throwException(thisInterpreter.ERROR, e.message); } }; this.setNativeFunctionPrototype(this.NUMBER, 'toExponential', wrapper); wrapper = function(digits) { try { return Number(this).toFixed(digits); } catch (e) { // Throws if digits isn't within 0-20. thisInterpreter.throwException(thisInterpreter.ERROR, e.message); } }; this.setNativeFunctionPrototype(this.NUMBER, 'toFixed', wrapper); wrapper = function(precision) { try { return Number(this).toPrecision(precision); } catch (e) { // Throws if precision isn't within range (depends on implementation). thisInterpreter.throwException(thisInterpreter.ERROR, e.message); } }; this.setNativeFunctionPrototype(this.NUMBER, 'toPrecision', wrapper); wrapper = function(radix) { try { return Number(this).toString(radix); } catch (e) { // Throws if radix isn't within 2-36. thisInterpreter.throwException(thisInterpreter.ERROR, e.message); } }; this.setNativeFunctionPrototype(this.NUMBER, 'toString', wrapper); wrapper = function(locales, options) { locales = locales ? thisInterpreter.pseudoToNative(locales) : undefined; options = options ? thisInterpreter.pseudoToNative(options) : undefined; return Number(this).toLocaleString(locales, options); }; this.setNativeFunctionPrototype(this.NUMBER, 'toLocaleString', wrapper); }; /** * Initialize the Date class. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initDate = function(scope) { var thisInterpreter = this; var wrapper; // Date constructor. wrapper = function(value, var_args) { if (!thisInterpreter.calledWithNew()) { // Called as Date(). // Calling Date() as a function returns a string, no arguments are heeded. return Date(); } // Called as new Date(). var args = [null].concat(Array.from(arguments)); this.data = new (Function.prototype.bind.apply(Date, args)); return this; }; this.DATE = this.createNativeFunction(wrapper, true); this.DATE_PROTO = this.DATE.properties['prototype']; this.setProperty(scope, 'Date', this.DATE); // Static methods on Date. this.setProperty(this.DATE, 'now', this.createNativeFunction(Date.now, false), Interpreter.NONENUMERABLE_DESCRIPTOR); this.setProperty(this.DATE, 'parse', this.createNativeFunction(Date.parse, false), Interpreter.NONENUMERABLE_DESCRIPTOR); this.setProperty(this.DATE, 'UTC', this.createNativeFunction(Date.UTC, false), Interpreter.NONENUMERABLE_DESCRIPTOR); // Instance methods on Date. var functions = ['getDate', 'getDay', 'getFullYear', 'getHours', 'getMilliseconds', 'getMinutes', 'getMonth', 'getSeconds', 'getTime', 'getTimezoneOffset', 'getUTCDate', 'getUTCDay', 'getUTCFullYear', 'getUTCHours', 'getUTCMilliseconds', 'getUTCMinutes', 'getUTCMonth', 'getUTCSeconds', 'getYear', 'setDate', 'setFullYear', 'setHours', 'setMilliseconds', 'setMinutes', 'setMonth', 'setSeconds', 'setTime', 'setUTCDate', 'setUTCFullYear', 'setUTCHours', 'setUTCMilliseconds', 'setUTCMinutes', 'setUTCMonth', 'setUTCSeconds', 'setYear', 'toDateString', 'toISOString', 'toJSON', 'toGMTString', 'toLocaleDateString', 'toLocaleString', 'toLocaleTimeString', 'toTimeString', 'toUTCString']; for (var i = 0; i < functions.length; i++) { wrapper = (function(nativeFunc) { return function(var_args) { var args = []; for (var i = 0; i < arguments.length; i++) { args[i] = thisInterpreter.pseudoToNative(arguments[i]); } return this.data[nativeFunc].apply(this.data, args); }; })(functions[i]); this.setNativeFunctionPrototype(this.DATE, functions[i], wrapper); } }; /** * Initialize Regular Expression object. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initRegExp = function(scope) { var thisInterpreter = this; var wrapper; // RegExp constructor. wrapper = function(pattern, flags) { if (thisInterpreter.calledWithNew()) { // Called as new RegExp(). var rgx = this; } else { // Called as RegExp(). var rgx = thisInterpreter.createObjectProto(thisInterpreter.REGEXP_PROTO); } pattern = pattern ? pattern.toString() : ''; flags = flags ? flags.toString() : ''; thisInterpreter.populateRegExp(rgx, new RegExp(pattern, flags)); return rgx; }; this.REGEXP = this.createNativeFunction(wrapper, true); this.REGEXP_PROTO = this.REGEXP.properties['prototype']; this.setProperty(scope, 'RegExp', this.REGEXP); this.setProperty(this.REGEXP.properties['prototype'], 'global', undefined, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); this.setProperty(this.REGEXP.properties['prototype'], 'ignoreCase', undefined, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); this.setProperty(this.REGEXP.properties['prototype'], 'multiline', undefined, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); this.setProperty(this.REGEXP.properties['prototype'], 'source', '(?:)', Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); wrapper = function(str) { return this.data.test(str); }; this.setNativeFunctionPrototype(this.REGEXP, 'test', wrapper); wrapper = function(str) { str = str.toString(); // Get lastIndex from wrapped regex, since this is settable. this.data.lastIndex = Number(thisInterpreter.getProperty(this, 'lastIndex')); var match = this.data.exec(str); thisInterpreter.setProperty(this, 'lastIndex', this.data.lastIndex); if (match) { var result = thisInterpreter.createObjectProto(thisInterpreter.ARRAY_PROTO); for (var i = 0; i < match.length; i++) { thisInterpreter.setProperty(result, i, match[i]); } // match has additional properties. thisInterpreter.setProperty(result, 'index', match.index); thisInterpreter.setProperty(result, 'input', match.input); return result; } return null; }; this.setNativeFunctionPrototype(this.REGEXP, 'exec', wrapper); }; /** * Initialize the Error class. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initError = function(scope) { var thisInterpreter = this; // Error constructor. this.ERROR = this.createNativeFunction(function(opt_message) { if (thisInterpreter.calledWithNew()) { // Called as new Error(). var newError = this; } else { // Called as Error(). var newError = thisInterpreter.createObject(thisInterpreter.ERROR); } if (opt_message) { thisInterpreter.setProperty(newError, 'message', String(opt_message), Interpreter.NONENUMERABLE_DESCRIPTOR); } return newError; }, true); this.setProperty(scope, 'Error', this.ERROR); this.setProperty(this.ERROR.properties['prototype'], 'message', '', Interpreter.NONENUMERABLE_DESCRIPTOR); this.setProperty(this.ERROR.properties['prototype'], 'name', 'Error', Interpreter.NONENUMERABLE_DESCRIPTOR); var createErrorSubclass = function(name) { var constructor = thisInterpreter.createNativeFunction( function(opt_message) { if (thisInterpreter.calledWithNew()) { // Called as new XyzError(). var newError = this; } else { // Called as XyzError(). var newError = thisInterpreter.createObject(constructor); } if (opt_message) { thisInterpreter.setProperty(newError, 'message', String(opt_message), Interpreter.NONENUMERABLE_DESCRIPTOR); } return newError; }, true); thisInterpreter.setProperty(constructor, 'prototype', thisInterpreter.createObject(thisInterpreter.ERROR)); thisInterpreter.setProperty(constructor.properties['prototype'], 'name', name, Interpreter.NONENUMERABLE_DESCRIPTOR); thisInterpreter.setProperty(scope, name, constructor); return constructor; }; this.EVAL_ERROR = createErrorSubclass('EvalError'); this.RANGE_ERROR = createErrorSubclass('RangeError'); this.REFERENCE_ERROR = createErrorSubclass('ReferenceError'); this.SYNTAX_ERROR = createErrorSubclass('SyntaxError'); this.TYPE_ERROR = createErrorSubclass('TypeError'); this.URI_ERROR = createErrorSubclass('URIError'); }; /** * Initialize Math object. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initMath = function(scope) { var thisInterpreter = this; var myMath = this.createObjectProto(this.OBJECT_PROTO); this.setProperty(scope, 'Math', myMath); var mathConsts = ['E', 'LN2', 'LN10', 'LOG2E', 'LOG10E', 'PI', 'SQRT1_2', 'SQRT2']; for (var i = 0; i < mathConsts.length; i++) { this.setProperty(myMath, mathConsts[i], Math[mathConsts[i]], Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); } var numFunctions = ['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'random', 'round', 'sin', 'sqrt', 'tan']; for (var i = 0; i < numFunctions.length; i++) { this.setProperty(myMath, numFunctions[i], this.createNativeFunction(Math[numFunctions[i]], false), Interpreter.NONENUMERABLE_DESCRIPTOR); } }; /** * Initialize JSON object. * @param {!Interpreter.Object} scope Global scope. */ Interpreter.prototype.initJSON = function(scope) { var thisInterpreter = this; var myJSON = thisInterpreter.createObjectProto(this.OBJECT_PROTO); this.setProperty(scope, 'JSON', myJSON); var wrapper = function(text) { try { var nativeObj = JSON.parse(text.toString()); } catch (e) { thisInterpreter.throwException(thisInterpreter.SYNTAX_ERROR, e.message); } return thisInterpreter.nativeToPseudo(nativeObj); }; this.setProperty(myJSON, 'parse', this.createNativeFunction(wrapper, false)); wrapper = function(value) { var nativeObj = thisInterpreter.pseudoToNative(value); try { var str = JSON.stringify(nativeObj); } catch (e) { thisInterpreter.throwException(thisInterpreter.TYPE_ERROR, e.message); } return str; }; this.setProperty(myJSON, 'stringify', this.createNativeFunction(wrapper, false)); }; /** * Is an object of a certain class? * @param {Interpreter.Value} child Object to check. * @param {Interpreter.Object} constructor Constructor of object. * @return {boolean} True if object is the class or inherits from it. * False otherwise. */ Interpreter.prototype.isa = function(child, constructor) { if (child === null || child === undefined || !constructor) { return false; } var proto = constructor.properties['prototype']; if (child === proto) { return true; } // The first step up the prototype chain is harder since the child might be // a primitive value. Subsequent steps can just follow the .proto property. child = this.getPrototype(child); while (child) { if (child === proto) { return true; } child = child.proto; } return false; }; /** * Is a value a legal integer for an array length? * @param {Interpreter.Value} x Value to check. * @return {number} Zero, or a positive integer if the value can be * converted to such. NaN otherwise. */ Interpreter.legalArrayLength = function(x) { var n = x >>> 0; // Array length must be between 0 and 2^32-1 (inclusive). return (n === Number(x)) ? n : NaN; }; /** * Is a value a legal integer for an array index? * @param {Interpreter.Value} x Value to check. * @return {number} Zero, or a positive integer if the value can be * converted to such. NaN otherwise. */ Interpreter.legalArrayIndex = function(x) { var n = x >>> 0; // Array index cannot be 2^32-1, otherwise length would be 2^32. // 0xffffffff is 2^32-1. return (String(n) === String(x) && n !== 0xffffffff) ? n : NaN; }; /** * Typedef for JS values. * @typedef {!Interpreter.Object|boolean|number|string|undefined|null} */ Interpreter.Value; /** * Class for an object. * @param {Interpreter.Object} proto Prototype object or null. * @constructor */ Interpreter.Object = function(proto) { this.getter = Object.create(null); this.setter = Object.create(null); this.properties = Object.create(null); this.proto = proto; }; /** @type {Interpreter.Object} */ Interpreter.Object.prototype.proto = null; /** @type {boolean} */ Interpreter.Object.prototype.isObject = true; /** @type {string} */ Interpreter.Object.prototype.class = 'Object'; /** @type {Date|RegExp|boolean|number|string|undefined|null} */ Interpreter.Object.prototype.data = null; /** * Convert this object into a string. * @return {string} String value. * @override */ Interpreter.Object.prototype.toString = function() { if (this.class === 'Array') { // Array var cycles = Interpreter.toStringCycles_; cycles.push(this); try { var strs = []; for (var i = 0; i < this.properties.length; i++) { var value = this.properties[i]; strs[i] = (value && value.isObject && cycles.indexOf(value) !== -1) ? '...' : value; } } finally { cycles.pop(); } return strs.join(','); } if (this.class === 'Error') { var cycles = Interpreter.toStringCycles_; if (cycles.indexOf(this) !== -1) { return '[object Error]'; } var name, message; // Bug: Does not support getters and setters for name or message. var obj = this; do { if ('name' in obj.properties) { name = obj.properties['name']; break; } } while ((obj = obj.proto)); var obj = this; do { if ('message' in obj.properties) { message = obj.properties['message']; break; } } while ((obj = obj.proto)); cycles.push(this); try { name = name && name.toString(); message = message && message.toString(); } finally { cycles.pop(); } return message ? name + ': ' + message : String(name); } // RegExp, Date, and boxed primitives. if (this.data !== null) { return String(this.data); } return '[object ' + this.class + ']'; }; /** * Return the object's value. * @return {Interpreter.Value} Value. * @override */ Interpreter.Object.prototype.valueOf = function() { if (this.data === undefined || this.data === null || this.data instanceof RegExp) { return this; // An Object. } if (this.data instanceof Date) { return this.data.valueOf(); // Milliseconds. } return /** @type {(boolean|number|string)} */ (this.data); // Boxed primitive. }; /** * Create a new data object based on a constructor's prototype. * @param {Interpreter.Object} constructor Parent constructor function, * or null if scope object. * @return {!Interpreter.Object} New data object. */ Interpreter.prototype.createObject = function(constructor) { return this.createObjectProto(constructor && constructor.properties['prototype']); }; /** * Create a new data object based on a prototype. * @param {Interpreter.Object} proto Prototype object. * @return {!Interpreter.Object} New data object. */ Interpreter.prototype.createObjectProto = function(proto) { if (typeof proto !== 'object') { throw Error('Non object prototype'); } var obj = new Interpreter.Object(proto); // Functions have prototype objects. if (this.isa(obj, this.FUNCTION)) { this.setProperty(obj, 'prototype', this.createObjectProto(this.OBJECT_PROTO || null)); obj.class = 'Function'; } // Arrays have length. if (this.isa(obj, this.ARRAY)) { this.setProperty(obj, 'length', 0, {configurable: false, enumerable: false, writable: true}); obj.class = 'Array'; } if (this.isa(obj, this.ERROR)) { obj.class = 'Error'; } return obj; }; /** * Initialize a pseudo regular expression object based on a native regular * expression object. * @param {!Interpreter.Object} pseudoRegexp The existing object to set. * @param {!RegExp} nativeRegexp The native regular expression. */ Interpreter.prototype.populateRegExp = function(pseudoRegexp, nativeRegexp) { pseudoRegexp.data = nativeRegexp; // lastIndex is settable, all others are read-only attributes this.setProperty(pseudoRegexp, 'lastIndex', nativeRegexp.lastIndex, Interpreter.NONENUMERABLE_DESCRIPTOR); this.setProperty(pseudoRegexp, 'source', nativeRegexp.source, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); this.setProperty(pseudoRegexp, 'global', nativeRegexp.global, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); this.setProperty(pseudoRegexp, 'ignoreCase', nativeRegexp.ignoreCase, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); this.setProperty(pseudoRegexp, 'multiline', nativeRegexp.multiline, Interpreter.READONLY_NONENUMERABLE_DESCRIPTOR); }; /** * Create a new function. * @param {!Object} node AST node defining the function. * @param {!Object} scope Parent scope. * @return {!Interpreter.Object} New function. */ Interpreter.prototype.createFunction = function(node, scope) { var func = this.createObjectProto(this.FUNCTION_PROTO); func.parentScope = scope; func.node = node; this.setProperty(func, 'length', func.node['params'].length, Interpreter.READONLY_DESCRIPTOR); return func; }; /** * Create a new native function. * @param {!Function} nativeFunc JavaScript function. * @param {boolean=} opt_constructor If true, the function's * prototype will have its constructor property set to the function. * If false, the function cannot be called as a constructor (e.g. escape). * Defaults to undefined. * @return {!Interpreter.Object} New function. */ Interpreter.prototype.createNativeFunction = function(nativeFunc, opt_constructor) { var func = this.createObjectProto(this.FUNCTION_PROTO); func.nativeFunc = nativeFunc; nativeFunc.id = this.functionCounter_++; this.setProperty(func, 'length', nativeFunc.length, Interpreter.READONLY_DESCRIPTOR); if (opt_constructor) { this.setProperty(func.properties['prototype'], 'constructor', func, Interpreter.NONENUMERABLE_DESCRIPTOR); } else if (opt_constructor === false) { func.illegalConstructor = true; this.setProperty(func, 'prototype', undefined); } return func; }; /** * Create a new native asynchronous function. * @param {!Function} asyncFunc JavaScript function. * @return {!Interpreter.Object} New function. */ Interpreter.prototype.createAsyncFunction = function(asyncFunc) { var func = this.createObjectProto(this.FUNCTION_PROTO); func.asyncFunc = asyncFunc; asyncFunc.id = this.functionCounter_++; this.setProperty(func, 'length', asyncFunc.length, Interpreter.READONLY_DESCRIPTOR); return func; }; /** * Converts from a native JS object or value to a JS interpreter object. * Can handle JSON-style values, does NOT handle cycles. * @param {*} nativeObj The native JS object to be converted. * @return {Interpreter.Value} The equivalent JS interpreter object. */ Interpreter.prototype.nativeToPseudo = function(nativeObj) { if ((typeof nativeObj !== 'object' && typeof nativeObj !== 'function') || nativeObj === null) { return nativeObj; } if (nativeObj instanceof RegExp) { var pseudoRegexp = this.createObjectProto(this.REGEXP_PROTO); this.populateRegExp(pseudoRegexp, nativeObj); return pseudoRegexp; } if (nativeObj instanceof Date) { var pseudoDate = this.createObjectProto(this.DATE_PROTO); pseudoDate.data = nativeObj; return pseudoDate; } if (nativeObj instanceof Function) { var interpreter = this; var wrapper = function() { return interpreter.nativeToPseudo( nativeObj.apply(interpreter, Array.prototype.slice.call(arguments) .map(function(i) { return interpreter.pseudoToNative(i); }) ) ); }; return this.createNativeFunction(wrapper, undefined); } var pseudoObj; if (Array.isArray(nativeObj)) { // Array. pseudoObj = this.createObjectProto(this.ARRAY_PROTO); for (var i = 0; i < nativeObj.length; i++) { if (i in nativeObj) { this.setProperty(pseudoObj, i, this.nativeToPseudo(nativeObj[i])); } } } else { // Object. pseudoObj = this.createObjectProto(this.OBJECT_PROTO); for (var key in nativeObj) { this.setProperty(pseudoObj, key, this.nativeToPseudo(nativeObj[key])); } } return pseudoObj; }; /** * Converts from a JS interpreter object to native JS object. * Can handle JSON-style values, plus cycles. * @param {Interpreter.Value} pseudoObj The JS interpreter object to be * converted. * @param {Object=} opt_cycles Cycle detection (used in recursive calls). * @return {*} The equivalent native JS object or value. */ Interpreter.prototype.pseudoToNative = function(pseudoObj, opt_cycles) { if ((typeof pseudoObj !== 'object' && typeof pseudoObj !== 'function') || pseudoObj === null) { return pseudoObj; } if (this.isa(pseudoObj, this.REGEXP)) { // Regular expression. return pseudoObj.data; } if (this.isa(pseudoObj, this.DATE)) { // Date. return pseudoObj.data; } var cycles = opt_cycles || { pseudo: [], native: [] }; var i = cycles.pseudo.indexOf(pseudoObj); if (i !== -1) { return cycles.native[i]; } cycles.pseudo.push(pseudoObj); var nativeObj; if (this.isa(pseudoObj, this.ARRAY)) { // Array. nativeObj = []; cycles.native.push(nativeObj); var length = this.getProperty(pseudoObj, 'length'); for (var i = 0; i < length; i++) { if (this.hasProperty(pseudoObj, i)) { nativeObj[i] = this.pseudoToNative(this.getProperty(pseudoObj, i), cycles); } } } else { // Object. nativeObj = {}; cycles.native.push(nativeObj); var val; for (var key in pseudoObj.properties) { val = pseudoObj.properties[key]; nativeObj[key] = this.pseudoToNative(val, cycles); } } cycles.pseudo.pop(); cycles.native.pop(); return nativeObj; }; /** * Converts from a native JS array to a JS interpreter array. * Does handle non-numeric properties (like str.match's index prop). * Does NOT recurse into the array's contents. * @param {!Array} nativeArray The JS array to be converted. * @return {!Interpreter.Object} The equivalent JS interpreter array. */ Interpreter.prototype.arrayNativeToPseudo = function(nativeArray) { var pseudoArray = this.createObjectProto(this.ARRAY_PROTO); var props = Object.getOwnPropertyNames(nativeArray); for (var i = 0; i < props.length; i++) { this.setProperty(pseudoArray, props[i], nativeArray[props[i]]); } return pseudoArray; }; /** * Converts from a JS interpreter array to native JS array. * Does handle non-numeric properties (like str.match's index prop). * Does NOT recurse into the array's contents. * @param {!Interpreter.Object} pseudoArray The JS interpreter array, * or JS interpreter object pretending to be an array. * @return {!Array} The equivalent native JS array. */ Interpreter.prototype.arrayPseudoToNative = function(pseudoArray) { var nativeArray = []; for (var key in pseudoArray.properties) { nativeArray[key] = this.getProperty(pseudoArray, key); } // pseudoArray might be an object pretending to be an array. In this case // it's possible that length is non-existent, invalid, or smaller than the // largest defined numeric property. Set length explicitly here. nativeArray.length = Interpreter.legalArrayLength( this.getProperty(pseudoArray, 'length')) || 0; return nativeArray; }; /** * Look up the prototype for this value. * @param {Interpreter.Value} value Data object. * @return {Interpreter.Object} Prototype object, null if none. */ Interpreter.prototype.getPrototype = function(value) { switch (typeof value) { case 'number': return this.NUMBER.properties['prototype']; case 'boolean': return this.BOOLEAN.properties['prototype']; case 'string': return this.STRING.properties['prototype']; } if (value) { return value.proto; } return null; }; /** * Fetch a property value from a data object. * @param {Interpreter.Value} obj Data object. * @param {Interpreter.Value} name Name of property. * @param {Acorn AST Node} node Node that triggered this function. Used by Bitburner for getting error line numbers * @return {Interpreter.Value} Property value (may be undefined). */ Interpreter.prototype.getProperty = function(obj, name, node) { name = String(name); if (obj === undefined || obj === null) { let lineNum; if (node != null && node.loc != null && node.loc.start != null) { lineNum = node.loc.start.line; } this.throwException(this.TYPE_ERROR, "Cannot read property '" + name + "' of " + obj, lineNum); } if (name === 'length') { // Special cases for magic length property. if (this.isa(obj, this.STRING)) { return String(obj).length; } } else if (name.charCodeAt(0) < 0x40) { // Might have numbers in there? // Special cases for string array indexing if (this.isa(obj, this.STRING)) { var n = Interpreter.legalArrayIndex(name); if (!isNaN(n) && n < String(obj).length) { return String(obj)[n]; } } } do { if (obj.properties && name in obj.properties) { var getter = obj.getter[name]; if (getter) { // Flag this function as being a getter and thus needing immediate // execution (rather than being the value of the property). getter.isGetter = true; return getter; } return obj.properties[name]; } } while ((obj = this.getPrototype(obj))); return undefined; }; /** * Does the named property exist on a data object. * @param {Interpreter.Value} obj Data object. * @param {Interpreter.Value} name Name of property. * @return {boolean} True if property exists. */ Interpreter.prototype.hasProperty = function(obj, name) { if (!obj.isObject) { throw TypeError('Primitive data type has no properties'); } name = String(name); if (name === 'length' && this.isa(obj, this.STRING)) { return true; } if (this.isa(obj, this.STRING)) { var n = Interpreter.legalArrayIndex(name); if (!isNaN(n) && n < String(obj).length) { return true; } } do { if (obj.properties && name in obj.properties) { return true; } } while ((obj = this.getPrototype(obj))); return false; }; /** * Set a property value on a data object. * @param {!Interpreter.Object} obj Data object. * @param {Interpreter.Value} name Name of property. * @param {Interpreter.Value} value New property value. * Use Interpreter.VALUE_IN_DESCRIPTOR if value is handled by * descriptor instead. * @param {Object=} opt_descriptor Optional descriptor object. * @return {!Interpreter.Object|undefined} Returns a setter function if one * needs to be called, otherwise undefined. */ Interpreter.prototype.setProperty = function(obj, name, value, opt_descriptor) { name = String(name); if (obj === undefined || obj === null) { this.throwException(this.TYPE_ERROR, "Cannot set property '" + name + "' of " + obj); } if (opt_descriptor && ('get' in opt_descriptor || 'set' in opt_descriptor) && ('value' in opt_descriptor || 'writable' in opt_descriptor)) { this.throwException(this.TYPE_ERROR, 'Invalid property descriptor. ' + 'Cannot both specify accessors and a value or writable attribute'); } var strict = !this.stateStack || this.getScope().strict; if (!obj.isObject) { if (strict) { this.throwException(this.TYPE_ERROR, "Can't create property '" + name + "' on '" + obj + "'"); } return; } if (this.isa(obj, this.STRING)) { var n = Interpreter.legalArrayIndex(name); if (name === 'length' || (!isNaN(n) && n < String(obj).length)) { // Can't set length or letters on String objects. if (strict) { this.throwException(this.TYPE_ERROR, "Cannot assign to read only " + "property '" + name + "' of String '" + obj.data + "'"); } return; } } if (obj.class === 'Array') { // Arrays have a magic length variable that is bound to the elements. var length = obj.properties.length; var i; if (name === 'length') { // Delete elements if length is smaller. if (opt_descriptor) { if (!('value' in opt_descriptor)) { return; } value = opt_descriptor.value; } value = Interpreter.legalArrayLength(value); if (isNaN(value)) { this.throwException(this.RANGE_ERROR, 'Invalid array length'); } if (value < length) { for (i in obj.properties) { i = Interpreter.legalArrayIndex(i); if (!isNaN(i) && value <= i) { delete obj.properties[i]; } } } } else if (!isNaN(i = Interpreter.legalArrayIndex(name))) { // Increase length if this index is larger. obj.properties.length = Math.max(length, i + 1); } } if (obj.preventExtensions && !(name in obj.properties)) { if (strict) { this.throwException(this.TYPE_ERROR, "Can't add property '" + name + "', object is not extensible"); } return; } if (opt_descriptor) { // Define the property. if ('get' in opt_descriptor) { if (opt_descriptor.get) { obj.getter[name] = opt_descriptor.get; } else { delete obj.getter[name]; } } if ('set' in opt_descriptor) { if (opt_descriptor.set) { obj.setter[name] = opt_descriptor.set; } else { delete obj.setter[name]; } } var descriptor = {}; if ('configurable' in opt_descriptor) { descriptor.configurable = opt_descriptor.configurable; } if ('enumerable' in opt_descriptor) { descriptor.enumerable = opt_descriptor.enumerable; } if ('writable' in opt_descriptor) { descriptor.writable = opt_descriptor.writable; delete obj.getter[name]; delete obj.setter[name]; } if ('value' in opt_descriptor) { descriptor.value = opt_descriptor.value; delete obj.getter[name]; delete obj.setter[name]; } else if (value !== Interpreter.VALUE_IN_DESCRIPTOR) { descriptor.value = value; delete obj.getter[name]; delete obj.setter[name]; } try { Object.defineProperty(obj.properties, name, descriptor); } catch (e) { this.throwException(this.TYPE_ERROR, 'Cannot redefine property: ' + name); } } else { // Set the property. if (value === Interpreter.VALUE_IN_DESCRIPTOR) { throw ReferenceError('Value not specified.'); } // Determine the parent (possibly self) where the property is defined. var defObj = obj; while (!(name in defObj.properties)) { defObj = this.getPrototype(defObj); if (!defObj) { // This is a new property. defObj = obj; break; } } if (defObj.setter && defObj.setter[name]) { return defObj.setter[name]; } if (defObj.getter && defObj.getter[name]) { if (strict) { this.throwException(this.TYPE_ERROR, "Cannot set property '" + name + "' of object '" + obj + "' which only has a getter"); } } else { // No setter, simple assignment. try { obj.properties[name] = value; } catch (e) { if (strict) { this.throwException(this.TYPE_ERROR, "Cannot assign to read only " + "property '" + name + "' of object '" + obj + "'"); } } } } }; /** * Convenience method for adding a native function as a non-enumerable property * onto an object's prototype. * @param {!Interpreter.Object} obj Data object. * @param {Interpreter.Value} name Name of property. * @param {!Function} wrapper Function object. */ Interpreter.prototype.setNativeFunctionPrototype = function(obj, name, wrapper) { this.setProperty(obj.properties['prototype'], name, this.createNativeFunction(wrapper, false), Interpreter.NONENUMERABLE_DESCRIPTOR); }; /** * Returns the current scope from the stateStack. * @return {!Interpreter.Object} Current scope dictionary. */ Interpreter.prototype.getScope = function() { var scope = this.stateStack[this.stateStack.length - 1].scope; if (!scope) { throw Error('No scope found.'); } return scope; }; /** * Create a new scope dictionary. * @param {!Object} node AST node defining the scope container * (e.g. a function). * @param {Interpreter.Object} parentScope Scope to link to. * @return {!Interpreter.Object} New scope. */ Interpreter.prototype.createScope = function(node, parentScope) { var scope = this.createObjectProto(null); scope.parentScope = parentScope; if (!parentScope) { this.initGlobalScope(scope); } this.populateScope_(node, scope); // Determine if this scope starts with 'use strict'. scope.strict = false; if (parentScope && parentScope.strict) { scope.strict = true; } else { var firstNode = node['body'] && node['body'][0]; if (firstNode && firstNode.expression && firstNode.expression['type'] === 'Literal' && firstNode.expression.value === 'use strict') { scope.strict = true; } } return scope; }; /** * Create a new special scope dictionary. Similar to createScope(), but * doesn't assume that the scope is for a function body. * This is used for 'catch' clauses and 'with' statements. * @param {!Interpreter.Object} parentScope Scope to link to. * @param {Interpreter.Object=} opt_scope Optional object to transform into * scope. * @return {!Interpreter.Object} New scope. */ Interpreter.prototype.createSpecialScope = function(parentScope, opt_scope) { if (!parentScope) { throw Error('parentScope required'); } var scope = opt_scope || this.createObjectProto(null); scope.parentScope = parentScope; scope.strict = parentScope.strict; return scope; }; /** * Retrieves a value from the scope chain. * @param {string} name Name of variable. * @param {Acorn AST Node} node Node that triggered this function. Used by Bitburner for getting error line number * @return {Interpreter.Value} Any value. * May be flagged as being a getter and thus needing immediate execution * (rather than being the value of the property). */ Interpreter.prototype.getValueFromScope = function(name, node) { var scope = this.getScope(); while (scope && scope !== this.global) { if (name in scope.properties) { return scope.properties[name]; } scope = scope.parentScope; } // The root scope is also an object which has inherited properties and // could also have getters. if (scope === this.global && this.hasProperty(scope, name)) { return this.getProperty(scope, name); } // Typeof operator is unique: it can safely look at non-defined variables. var prevNode = this.stateStack[this.stateStack.length - 1].node; if (prevNode['type'] === 'UnaryExpression' && prevNode['operator'] === 'typeof') { return undefined; } var lineNum; if (node != null && node.loc != null && node.loc.start != null) { lineNum = node.loc.start.line; } this.throwException(this.REFERENCE_ERROR, name + ' is not defined', lineNum); }; /** * Sets a value to the current scope. * @param {string} name Name of variable. * @param {Interpreter.Value} value Value. * @return {!Interpreter.Object|undefined} Returns a setter function if one * needs to be called, otherwise undefined. */ Interpreter.prototype.setValueToScope = function(name, value) { var scope = this.getScope(); var strict = scope.strict; while (scope && scope !== this.global) { if (name in scope.properties) { scope.properties[name] = value; return undefined; } scope = scope.parentScope; } // The root scope is also an object which has readonly properties and // could also have setters. if (scope === this.global && (!strict || this.hasProperty(scope, name))) { return this.setProperty(scope, name, value); } this.throwException(this.REFERENCE_ERROR, name + ' is not defined'); }; /** * Create a new scope for the given node. * @param {!Object} node AST node (program or function). * @param {!Interpreter.Object} scope Scope dictionary to populate. * @private */ Interpreter.prototype.populateScope_ = function(node, scope) { if (node['type'] === 'VariableDeclaration') { for (var i = 0; i < node['declarations'].length; i++) { this.setProperty(scope, node['declarations'][i]['id']['name'], undefined, Interpreter.VARIABLE_DESCRIPTOR); } } else if (node['type'] === 'FunctionDeclaration') { this.setProperty(scope, node['id']['name'], this.createFunction(node, scope), Interpreter.VARIABLE_DESCRIPTOR); return; // Do not recurse into function. } else if (node['type'] === 'FunctionExpression') { return; // Do not recurse into function. } else if (node['type'] === 'ExpressionStatement') { return; // Expressions can't contain variable/function declarations. } var nodeClass = node['constructor']; for (var name in node) { var prop = node[name]; if (prop && typeof prop === 'object') { if (Array.isArray(prop)) { for (var i = 0; i < prop.length; i++) { if (prop[i] && prop[i].constructor === nodeClass) { this.populateScope_(prop[i], scope); } } } else { if (prop.constructor === nodeClass) { this.populateScope_(prop, scope); } } } } }; /** * Remove start and end values from AST, or set start and end values to a * constant value. Used to remove highlighting from polyfills and to set * highlighting in an eval to cover the entire eval expression. * @param {!Object} node AST node. * @param {number=} start Starting character of all nodes, or undefined. * @param {number=} end Ending character of all nodes, or undefined. * @private */ Interpreter.prototype.stripLocations_ = function(node, start, end) { if (start) { node['start'] = start; } else { delete node['start']; } if (end) { node['end'] = end; } else { delete node['end']; } for (var name in node) { if (node.hasOwnProperty(name)) { var prop = node[name]; if (prop && typeof prop === 'object') { this.stripLocations_(prop, start, end); } } } }; /** * Is the current state directly being called with as a construction with 'new'. * @return {boolean} True if 'new foo()', false if 'foo()'. */ Interpreter.prototype.calledWithNew = function() { return this.stateStack[this.stateStack.length - 1].isConstructor; }; /** * Gets a value from the scope chain or from an object property. * @param {!Array} ref Name of variable or object/propname tuple. * @param {Acorn AST Node} node Node that triggered this function. Used by Bitburner for getting error line number * @return {Interpreter.Value} Any value. * May be flagged as being a getter and thus needing immediate execution * (rather than being the value of the property). */ Interpreter.prototype.getValue = function(ref, node) { if (ref[0] === Interpreter.SCOPE_REFERENCE) { // A null/varname variable lookup. return this.getValueFromScope(ref[1], node); } else { // An obj/prop components tuple (foo.bar). return this.getProperty(ref[0], ref[1], node); } }; /** * Sets a value to the scope chain or to an object property. * @param {!Array} ref Name of variable or object/propname tuple. * @param {Interpreter.Value} value Value. * @return {!Interpreter.Object|undefined} Returns a setter function if one * needs to be called, otherwise undefined. */ Interpreter.prototype.setValue = function(ref, value) { if (ref[0] === Interpreter.SCOPE_REFERENCE) { // A null/varname variable lookup. return this.setValueToScope(ref[1], value); } else { // An obj/prop components tuple (foo.bar). return this.setProperty(ref[0], ref[1], value); } }; /** * Completion Value Types. * @enum {number} */ Interpreter.Completion = { NORMAL: 0, BREAK: 1, CONTINUE: 2, RETURN: 3, THROW: 4 }; /** * Throw an exception in the interpreter that can be handled by an * interpreter try/catch statement. If unhandled, a real exception will * be thrown. Can be called with either an error class and a message, or * with an actual object to be thrown. * @param {!Interpreter.Object} errorClass Type of error (if message is * provided) or the value to throw (if no message). * @param {string=} opt_message Message being thrown. */ Interpreter.prototype.throwException = function(errorClass, opt_message, lineNumber) { if (opt_message === undefined) { var error = errorClass; // This is a value to throw, not an error class. } else { var error = this.createObject(errorClass); this.setProperty(error, 'message', opt_message, Interpreter.NONENUMERABLE_DESCRIPTOR); } var lineNumErrorMsg; if (lineNumber != null) { lineNumErrorMsg = this.getErrorLineNumberMessage(lineNumber); } this.unwind(Interpreter.Completion.THROW, error, undefined, lineNumErrorMsg); // Abort anything related to the current step. throw Interpreter.STEP_ERROR; }; /** * Unwind the stack to the innermost relevant enclosing TryStatement, * For/ForIn/WhileStatement or Call/NewExpression. If this results in * the stack being completely unwound the thread will be terminated * and the appropriate error being thrown. * @param {Interpreter.Completion} type Completion type. * @param {Interpreter.Value=} value Value computed, returned or thrown. * @param {string=} label Target label for break or return. */ Interpreter.prototype.unwind = function(type, value, label, lineNumberMsg="") { if (type === Interpreter.Completion.NORMAL) { throw TypeError('Should not unwind for NORMAL completions'); } for (var stack = this.stateStack; stack.length > 0; stack.pop()) { var state = stack[stack.length - 1]; switch (state.node['type']) { case 'TryStatement': state.cv = {type: type, value: value, label: label}; return; case 'CallExpression': case 'NewExpression': if (type === Interpreter.Completion.RETURN) { state.value = value; return; } else if (type !== Interpreter.Completion.THROW) { throw Error('Unsynatctic break/continue not rejected by Acorn'); } } if (type === Interpreter.Completion.BREAK) { if (label ? (state.labels && state.labels.indexOf(label) !== -1) : (state.isLoop || state.isSwitch)) { stack.pop(); return; } } else if (type === Interpreter.Completion.CONTINUE) { if (label ? (state.labels && state.labels.indexOf(label) !== -1) : state.isLoop) { return; } } } // Unhandled completion. Throw a real error. var realError; if (this.isa(value, this.ERROR)) { var errorTable = { 'EvalError': EvalError, 'RangeError': RangeError, 'ReferenceError': ReferenceError, 'SyntaxError': SyntaxError, 'TypeError': TypeError, 'URIError': URIError }; var name = this.getProperty(value, 'name').toString(); var message = this.getProperty(value, 'message').valueOf(); var type = errorTable[name] || Error; realError = type(message + lineNumberMsg); } else { realError = String(value) + lineNumberMsg; } throw realError; }; /** * Create a call to a getter function. * @param {!Interpreter.Object} func Function to execute. * @param {!Interpreter.Object|!Array} left * Name of variable or object/propname tuple. * @private */ Interpreter.prototype.createGetter_ = function(func, left) { // Normally 'this' will be specified as the object component (o.x). // Sometimes 'this' is explicitly provided (o). var funcThis = Array.isArray(left) ? left[0] : left; var node = new this.nodeConstructor(); node['type'] = 'CallExpression'; var state = new Interpreter.State(node, this.stateStack[this.stateStack.length - 1].scope); state.doneCallee_ = true; state.funcThis_ = funcThis; state.func_ = func; state.doneArgs_ = true; state.arguments_ = []; return state; }; /** * Create a call to a setter function. * @param {!Interpreter.Object} func Function to execute. * @param {!Interpreter.Object|!Array} left * Name of variable or object/propname tuple. * @param {Interpreter.Value} value Value to set. * @private */ Interpreter.prototype.createSetter_ = function(func, left, value) { // Normally 'this' will be specified as the object component (o.x). // Sometimes 'this' is implicitly the global object (x). var funcThis = Array.isArray(left) ? left[0] : this.global; var node = new this.nodeConstructor(); node['type'] = 'CallExpression'; var state = new Interpreter.State(node, this.stateStack[this.stateStack.length - 1].scope); state.doneCallee_ = true; state.funcThis_ = funcThis; state.func_ = func; state.doneArgs_ = true; state.arguments_ = [value]; return state; }; /** * Class for a state. * @param {!Object} node AST node for the state. * @param {!Interpreter.Object} scope Scope object for the state. * @constructor */ Interpreter.State = function(node, scope) { this.node = node; this.scope = scope; }; /////////////////////////////////////////////////////////////////////////////// // Functions to handle each node type. /////////////////////////////////////////////////////////////////////////////// Interpreter.prototype['stepArrayExpression'] = function(stack, state, node) { var elements = node['elements']; var n = state.n_ || 0; if (!state.array_) { state.array_ = this.createObjectProto(this.ARRAY_PROTO); state.array_.properties.length = elements.length; } else { this.setProperty(state.array_, n, state.value); n++; } while (n < elements.length) { // Skip missing elements - they're not defined, not undefined. if (elements[n]) { state.n_ = n; return new Interpreter.State(elements[n], state.scope); } n++; } stack.pop(); stack[stack.length - 1].value = state.array_; }; Interpreter.prototype['stepAssignmentExpression'] = function(stack, state, node) { if (!state.doneLeft_) { state.doneLeft_ = true; var nextState = new Interpreter.State(node['left'], state.scope); nextState.components = true; return nextState; } if (!state.doneRight_) { if (!state.leftReference_) { state.leftReference_ = state.value; } if (state.doneGetter_) { state.leftValue_ = state.value; } if (!state.doneGetter_ && node['operator'] !== '=') { var leftValue = this.getValue(state.leftReference_, node); state.leftValue_ = leftValue; if (leftValue && typeof leftValue === 'object' && leftValue.isGetter) { // Clear the getter flag and call the getter function. leftValue.isGetter = false; state.doneGetter_ = true; var func = /** @type {!Interpreter.Object} */ (leftValue); return this.createGetter_(func, state.leftReference_); } } state.doneRight_ = true; return new Interpreter.State(node['right'], state.scope); } if (state.doneSetter_) { // Return if setter function. // Setter method on property has completed. // Ignore its return value, and use the original set value instead. stack.pop(); stack[stack.length - 1].value = state.setterValue_; return; } var value = state.leftValue_; var rightValue = state.value; switch (node['operator']) { case '=': value = rightValue; break; case '+=': value += rightValue; break; case '-=': value -= rightValue; break; case '*=': value *= rightValue; break; case '/=': value /= rightValue; break; case '%=': value %= rightValue; break; case '<<=': value <<= rightValue; break; case '>>=': value >>= rightValue; break; case '>>>=': value >>>= rightValue; break; case '&=': value &= rightValue; break; case '^=': value ^= rightValue; break; case '|=': value |= rightValue; break; default: throw SyntaxError('Unknown assignment expression: ' + node['operator']); } var setter = this.setValue(state.leftReference_, value); if (setter) { state.doneSetter_ = true; state.setterValue_ = value; return this.createSetter_(setter, state.leftReference_, value); } // Return if no setter function. stack.pop(); stack[stack.length - 1].value = value; }; Interpreter.prototype['stepBinaryExpression'] = function(stack, state, node) { if (!state.doneLeft_) { state.doneLeft_ = true; return new Interpreter.State(node['left'], state.scope); } if (!state.doneRight_) { state.doneRight_ = true; state.leftValue_ = state.value; return new Interpreter.State(node['right'], state.scope); } stack.pop(); var leftValue = state.leftValue_; var rightValue = state.value; var value; switch (node['operator']) { case '==': value = leftValue == rightValue; break; case '!=': value = leftValue != rightValue; break; case '===': value = leftValue === rightValue; break; case '!==': value = leftValue !== rightValue; break; case '>': value = leftValue > rightValue; break; case '>=': value = leftValue >= rightValue; break; case '<': value = leftValue < rightValue; break; case '<=': value = leftValue <= rightValue; break; case '+': value = leftValue + rightValue; break; case '-': value = leftValue - rightValue; break; case '*': value = leftValue * rightValue; break; case '/': value = leftValue / rightValue; break; case '%': value = leftValue % rightValue; break; case '&': value = leftValue & rightValue; break; case '|': value = leftValue | rightValue; break; case '^': value = leftValue ^ rightValue; break; case '<<': value = leftValue << rightValue; break; case '>>': value = leftValue >> rightValue; break; case '>>>': value = leftValue >>> rightValue; break; case 'in': if (!rightValue || !rightValue.isObject) { let lineNum = this.getErrorLineNumber(node); this.throwException(this.TYPE_ERROR, "'in' expects an object, not '" + rightValue + "'", lineNum); } value = this.hasProperty(rightValue, leftValue); break; case 'instanceof': if (!this.isa(rightValue, this.FUNCTION)) { let lineNum = this.getErrorLineNumber(node); this.throwException(this.TYPE_ERROR, 'Right-hand side of instanceof is not an object', lineNum); } value = leftValue.isObject ? this.isa(leftValue, rightValue) : false; break; default: throw SyntaxError('Unknown binary operator: ' + node['operator']); } stack[stack.length - 1].value = value; }; Interpreter.prototype['stepBlockStatement'] = function(stack, state, node) { var n = state.n_ || 0; var expression = node['body'][n]; if (expression) { state.n_ = n + 1; return new Interpreter.State(expression, state.scope); } stack.pop(); }; Interpreter.prototype['stepBreakStatement'] = function(stack, state, node) { var label = node['label'] && node['label']['name']; this.unwind(Interpreter.Completion.BREAK, undefined, label); }; Interpreter.prototype['stepCallExpression'] = function(stack, state, node) { if (!state.doneCallee_) { state.doneCallee_ = 1; // Components needed to determine value of 'this'. var nextState = new Interpreter.State(node['callee'], state.scope); nextState.components = true; return nextState; } if (state.doneCallee_ === 1) { // Determine value of the function. state.doneCallee_ = 2; var func = state.value; if (Array.isArray(func)) { state.func_ = this.getValue(func, node); if (func[0] === Interpreter.SCOPE_REFERENCE) { // (Globally or locally) named function. Is it named 'eval'? state.directEval_ = (func[1] === 'eval'); } else { // Method function, 'this' is object (ignored if invoked as 'new'). state.funcThis_ = func[0]; } func = state.func_; if (func && typeof func === 'object' && func.isGetter) { // Clear the getter flag and call the getter function. func.isGetter = false; state.doneCallee_ = 1; return this.createGetter_(/** @type {!Interpreter.Object} */ (func), state.value); } } else { // Already evaluated function: (function(){...})(); state.func_ = func; } state.arguments_ = []; state.n_ = 0; } var func = state.func_; if (!state.doneArgs_) { if (state.n_ !== 0) { state.arguments_.push(state.value); } if (node['arguments'][state.n_]) { return new Interpreter.State(node['arguments'][state.n_++], state.scope); } // Determine value of 'this' in function. if (node['type'] === 'NewExpression') { if (func.illegalConstructor) { // Illegal: new escape(); let lineNum = this.getErrorLineNumber(node); this.throwException(this.TYPE_ERROR, func + ' is not a constructor', lineNum); } // Constructor, 'this' is new object. var proto = func.properties['prototype']; if (typeof proto !== 'object' || proto === null) { // Non-object prototypes default to Object.prototype. proto = this.OBJECT_PROTO; } state.funcThis_ = this.createObjectProto(proto); state.isConstructor = true; } else if (state.funcThis_ === undefined) { // Global function, 'this' is global object (or 'undefined' if strict). state.funcThis_ = state.scope.strict ? undefined : this.global; } state.doneArgs_ = true; } if (!state.doneExec_) { state.doneExec_ = true; if (!func || !func.isObject) { let lineNum = this.getErrorLineNumber(node); this.throwException(this.TYPE_ERROR, func + ' is not a function', lineNum); } var funcNode = func.node; if (funcNode) { var scope = this.createScope(funcNode['body'], func.parentScope); // Add all arguments. for (var i = 0; i < funcNode['params'].length; i++) { var paramName = funcNode['params'][i]['name']; var paramValue = state.arguments_.length > i ? state.arguments_[i] : undefined; this.setProperty(scope, paramName, paramValue); } // Build arguments variable. var argsList = this.createObjectProto(this.ARRAY_PROTO); for (var i = 0; i < state.arguments_.length; i++) { this.setProperty(argsList, i, state.arguments_[i]); } this.setProperty(scope, 'arguments', argsList); // Add the function's name (var x = function foo(){};) var name = funcNode['id'] && funcNode['id']['name']; if (name) { this.setProperty(scope, name, func); } this.setProperty(scope, 'this', state.funcThis_, Interpreter.READONLY_DESCRIPTOR); state.value = undefined; // Default value if no explicit return. return new Interpreter.State(funcNode['body'], scope); } else if (func.eval) { var code = state.arguments_[0]; if (typeof code !== 'string') { // JS does not parse String objects: // eval(new String('1 + 1')) -> '1 + 1' state.value = code; } else { try { var ast = acorn.parse(code.toString(), Interpreter.PARSE_OPTIONS); } catch (e) { // Acorn threw a SyntaxError. Rethrow as a trappable error. let lineNum = this.getErrorLineNumber(node); this.throwException(this.SYNTAX_ERROR, 'Invalid code: ' + e.message, lineNum); } var evalNode = new this.nodeConstructor(); evalNode['type'] = 'EvalProgram_'; evalNode['body'] = ast['body']; this.stripLocations_(evalNode, node['start'], node['end']); // Create new scope and update it with definitions in eval(). var scope = state.directEval_ ? state.scope : this.global; if (scope.strict) { // Strict mode get its own scope in eval. scope = this.createScope(ast, scope); } else { // Non-strict mode pollutes the current scope. this.populateScope_(ast, scope); } this.value = undefined; // Default value if no code. return new Interpreter.State(evalNode, scope); } } else if (func.nativeFunc) { state.value = func.nativeFunc.apply(state.funcThis_, state.arguments_); } else if (func.asyncFunc) { var thisInterpreter = this; var callback = function(value) { state.value = value; thisInterpreter.paused_ = false; }; var argsWithCallback = state.arguments_.concat(callback); this.paused_ = true; func.asyncFunc.apply(state.funcThis_, argsWithCallback); return; } else { /* A child of a function is a function but is not callable. For example: var F = function() {}; F.prototype = escape; var f = new F(); f(); */ let lineNum = this.getErrorLineNumber(node); this.throwException(this.TYPE_ERROR, func.class + ' is not a function', lineNum); } } else { // Execution complete. Put the return value on the stack. stack.pop(); if (state.isConstructor && typeof state.value !== 'object') { stack[stack.length - 1].value = state.funcThis_; } else { stack[stack.length - 1].value = state.value; } } }; Interpreter.prototype['stepCatchClause'] = function(stack, state, node) { if (!state.done_) { state.done_ = true; // Create an empty scope. var scope = this.createSpecialScope(state.scope); // Add the argument. this.setProperty(scope, node['param']['name'], state.throwValue); // Execute catch clause. return new Interpreter.State(node['body'], scope); } else { stack.pop(); } }; Interpreter.prototype['stepConditionalExpression'] = function(stack, state, node) { var mode = state.mode_ || 0; if (mode === 0) { state.mode_ = 1; return new Interpreter.State(node['test'], state.scope); } if (mode === 1) { state.mode_ = 2; var value = Boolean(state.value); if (value && node['consequent']) { // Execute 'if' block. return new Interpreter.State(node['consequent'], state.scope); } else if (!value && node['alternate']) { // Execute 'else' block. return new Interpreter.State(node['alternate'], state.scope); } // eval('1;if(false){2}') -> undefined this.value = undefined; } stack.pop(); if (node['type'] === 'ConditionalExpression') { stack[stack.length - 1].value = state.value; } }; Interpreter.prototype['stepContinueStatement'] = function(stack, state, node) { var label = node['label'] && node['label']['name']; this.unwind(Interpreter.Completion.CONTINUE, undefined, label); }; Interpreter.prototype['stepDebuggerStatement'] = function(stack, state, node) { // Do nothing. May be overridden by developers. stack.pop(); }; Interpreter.prototype['stepDoWhileStatement'] = function(stack, state, node) { if (node['type'] === 'DoWhileStatement' && state.test_ === undefined) { // First iteration of do/while executes without checking test. state.value = true; state.test_ = true; } if (!state.test_) { state.test_ = true; return new Interpreter.State(node['test'], state.scope); } if (!state.value) { // Done, exit loop. stack.pop(); } else if (node['body']) { // Execute the body. state.test_ = false; state.isLoop = true; return new Interpreter.State(node['body'], state.scope); } }; Interpreter.prototype['stepEmptyStatement'] = function(stack, state, node) { stack.pop(); }; Interpreter.prototype['stepEvalProgram_'] = function(stack, state, node) { var n = state.n_ || 0; var expression = node['body'][n]; if (expression) { state.n_ = n + 1; return new Interpreter.State(expression, state.scope); } stack.pop(); stack[stack.length - 1].value = this.value; }; Interpreter.prototype['stepExpressionStatement'] = function(stack, state, node) { if (!state.done_) { state.done_ = true; return new Interpreter.State(node['expression'], state.scope); } stack.pop(); // Save this value to interpreter.value for use as a return value if // this code is inside an eval function. this.value = state.value; }; Interpreter.prototype['stepForInStatement'] = function(stack, state, node) { // First, initialize a variable if exists. Only do so once, ever. if (!state.doneInit_) { state.doneInit_ = true; if (node['left']['declarations'] && node['left']['declarations'][0]['init']) { if (state.scope.strict) { let lineNum = this.getErrorLineNumber(node); this.throwException(this.SYNTAX_ERROR, 'for-in loop variable declaration may not have an initializer.', lineNum); } // Variable initialization: for (var x = 4 in y) return new Interpreter.State(node['left'], state.scope); } } // Second, look up the object. Only do so once, ever. if (!state.doneObject_) { state.doneObject_ = true; if (!state.variable_) { state.variable_ = state.value; } return new Interpreter.State(node['right'], state.scope); } if (!state.isLoop) { // First iteration. state.isLoop = true; state.object_ = state.value; state.visited_ = Object.create(null); } // Third, find the property name for this iteration. if (state.name_ === undefined) { gotPropName: while (true) { if (state.object_ && state.object_.isObject) { if (!state.props_) { state.props_ = Object.getOwnPropertyNames(state.object_.properties); } while (true) { var prop = state.props_.shift(); if (prop === undefined) { break; // Reached end of this object's properties. } if (!Object.prototype.hasOwnProperty.call(state.object_.properties, prop)) { continue; // Property has been deleted in the loop. } if (state.visited_[prop]) { continue; // Already seen this property on a child. } state.visited_[prop] = true; if (!Object.prototype.propertyIsEnumerable.call( state.object_.properties, prop)) { continue; // Skip non-enumerable property. } state.name_ = prop; break gotPropName; } } else if (state.object_ !== null && state.object_ !== undefined) { // Primitive value (other than null or undefined). if (!state.props_) { state.props_ = Object.getOwnPropertyNames(state.object_); } while (true) { var prop = state.props_.shift(); if (prop === undefined) { break; // Reached end of this value's properties. } state.visited_[prop] = true; if (!Object.prototype.propertyIsEnumerable.call( state.object_, prop)) { continue; // Skip non-enumerable property. } state.name_ = prop; break gotPropName; } } state.object_ = this.getPrototype(state.object_); state.props_ = null; if (state.object_ === null) { // Done, exit loop. stack.pop(); return; } } } // Fourth, find the variable if (!state.doneVariable_) { state.doneVariable_ = true; var left = node['left']; if (left['type'] === 'VariableDeclaration') { // Inline variable declaration: for (var x in y) state.variable_ = [Interpreter.SCOPE_REFERENCE, left['declarations'][0]['id']['name']]; } else { // Arbitrary left side: for (foo().bar in y) state.variable_ = null; var nextState = new Interpreter.State(left, state.scope); nextState.components = true; return nextState; } } if (!state.variable_) { state.variable_ = state.value; } // Fifth, set the variable. if (!state.doneSetter_) { state.doneSetter_ = true; var value = state.name_; var setter = this.setValue(state.variable_, value); if (setter) { return this.createSetter_(setter, state.variable_, value); } } // Next step will be step three. state.name_ = undefined; // Reevaluate the variable since it could be a setter on the global object. state.doneVariable_ = false; state.doneSetter_ = false; // Sixth and finally, execute the body if there was one. this. if (node['body']) { return new Interpreter.State(node['body'], state.scope); } }; Interpreter.prototype['stepForStatement'] = function(stack, state, node) { var mode = state.mode_ || 0; if (mode === 0) { state.mode_ = 1; if (node['init']) { return new Interpreter.State(node['init'], state.scope); } } else if (mode === 1) { state.mode_ = 2; if (node['test']) { return new Interpreter.State(node['test'], state.scope); } } else if (mode === 2) { state.mode_ = 3; if (node['test'] && !state.value) { // Done, exit loop. stack.pop(); } else { // Execute the body. state.isLoop = true; return new Interpreter.State(node['body'], state.scope); } } else if (mode === 3) { state.mode_ = 1; if (node['update']) { return new Interpreter.State(node['update'], state.scope); } } }; Interpreter.prototype['stepFunctionDeclaration'] = function(stack, state, node) { // This was found and handled when the scope was populated. stack.pop(); }; Interpreter.prototype['stepFunctionExpression'] = function(stack, state, node) { stack.pop(); stack[stack.length - 1].value = this.createFunction(node, state.scope); }; Interpreter.prototype['stepIdentifier'] = function(stack, state, node) { stack.pop(); if (state.components) { stack[stack.length - 1].value = [Interpreter.SCOPE_REFERENCE, node['name']]; return; } var value = this.getValueFromScope(node['name'], node); // An identifier could be a getter if it's a property on the global object. if (value && typeof value === 'object' && value.isGetter) { // Clear the getter flag and call the getter function. value.isGetter = false; var scope = state.scope; while (!this.hasProperty(scope, node['name'])) { scope = scope.parentScope; } var func = /** @type {!Interpreter.Object} */ (value); return this.createGetter_(func, this.global); } stack[stack.length - 1].value = value; }; Interpreter.prototype['stepIfStatement'] = Interpreter.prototype['stepConditionalExpression']; Interpreter.prototype['stepLabeledStatement'] = function(stack, state, node) { // No need to hit this node again on the way back up the stack. stack.pop(); // Note that a statement might have multiple labels. var labels = state.labels || []; labels.push(node['label']['name']); var nextState = new Interpreter.State(node['body'], state.scope); nextState.labels = labels; return nextState; }; Interpreter.prototype['stepLiteral'] = function(stack, state, node) { stack.pop(); var value = node['value']; if (value instanceof RegExp) { var pseudoRegexp = this.createObjectProto(this.REGEXP_PROTO); this.populateRegExp(pseudoRegexp, value); value = pseudoRegexp; } stack[stack.length - 1].value = value; }; Interpreter.prototype['stepLogicalExpression'] = function(stack, state, node) { if (node['operator'] !== '&&' && node['operator'] !== '||') { throw SyntaxError('Unknown logical operator: ' + node['operator']); } if (!state.doneLeft_) { state.doneLeft_ = true; return new Interpreter.State(node['left'], state.scope); } if (!state.doneRight_) { if ((node['operator'] === '&&' && !state.value) || (node['operator'] === '||' && state.value)) { // Shortcut evaluation. stack.pop(); stack[stack.length - 1].value = state.value; } else { state.doneRight_ = true; return new Interpreter.State(node['right'], state.scope); } } else { stack.pop(); stack[stack.length - 1].value = state.value; } }; Interpreter.prototype['stepMemberExpression'] = function(stack, state, node) { if (!state.doneObject_) { state.doneObject_ = true; return new Interpreter.State(node['object'], state.scope); } var propName; if (!node['computed']) { state.object_ = state.value; // obj.foo -- Just access 'foo' directly. propName = node['property']['name']; } else if (!state.doneProperty_) { state.object_ = state.value; // obj[foo] -- Compute value of 'foo'. state.doneProperty_ = true; return new Interpreter.State(node['property'], state.scope); } else { propName = state.value; } stack.pop(); if (state.components) { stack[stack.length - 1].value = [state.object_, propName]; } else { var value = this.getProperty(state.object_, propName); if (value && typeof value === 'object' && value.isGetter) { // Clear the getter flag and call the getter function. value.isGetter = false; var func = /** @type {!Interpreter.Object} */ (value); return this.createGetter_(func, state.object_); } stack[stack.length - 1].value = value; } }; Interpreter.prototype['stepNewExpression'] = Interpreter.prototype['stepCallExpression']; Interpreter.prototype['stepObjectExpression'] = function(stack, state, node) { var n = state.n_ || 0; var property = node['properties'][n]; if (!state.object_) { // First execution. state.object_ = this.createObjectProto(this.OBJECT_PROTO); state.properties_ = Object.create(null); } else { // Determine property name. var key = property['key']; if (key['type'] === 'Identifier') { var propName = key['name']; } else if (key['type'] === 'Literal') { var propName = key['value']; } else { throw SyntaxError('Unknown object structure: ' + key['type']); } // Set the property computed in the previous execution. if (!state.properties_[propName]) { // Create temp object to collect value, getter, and/or setter. state.properties_[propName] = {}; } state.properties_[propName][property['kind']] = state.value; state.n_ = ++n; property = node['properties'][n]; } if (property) { return new Interpreter.State(property['value'], state.scope); } for (var key in state.properties_) { var kinds = state.properties_[key]; if ('get' in kinds || 'set' in kinds) { // Set a property with a getter or setter. var descriptor = { configurable: true, enumerable: true, get: kinds['get'], set: kinds['set'] }; this.setProperty(state.object_, key, null, descriptor); } else { // Set a normal property with a value. this.setProperty(state.object_, key, kinds['init']); } } stack.pop(); stack[stack.length - 1].value = state.object_; }; Interpreter.prototype['stepProgram'] = function(stack, state, node) { var expression = node['body'].shift(); if (expression) { state.done = false; return new Interpreter.State(expression, state.scope); } state.done = true; // Don't pop the stateStack. // Leave the root scope on the tree in case the program is appended to. }; Interpreter.prototype['stepReturnStatement'] = function(stack, state, node) { if (node['argument'] && !state.done_) { state.done_ = true; return new Interpreter.State(node['argument'], state.scope); } this.unwind(Interpreter.Completion.RETURN, state.value, undefined); }; Interpreter.prototype['stepSequenceExpression'] = function(stack, state, node) { var n = state.n_ || 0; var expression = node['expressions'][n]; if (expression) { state.n_ = n + 1; return new Interpreter.State(expression, state.scope); } stack.pop(); stack[stack.length - 1].value = state.value; }; Interpreter.prototype['stepSwitchStatement'] = function(stack, state, node) { if (!state.test_) { state.test_ = 1; return new Interpreter.State(node['discriminant'], state.scope); } if (state.test_ === 1) { state.test_ = 2; // Preserve switch value between case tests. state.switchValue_ = state.value; state.defaultCase_ = -1; } while (true) { var index = state.index_ || 0; var switchCase = node['cases'][index]; if (!state.matched_ && switchCase && !switchCase['test']) { // Test on the default case is null. // Bypass (but store) the default case, and get back to it later. state.defaultCase_ = index; state.index_ = index + 1; continue; } if (!switchCase && !state.matched_ && state.defaultCase_ !== -1) { // Ran through all cases, no match. Jump to the default. state.matched_ = true; state.index_ = state.defaultCase_; continue; } if (switchCase) { if (!state.matched_ && !state.tested_ && switchCase['test']) { state.tested_ = true; return new Interpreter.State(switchCase['test'], state.scope); } if (state.matched_ || state.value === state.switchValue_) { state.matched_ = true; var n = state.n_ || 0; if (switchCase['consequent'][n]) { state.isSwitch = true; state.n_ = n + 1; return new Interpreter.State(switchCase['consequent'][n], state.scope); } } // Move on to next case. state.tested_ = false; state.n_ = 0; state.index_ = index + 1; } else { stack.pop(); return; } } }; Interpreter.prototype['stepThisExpression'] = function(stack, state, node) { stack.pop(); stack[stack.length - 1].value = this.getValueFromScope('this', node); }; Interpreter.prototype['stepThrowStatement'] = function(stack, state, node) { if (!state.done_) { state.done_ = true; return new Interpreter.State(node['argument'], state.scope); } else { this.throwException(state.value); } }; Interpreter.prototype['stepTryStatement'] = function(stack, state, node) { if (!state.doneBlock_) { state.doneBlock_ = true; return new Interpreter.State(node['block'], state.scope); } if (state.cv && state.cv.type === Interpreter.Completion.THROW && !state.doneHandler_ && node['handler']) { state.doneHandler_ = true; var nextState = new Interpreter.State(node['handler'], state.scope); nextState.throwValue = state.cv.value; state.cv = undefined; // This error has been handled, don't rethrow. return nextState; } if (!state.doneFinalizer_ && node['finalizer']) { state.doneFinalizer_ = true; return new Interpreter.State(node['finalizer'], state.scope); } stack.pop(); if (state.cv) { // There was no catch handler, or the catch/finally threw an error. // Throw the error up to a higher try. this.unwind(state.cv.type, state.cv.value, state.cv.label); } }; Interpreter.prototype['stepUnaryExpression'] = function(stack, state, node) { if (!state.done_) { state.done_ = true; var nextState = new Interpreter.State(node['argument'], state.scope); nextState.components = node['operator'] === 'delete'; return nextState; } stack.pop(); var value = state.value; if (node['operator'] === '-') { value = -value; } else if (node['operator'] === '+') { value = +value; } else if (node['operator'] === '!') { value = !value; } else if (node['operator'] === '~') { value = ~value; } else if (node['operator'] === 'delete') { var result = true; // If value is not an array, then it is a primitive, or some other value. // If so, skip the delete and return true. if (Array.isArray(value)) { var obj = value[0]; if (obj === Interpreter.SCOPE_REFERENCE) { // 'delete foo;' is the same as 'delete window.foo'. obj = state.scope; } var name = String(value[1]); try { delete obj.properties[name]; } catch (e) { if (state.scope.strict) { this.throwException(this.TYPE_ERROR, "Cannot delete property '" + name + "' of '" + obj + "'"); } else { result = false; } } } value = result; } else if (node['operator'] === 'typeof') { value = (value && value.class === 'Function') ? 'function' : typeof value; } else if (node['operator'] === 'void') { value = undefined; } else { throw SyntaxError('Unknown unary operator: ' + node['operator']); } stack[stack.length - 1].value = value; }; Interpreter.prototype['stepUpdateExpression'] = function(stack, state, node) { if (!state.doneLeft_) { state.doneLeft_ = true; var nextState = new Interpreter.State(node['argument'], state.scope); nextState.components = true; return nextState; } if (!state.leftSide_) { state.leftSide_ = state.value; } if (state.doneGetter_) { state.leftValue_ = state.value; } if (!state.doneGetter_) { var leftValue = this.getValue(state.leftSide_, node); state.leftValue_ = leftValue; if (leftValue && typeof leftValue === 'object' && leftValue.isGetter) { // Clear the getter flag and call the getter function. leftValue.isGetter = false; state.doneGetter_ = true; var func = /** @type {!Interpreter.Object} */ (leftValue); return this.createGetter_(func, state.leftSide_); } } if (state.doneSetter_) { // Return if setter function. // Setter method on property has completed. // Ignore its return value, and use the original set value instead. stack.pop(); stack[stack.length - 1].value = state.setterValue_; return; } var leftValue = Number(state.leftValue_); var changeValue; if (node['operator'] === '++') { changeValue = leftValue + 1; } else if (node['operator'] === '--') { changeValue = leftValue - 1; } else { throw SyntaxError('Unknown update expression: ' + node['operator']); } var returnValue = node['prefix'] ? changeValue : leftValue; var setter = this.setValue(state.leftSide_, changeValue); if (setter) { state.doneSetter_ = true; state.setterValue_ = returnValue; return this.createSetter_(setter, state.leftSide_, changeValue); } // Return if no setter function. stack.pop(); stack[stack.length - 1].value = returnValue; }; Interpreter.prototype['stepVariableDeclaration'] = function(stack, state, node) { var declarations = node['declarations']; var n = state.n_ || 0; var declarationNode = declarations[n]; if (state.init_ && declarationNode) { // This setValue call never needs to deal with calling a setter function. // Note that this is setting the init value, not defining the variable. // Variable definition is done when scope is populated. this.setValueToScope(declarationNode['id']['name'], state.value); state.init_ = false; declarationNode = declarations[++n]; } while (declarationNode) { // Skip any declarations that are not initialized. They have already // been defined as undefined in populateScope_. if (declarationNode['init']) { state.n_ = n; state.init_ = true; return new Interpreter.State(declarationNode['init'], state.scope); } declarationNode = declarations[++n]; } stack.pop(); }; Interpreter.prototype['stepWithStatement'] = function(stack, state, node) { if (!state.doneObject_) { state.doneObject_ = true; return new Interpreter.State(node['object'], state.scope); } else if (!state.doneBody_) { state.doneBody_ = true; var scope = this.createSpecialScope(state.scope, state.value); return new Interpreter.State(node['body'], scope); } else { stack.pop(); } }; Interpreter.prototype['stepWhileStatement'] = Interpreter.prototype['stepDoWhileStatement']; // Preserve top-level API functions from being pruned/renamed by JS compilers. // Add others as needed. // The global object ('window' in a browser, 'global' in node.js) is 'this'. //this['Interpreter'] = Interpreter; Interpreter.prototype['step'] = Interpreter.prototype.step; Interpreter.prototype['run'] = Interpreter.prototype.run; Interpreter.prototype['appendCode'] = Interpreter.prototype.appendCode; Interpreter.prototype['createObject'] = Interpreter.prototype.createObject; Interpreter.prototype['createObjectProto'] = Interpreter.prototype.createObjectProto; Interpreter.prototype['createAsyncFunction'] = Interpreter.prototype.createAsyncFunction; Interpreter.prototype['createNativeFunction'] = Interpreter.prototype.createNativeFunction; Interpreter.prototype['getProperty'] = Interpreter.prototype.getProperty; Interpreter.prototype['setProperty'] = Interpreter.prototype.setProperty; Interpreter.prototype['nativeToPseudo'] = Interpreter.prototype.nativeToPseudo; Interpreter.prototype['pseudoToNative'] = Interpreter.prototype.pseudoToNative; // Obsolete. Do not use. Interpreter.prototype['createPrimitive'] = function(x) {return x;}; export {Interpreter};