evaljs
Version:
A JavaScript interpreter written in JavaScript
2,492 lines • 71.7 kB
JavaScript
/**
* Copyright (c) 2014, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* https://raw.github.com/facebook/regenerator/master/LICENSE file. An
* additional grant of patent rights can be found in the PATENTS file in
* the same directory.
*/
!(function(global) {
"use strict";
var Op = Object.prototype;
var hasOwn = Op.hasOwnProperty;
var undefined; // More compressible than void 0.
var $Symbol = typeof Symbol === "function" ? Symbol : {};
var iteratorSymbol = $Symbol.iterator || "@@iterator";
var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
var inModule = typeof module === "object";
var runtime = global.regeneratorRuntime;
if (runtime) {
if (inModule) {
// If regeneratorRuntime is defined globally and we're in a module,
// make the exports object identical to regeneratorRuntime.
module.exports = runtime;
}
// Don't bother evaluating the rest of this file if the runtime was
// already defined globally.
return;
}
// Define the runtime globally (as expected by generated code) as either
// module.exports (if we're in a module) or a new, empty object.
runtime = global.regeneratorRuntime = inModule ? module.exports : {};
function wrap(innerFn, outerFn, self, tryLocsList) {
// If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
var generator = Object.create(protoGenerator.prototype);
var context = new Context(tryLocsList || []);
// The ._invoke method unifies the implementations of the .next,
// .throw, and .return methods.
generator._invoke = makeInvokeMethod(innerFn, self, context);
return generator;
}
runtime.wrap = wrap;
// Try/catch helper to minimize deoptimizations. Returns a completion
// record like context.tryEntries[i].completion. This interface could
// have been (and was previously) designed to take a closure to be
// invoked without arguments, but in all the cases we care about we
// already have an existing method we want to call, so there's no need
// to create a new function object. We can even get away with assuming
// the method takes exactly one argument, since that happens to be true
// in every case, so we don't have to touch the arguments object. The
// only additional allocation required is the completion record, which
// has a stable shape and so hopefully should be cheap to allocate.
function tryCatch(fn, obj, arg) {
try {
return { type: "normal", arg: fn.call(obj, arg) };
} catch (err) {
return { type: "throw", arg: err };
}
}
var GenStateSuspendedStart = "suspendedStart";
var GenStateSuspendedYield = "suspendedYield";
var GenStateExecuting = "executing";
var GenStateCompleted = "completed";
// Returning this object from the innerFn has the same effect as
// breaking out of the dispatch switch statement.
var ContinueSentinel = {};
// Dummy constructor functions that we use as the .constructor and
// .constructor.prototype properties for functions that return Generator
// objects. For full spec compliance, you may wish to configure your
// minifier not to mangle the names of these two functions.
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
// This is a polyfill for %IteratorPrototype% for environments that
// don't natively support it.
var IteratorPrototype = {};
IteratorPrototype[iteratorSymbol] = function () {
return this;
};
var getProto = Object.getPrototypeOf;
var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
if (NativeIteratorPrototype &&
NativeIteratorPrototype !== Op &&
hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
// This environment has a native %IteratorPrototype%; use it instead
// of the polyfill.
IteratorPrototype = NativeIteratorPrototype;
}
var Gp = GeneratorFunctionPrototype.prototype =
Generator.prototype = Object.create(IteratorPrototype);
GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
GeneratorFunctionPrototype.constructor = GeneratorFunction;
GeneratorFunctionPrototype[toStringTagSymbol] =
GeneratorFunction.displayName = "GeneratorFunction";
// Helper for defining the .next, .throw, and .return methods of the
// Iterator interface in terms of a single ._invoke method.
function defineIteratorMethods(prototype) {
["next", "throw", "return"].forEach(function(method) {
prototype[method] = function(arg) {
return this._invoke(method, arg);
};
});
}
runtime.isGeneratorFunction = function(genFun) {
var ctor = typeof genFun === "function" && genFun.constructor;
return ctor
? ctor === GeneratorFunction ||
// For the native GeneratorFunction constructor, the best we can
// do is to check its .name property.
(ctor.displayName || ctor.name) === "GeneratorFunction"
: false;
};
runtime.mark = function(genFun) {
if (Object.setPrototypeOf) {
Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
} else {
genFun.__proto__ = GeneratorFunctionPrototype;
if (!(toStringTagSymbol in genFun)) {
genFun[toStringTagSymbol] = "GeneratorFunction";
}
}
genFun.prototype = Object.create(Gp);
return genFun;
};
// Within the body of any async function, `await x` is transformed to
// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
// `hasOwn.call(value, "__await")` to determine if the yielded value is
// meant to be awaited.
runtime.awrap = function(arg) {
return { __await: arg };
};
function AsyncIterator(generator) {
function invoke(method, arg, resolve, reject) {
var record = tryCatch(generator[method], generator, arg);
if (record.type === "throw") {
reject(record.arg);
} else {
var result = record.arg;
var value = result.value;
if (value &&
typeof value === "object" &&
hasOwn.call(value, "__await")) {
return Promise.resolve(value.__await).then(function(value) {
invoke("next", value, resolve, reject);
}, function(err) {
invoke("throw", err, resolve, reject);
});
}
return Promise.resolve(value).then(function(unwrapped) {
// When a yielded Promise is resolved, its final value becomes
// the .value of the Promise<{value,done}> result for the
// current iteration. If the Promise is rejected, however, the
// result for this iteration will be rejected with the same
// reason. Note that rejections of yielded Promises are not
// thrown back into the generator function, as is the case
// when an awaited Promise is rejected. This difference in
// behavior between yield and await is important, because it
// allows the consumer to decide what to do with the yielded
// rejection (swallow it and continue, manually .throw it back
// into the generator, abandon iteration, whatever). With
// await, by contrast, there is no opportunity to examine the
// rejection reason outside the generator function, so the
// only option is to throw it from the await expression, and
// let the generator function handle the exception.
result.value = unwrapped;
resolve(result);
}, reject);
}
}
if (typeof process === "object" && process.domain) {
invoke = process.domain.bind(invoke);
}
var previousPromise;
function enqueue(method, arg) {
function callInvokeWithMethodAndArg() {
return new Promise(function(resolve, reject) {
invoke(method, arg, resolve, reject);
});
}
return previousPromise =
// If enqueue has been called before, then we want to wait until
// all previous Promises have been resolved before calling invoke,
// so that results are always delivered in the correct order. If
// enqueue has not been called before, then it is important to
// call invoke immediately, without waiting on a callback to fire,
// so that the async generator function has the opportunity to do
// any necessary setup in a predictable way. This predictability
// is why the Promise constructor synchronously invokes its
// executor callback, and why async functions synchronously
// execute code before the first await. Since we implement simple
// async functions in terms of async generators, it is especially
// important to get this right, even though it requires care.
previousPromise ? previousPromise.then(
callInvokeWithMethodAndArg,
// Avoid propagating failures to Promises returned by later
// invocations of the iterator.
callInvokeWithMethodAndArg
) : callInvokeWithMethodAndArg();
}
// Define the unified helper method that is used to implement .next,
// .throw, and .return (see defineIteratorMethods).
this._invoke = enqueue;
}
defineIteratorMethods(AsyncIterator.prototype);
runtime.AsyncIterator = AsyncIterator;
// Note that simple async functions are implemented on top of
// AsyncIterator objects; they just return a Promise for the value of
// the final result produced by the iterator.
runtime.async = function(innerFn, outerFn, self, tryLocsList) {
var iter = new AsyncIterator(
wrap(innerFn, outerFn, self, tryLocsList)
);
return runtime.isGeneratorFunction(outerFn)
? iter // If outerFn is a generator, return the full iterator.
: iter.next().then(function(result) {
return result.done ? result.value : iter.next();
});
};
function makeInvokeMethod(innerFn, self, context) {
var state = GenStateSuspendedStart;
return function invoke(method, arg) {
if (state === GenStateExecuting) {
throw new Error("Generator is already running");
}
if (state === GenStateCompleted) {
if (method === "throw") {
throw arg;
}
// Be forgiving, per 25.3.3.3.3 of the spec:
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
return doneResult();
}
while (true) {
var delegate = context.delegate;
if (delegate) {
if (method === "return" ||
(method === "throw" && delegate.iterator[method] === undefined)) {
// A return or throw (when the delegate iterator has no throw
// method) always terminates the yield* loop.
context.delegate = null;
// If the delegate iterator has a return method, give it a
// chance to clean up.
var returnMethod = delegate.iterator["return"];
if (returnMethod) {
var record = tryCatch(returnMethod, delegate.iterator, arg);
if (record.type === "throw") {
// If the return method threw an exception, let that
// exception prevail over the original return or throw.
method = "throw";
arg = record.arg;
continue;
}
}
if (method === "return") {
// Continue with the outer return, now that the delegate
// iterator has been terminated.
continue;
}
}
var record = tryCatch(
delegate.iterator[method],
delegate.iterator,
arg
);
if (record.type === "throw") {
context.delegate = null;
// Like returning generator.throw(uncaught), but without the
// overhead of an extra function call.
method = "throw";
arg = record.arg;
continue;
}
// Delegate generator ran and handled its own exceptions so
// regardless of what the method was, we continue as if it is
// "next" with an undefined arg.
method = "next";
arg = undefined;
var info = record.arg;
if (info.done) {
context[delegate.resultName] = info.value;
context.next = delegate.nextLoc;
} else {
state = GenStateSuspendedYield;
return info;
}
context.delegate = null;
}
if (method === "next") {
// Setting context._sent for legacy support of Babel's
// function.sent implementation.
context.sent = context._sent = arg;
} else if (method === "throw") {
if (state === GenStateSuspendedStart) {
state = GenStateCompleted;
throw arg;
}
if (context.dispatchException(arg)) {
// If the dispatched exception was caught by a catch block,
// then let that catch block handle the exception normally.
method = "next";
arg = undefined;
}
} else if (method === "return") {
context.abrupt("return", arg);
}
state = GenStateExecuting;
var record = tryCatch(innerFn, self, context);
if (record.type === "normal") {
// If an exception is thrown from innerFn, we leave state ===
// GenStateExecuting and loop back for another invocation.
state = context.done
? GenStateCompleted
: GenStateSuspendedYield;
var info = {
value: record.arg,
done: context.done
};
if (record.arg === ContinueSentinel) {
if (context.delegate && method === "next") {
// Deliberately forget the last sent value so that we don't
// accidentally pass it on to the delegate.
arg = undefined;
}
} else {
return info;
}
} else if (record.type === "throw") {
state = GenStateCompleted;
// Dispatch the exception by looping back around to the
// context.dispatchException(arg) call above.
method = "throw";
arg = record.arg;
}
}
};
}
// Define Generator.prototype.{next,throw,return} in terms of the
// unified ._invoke helper method.
defineIteratorMethods(Gp);
Gp[toStringTagSymbol] = "Generator";
Gp.toString = function() {
return "[object Generator]";
};
function pushTryEntry(locs) {
var entry = { tryLoc: locs[0] };
if (1 in locs) {
entry.catchLoc = locs[1];
}
if (2 in locs) {
entry.finallyLoc = locs[2];
entry.afterLoc = locs[3];
}
this.tryEntries.push(entry);
}
function resetTryEntry(entry) {
var record = entry.completion || {};
record.type = "normal";
delete record.arg;
entry.completion = record;
}
function Context(tryLocsList) {
// The root entry object (effectively a try statement without a catch
// or a finally block) gives us a place to store values thrown from
// locations where there is no enclosing try statement.
this.tryEntries = [{ tryLoc: "root" }];
tryLocsList.forEach(pushTryEntry, this);
this.reset(true);
}
runtime.keys = function(object) {
var keys = [];
for (var key in object) {
keys.push(key);
}
keys.reverse();
// Rather than returning an object with a next method, we keep
// things simple and return the next function itself.
return function next() {
while (keys.length) {
var key = keys.pop();
if (key in object) {
next.value = key;
next.done = false;
return next;
}
}
// To avoid creating an additional object, we just hang the .value
// and .done properties off the next function object itself. This
// also ensures that the minifier will not anonymize the function.
next.done = true;
return next;
};
};
function values(iterable) {
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol];
if (iteratorMethod) {
return iteratorMethod.call(iterable);
}
if (typeof iterable.next === "function") {
return iterable;
}
if (!isNaN(iterable.length)) {
var i = -1, next = function next() {
while (++i < iterable.length) {
if (hasOwn.call(iterable, i)) {
next.value = iterable[i];
next.done = false;
return next;
}
}
next.value = undefined;
next.done = true;
return next;
};
return next.next = next;
}
}
// Return an iterator with no values.
return { next: doneResult };
}
runtime.values = values;
function doneResult() {
return { value: undefined, done: true };
}
Context.prototype = {
constructor: Context,
reset: function(skipTempReset) {
this.prev = 0;
this.next = 0;
// Resetting context._sent for legacy support of Babel's
// function.sent implementation.
this.sent = this._sent = undefined;
this.done = false;
this.delegate = null;
this.tryEntries.forEach(resetTryEntry);
if (!skipTempReset) {
for (var name in this) {
// Not sure about the optimal order of these conditions:
if (name.charAt(0) === "t" &&
hasOwn.call(this, name) &&
!isNaN(+name.slice(1))) {
this[name] = undefined;
}
}
}
},
stop: function() {
this.done = true;
var rootEntry = this.tryEntries[0];
var rootRecord = rootEntry.completion;
if (rootRecord.type === "throw") {
throw rootRecord.arg;
}
return this.rval;
},
dispatchException: function(exception) {
if (this.done) {
throw exception;
}
var context = this;
function handle(loc, caught) {
record.type = "throw";
record.arg = exception;
context.next = loc;
return !!caught;
}
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
var record = entry.completion;
if (entry.tryLoc === "root") {
// Exception thrown outside of any try block that could handle
// it, so set the completion value of the entire function to
// throw the exception.
return handle("end");
}
if (entry.tryLoc <= this.prev) {
var hasCatch = hasOwn.call(entry, "catchLoc");
var hasFinally = hasOwn.call(entry, "finallyLoc");
if (hasCatch && hasFinally) {
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true);
} else if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
}
} else if (hasCatch) {
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true);
}
} else if (hasFinally) {
if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
}
} else {
throw new Error("try statement without catch or finally");
}
}
}
},
abrupt: function(type, arg) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc <= this.prev &&
hasOwn.call(entry, "finallyLoc") &&
this.prev < entry.finallyLoc) {
var finallyEntry = entry;
break;
}
}
if (finallyEntry &&
(type === "break" ||
type === "continue") &&
finallyEntry.tryLoc <= arg &&
arg <= finallyEntry.finallyLoc) {
// Ignore the finally entry if control is not jumping to a
// location outside the try/catch block.
finallyEntry = null;
}
var record = finallyEntry ? finallyEntry.completion : {};
record.type = type;
record.arg = arg;
if (finallyEntry) {
this.next = finallyEntry.finallyLoc;
} else {
this.complete(record);
}
return ContinueSentinel;
},
complete: function(record, afterLoc) {
if (record.type === "throw") {
throw record.arg;
}
if (record.type === "break" ||
record.type === "continue") {
this.next = record.arg;
} else if (record.type === "return") {
this.rval = record.arg;
this.next = "end";
} else if (record.type === "normal" && afterLoc) {
this.next = afterLoc;
}
},
finish: function(finallyLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.finallyLoc === finallyLoc) {
this.complete(entry.completion, entry.afterLoc);
resetTryEntry(entry);
return ContinueSentinel;
}
}
},
"catch": function(tryLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc === tryLoc) {
var record = entry.completion;
if (record.type === "throw") {
var thrown = record.arg;
resetTryEntry(entry);
}
return thrown;
}
}
// The context.catch method must only be called with a location
// argument that corresponds to a known catch block.
throw new Error("illegal catch attempt");
},
delegateYield: function(iterable, resultName, nextLoc) {
this.delegate = {
iterator: values(iterable),
resultName: resultName,
nextLoc: nextLoc
};
return ContinueSentinel;
}
};
})(
// Among the various tricks for obtaining a reference to the global
// object, this seems to be the most reliable technique that does not
// use indirect eval (which violates Content Security Policy).
typeof global === "object" ? global :
typeof window === "object" ? window :
typeof self === "object" ? self : this
);
/* jshint esversion: 6 */
/* jshint noyield: true */
"use strict";
//TODO:
//- LabeledStatement -> including use in break/continue
//- nicer error handling?
//-> TESTS
//-> BENCHMARKS
var parse = require('acorn').parse;
var util = require("util");
var EventEmitter = require("events").EventEmitter;
function noop() {}
function execute(func) {
var result = func();
if ('' + result === 'null') {
return result;
}
// FIXME: Convert to yield*
if (result !== undefined) {
if (result.next) {
var iter = result;
var res = iter.next();
while (!res.done) {
res = iter.next();
}
if ('' + res.value === 'null') {
return res.value;
}
if ('' + res.value === 'undefined') {
return res.value;
}
return res.value;
}
}
return result;
}
function Arguments() {
//TODO: add es3 'arguments.callee'?
}
Arguments.prototype.toString = function () {
return '[object Arguments]';
};
function Return(val) {
this.value = val;
}
// need something unique to compare a against.
var Break = {};
var Continue = {};
function Environment(globalObjects) {
EventEmitter.call(this);
if (!Array.isArray(globalObjects)) {
globalObjects = [globalObjects];
}
var parent;
globalObjects.forEach(function (vars) {
parent = createVarStore(parent, vars);
});
// the topmost store is our current store
this._curVarStore = parent;
this._curDeclarations = {};
this._globalObj = globalObjects[0];
this._curThis = this._globalObj;
this._boundGen = this._gen.bind(this);
this.DEBUG = false;
this.DELAY = 0;
this.STATE = 'running';
}
util.inherits(Environment, EventEmitter);
function createVarStore(parent, vars) {
vars = vars || {};
return {
parent: parent,
vars: vars
};
}
Environment.prototype.gen = function (node) {
var opts = {
'locations': true
};
if (typeof node === 'string') {
node = parse(node, opts);
}
var resp = this._gen(node);
addDeclarationsToStore(this._curDeclarations, this._curVarStore);
this._curDeclarations = {};
return resp;
};
Environment.prototype._gen = function (node) {
var closure = ({
BinaryExpression: this._genBinExpr,
LogicalExpression: this._genBinExpr,
UnaryExpression: this._genUnaryExpr,
UpdateExpression: this._genUpdExpr,
ObjectExpression: this._genObjExpr,
ArrayExpression: this._genArrExpr,
CallExpression: this._genCallExpr,
NewExpression: this._genNewExpr,
MemberExpression: this._genMemExpr,
ThisExpression: this._genThisExpr,
SequenceExpression: this._genSeqExpr,
Literal: this._genLit,
Identifier: this._genIdent,
AssignmentExpression: this._genAssignExpr,
FunctionDeclaration: this._genFuncDecl,
VariableDeclaration: this._genVarDecl,
BlockStatement: this._genProgram,
Program: this._genProgram,
ExpressionStatement: this._genExprStmt,
EmptyStatement: this._genEmptyStmt,
ReturnStatement: this._genRetStmt,
FunctionExpression: this._genFuncExpr,
IfStatement: this._genIfStmt,
ConditionalExpression: this._genCondStmt,
ForStatement: this._genLoopStmt,
WhileStatement: this._genLoopStmt,
DoWhileStatement: this._genDoWhileStmt,
ForInStatement: this._genForInStmt,
WithStatement: this._genWithStmt,
ThrowStatement: this._genThrowStmt,
TryStatement: this._genTryStmt,
ContinueStatement: this._genContStmt,
BreakStatement: this._genBreakStmt,
SwitchStatement: this._genSwitchStmt
}[node.type] || function () {
console.warn("Not implemented yet: " + node.type);
return noop;
}).call(this, node);
if (this.DEBUG) {
return function () {
var info = 'closure for ' + node.type + ' called';
var line = ((node.loc || {}).start || {}).line;
if (line) {
info += ' while processing line ' + line;
}
var resp = closure();
info += '. Result:';
console.log(info, resp);
return resp;
};
}
return closure;
};
Environment.prototype._genBinExpr = function (node) {
var _marked = [callExpr].map(regeneratorRuntime.mark);
var a = this._gen(node.left);
var b = this._gen(node.right);
function callExpr(expr) {
var result;
return regeneratorRuntime.wrap(function callExpr$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
if (!(expr.constructor.name == 'GeneratorFunction')) {
_context.next = 5;
break;
}
return _context.delegateYield(expr(), "t0", 2);
case 2:
result = _context.t0;
_context.next = 6;
break;
case 5:
result = expr();
case 6:
return _context.abrupt("return", result);
case 7:
case "end":
return _context.stop();
}
}
}, _marked[0], this);
}
var cmp = {
'==': regeneratorRuntime.mark(function _callee() {
return regeneratorRuntime.wrap(function _callee$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
return _context2.delegateYield(callExpr(a), "t0", 1);
case 1:
_context2.t1 = _context2.t0;
return _context2.delegateYield(callExpr(b), "t2", 3);
case 3:
_context2.t3 = _context2.t2;
return _context2.abrupt("return", _context2.t1 == _context2.t3);
case 5:
case "end":
return _context2.stop();
}
}
}, _callee, this);
}),
'!=': regeneratorRuntime.mark(function _callee2() {
return regeneratorRuntime.wrap(function _callee2$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
return _context3.delegateYield(callExpr(a), "t0", 1);
case 1:
_context3.t1 = _context3.t0;
return _context3.delegateYield(callExpr(b), "t2", 3);
case 3:
_context3.t3 = _context3.t2;
return _context3.abrupt("return", _context3.t1 != _context3.t3);
case 5:
case "end":
return _context3.stop();
}
}
}, _callee2, this);
}),
'===': regeneratorRuntime.mark(function _callee3() {
return regeneratorRuntime.wrap(function _callee3$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
return _context4.delegateYield(callExpr(a), "t0", 1);
case 1:
_context4.t1 = _context4.t0;
return _context4.delegateYield(callExpr(b), "t2", 3);
case 3:
_context4.t3 = _context4.t2;
return _context4.abrupt("return", _context4.t1 === _context4.t3);
case 5:
case "end":
return _context4.stop();
}
}
}, _callee3, this);
}),
'!==': regeneratorRuntime.mark(function _callee4() {
return regeneratorRuntime.wrap(function _callee4$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
return _context5.delegateYield(callExpr(a), "t0", 1);
case 1:
_context5.t1 = _context5.t0;
return _context5.delegateYield(callExpr(b), "t2", 3);
case 3:
_context5.t3 = _context5.t2;
return _context5.abrupt("return", _context5.t1 !== _context5.t3);
case 5:
case "end":
return _context5.stop();
}
}
}, _callee4, this);
}),
'<': regeneratorRuntime.mark(function _callee5() {
return regeneratorRuntime.wrap(function _callee5$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
return _context6.delegateYield(callExpr(a), "t0", 1);
case 1:
_context6.t1 = _context6.t0;
return _context6.delegateYield(callExpr(b), "t2", 3);
case 3:
_context6.t3 = _context6.t2;
return _context6.abrupt("return", _context6.t1 < _context6.t3);
case 5:
case "end":
return _context6.stop();
}
}
}, _callee5, this);
}),
'<=': regeneratorRuntime.mark(function _callee6() {
return regeneratorRuntime.wrap(function _callee6$(_context7) {
while (1) {
switch (_context7.prev = _context7.next) {
case 0:
return _context7.delegateYield(callExpr(a), "t0", 1);
case 1:
_context7.t1 = _context7.t0;
return _context7.delegateYield(callExpr(b), "t2", 3);
case 3:
_context7.t3 = _context7.t2;
return _context7.abrupt("return", _context7.t1 <= _context7.t3);
case 5:
case "end":
return _context7.stop();
}
}
}, _callee6, this);
}),
'>': regeneratorRuntime.mark(function _callee7() {
return regeneratorRuntime.wrap(function _callee7$(_context8) {
while (1) {
switch (_context8.prev = _context8.next) {
case 0:
return _context8.delegateYield(callExpr(a), "t0", 1);
case 1:
_context8.t1 = _context8.t0;
return _context8.delegateYield(callExpr(b), "t2", 3);
case 3:
_context8.t3 = _context8.t2;
return _context8.abrupt("return", _context8.t1 > _context8.t3);
case 5:
case "end":
return _context8.stop();
}
}
}, _callee7, this);
}),
'>=': regeneratorRuntime.mark(function _callee8() {
return regeneratorRuntime.wrap(function _callee8$(_context9) {
while (1) {
switch (_context9.prev = _context9.next) {
case 0:
return _context9.delegateYield(callExpr(a), "t0", 1);
case 1:
_context9.t1 = _context9.t0;
return _context9.delegateYield(callExpr(b), "t2", 3);
case 3:
_context9.t3 = _context9.t2;
return _context9.abrupt("return", _context9.t1 >= _context9.t3);
case 5:
case "end":
return _context9.stop();
}
}
}, _callee8, this);
}),
'<<': regeneratorRuntime.mark(function _callee9() {
return regeneratorRuntime.wrap(function _callee9$(_context10) {
while (1) {
switch (_context10.prev = _context10.next) {
case 0:
return _context10.delegateYield(callExpr(a), "t0", 1);
case 1:
_context10.t1 = _context10.t0;
return _context10.delegateYield(callExpr(b), "t2", 3);
case 3:
_context10.t3 = _context10.t2;
return _context10.abrupt("return", _context10.t1 << _context10.t3);
case 5:
case "end":
return _context10.stop();
}
}
}, _callee9, this);
}),
'>>': regeneratorRuntime.mark(function _callee10() {
return regeneratorRuntime.wrap(function _callee10$(_context11) {
while (1) {
switch (_context11.prev = _context11.next) {
case 0:
return _context11.delegateYield(callExpr(a), "t0", 1);
case 1:
_context11.t1 = _context11.t0;
return _context11.delegateYield(callExpr(b), "t2", 3);
case 3:
_context11.t3 = _context11.t2;
return _context11.abrupt("return", _context11.t1 >> _context11.t3);
case 5:
case "end":
return _context11.stop();
}
}
}, _callee10, this);
}),
'>>>': regeneratorRuntime.mark(function _callee11() {
return regeneratorRuntime.wrap(function _callee11$(_context12) {
while (1) {
switch (_context12.prev = _context12.next) {
case 0:
return _context12.delegateYield(callExpr(a), "t0", 1);
case 1:
_context12.t1 = _context12.t0;
return _context12.delegateYield(callExpr(b), "t2", 3);
case 3:
_context12.t3 = _context12.t2;
return _context12.abrupt("return", _context12.t1 >>> _context12.t3);
case 5:
case "end":
return _context12.stop();
}
}
}, _callee11, this);
}),
'+': regeneratorRuntime.mark(function _callee12() {
return regeneratorRuntime.wrap(function _callee12$(_context13) {
while (1) {
switch (_context13.prev = _context13.next) {
case 0:
return _context13.delegateYield(callExpr(a), "t0", 1);
case 1:
_context13.t1 = _context13.t0;
return _context13.delegateYield(callExpr(b), "t2", 3);
case 3:
_context13.t3 = _context13.t2;
return _context13.abrupt("return", _context13.t1 + _context13.t3);
case 5:
case "end":
return _context13.stop();
}
}
}, _callee12, this);
}),
'-': regeneratorRuntime.mark(function _callee13() {
return regeneratorRuntime.wrap(function _callee13$(_context14) {
while (1) {
switch (_context14.prev = _context14.next) {
case 0:
return _context14.delegateYield(callExpr(a), "t0", 1);
case 1:
_context14.t1 = _context14.t0;
return _context14.delegateYield(callExpr(b), "t2", 3);
case 3:
_context14.t3 = _context14.t2;
return _context14.abrupt("return", _context14.t1 - _context14.t3);
case 5:
case "end":
return _context14.stop();
}
}
}, _callee13, this);
}),
'*': regeneratorRuntime.mark(function _callee14() {
return regeneratorRuntime.wrap(function _callee14$(_context15) {
while (1) {
switch (_context15.prev = _context15.next) {
case 0:
return _context15.delegateYield(callExpr(a), "t0", 1);
case 1:
_context15.t1 = _context15.t0;
return _context15.delegateYield(callExpr(b), "t2", 3);
case 3:
_context15.t3 = _context15.t2;
return _context15.abrupt("return", _context15.t1 * _context15.t3);
case 5:
case "end":
return _context15.stop();
}
}
}, _callee14, this);
}),
'/': regeneratorRuntime.mark(function _callee15() {
return regeneratorRuntime.wrap(function _callee15$(_context16) {
while (1) {
switch (_context16.prev = _context16.next) {
case 0:
return _context16.delegateYield(callExpr(a), "t0", 1);
case 1:
_context16.t1 = _context16.t0;
return _context16.delegateYield(callExpr(b), "t2", 3);
case 3:
_context16.t3 = _context16.t2;
return _context16.abrupt("return", _context16.t1 / _context16.t3);
case 5:
case "end":
return _context16.stop();
}
}
}, _callee15, this);
}),
'%': regeneratorRuntime.mark(function _callee16() {
return regeneratorRuntime.wrap(function _callee16$(_context17) {
while (1) {
switch (_context17.prev = _context17.next) {
case 0:
return _context17.delegateYield(callExpr(a), "t0", 1);
case 1:
_context17.t1 = _context17.t0;
return _context17.delegateYield(callExpr(b), "t2", 3);
case 3:
_context17.t3 = _context17.t2;
return _context17.abrupt("return", _context17.t1 % _context17.t3);
case 5:
case "end":
return _context17.stop();
}
}
}, _callee16, this);
}),
'|': regeneratorRuntime.mark(function _callee17() {
return regeneratorRuntime.wrap(function _callee17$(_context18) {
while (1) {
switch (_context18.prev = _context18.next) {
case 0:
return _context18.delegateYield(callExpr(a), "t0", 1);
case 1:
_context18.t1 = _context18.t0;
return _context18.delegateYield(callExpr(b), "t2", 3);
case 3:
_context18.t3 = _context18.t2;
return _context18.abrupt("return", _context18.t1 | _context18.t3);
case 5:
case "end":
return _context18.stop();
}
}
}, _callee17, this);
}),
'^': regeneratorRuntime.mark(function _callee18() {
return regeneratorRuntime.wrap(function _callee18$(_context19) {
while (1) {
switch (_context19.prev = _context19.next) {
case 0:
return _context19.delegateYield(callExpr(a), "t0", 1);
case 1:
_context19.t1 = _context19.t0;
return _context19.delegateYield(callExpr(b), "t2", 3);
case 3:
_context19.t3 = _context19.t2;
return _context19.abrupt("return", _context19.t1 ^ _context19.t3);
case 5:
case "end":
return _context19.stop();
}
}
}, _callee18, this);
}),
'&': regeneratorRuntime.mark(function _callee19() {
return regeneratorRuntime.wrap(function _callee19$(_context20) {
while (1) {
switch (_context20.prev = _context20.next) {
case 0:
return _context20.delegateYield(callExpr(a), "t0", 1);
case 1:
_context20.t1 = _context20.t0;
return _context20.delegateYield(callExpr(b), "t2", 3);
case 3:
_context20.t3 = _context20.t2;
return _context20.abrupt("return", _context20.t1 & _context20.t3);
case 5:
case "end":
return _context20.stop();
}
}
}, _callee19, this);
}),
'in': regeneratorRuntime.mark(function _callee20() {
return regeneratorRuntime.wrap(function _callee20$(_context21) {
while (1) {
switch (_context21.prev = _context21.next) {
case 0:
return _context21.delegateYield(callExpr(a), "t0", 1);
case 1:
_context21.t1 = _context21.t0;
return _context21.delegateYield(callExpr(b), "t2", 3);
case 3:
_context21.t3 = _context21.t2;
return _context21.abrupt("return", _context21.t1 in _context21.t3);
case 5:
case "end":
return _context21.stop();
}
}
}, _callee20, this);
}),
'instanceof': regeneratorRuntime.mark(function _callee21() {
return regeneratorRuntime.wrap(function _callee21$(_context22) {
while (1) {
switch (_context22.prev = _context22.next) {
case 0:
return _context22.delegateYield(callExpr(a), "t0", 1);
case 1:
_context22.t1 = _context22.t0;
return _context22.delegateYield(callExpr(b), "t2", 3);
case 3:
_context22.t3 = _context22.t2;
return _context22.abrupt("return", _context22.t1 instanceof _context22.t3);
case 5:
case "end":
return _context22.stop();
}
}
}, _callee21, this);
}),
// logic expressions
'||': regeneratorRuntime.mark(function _callee22() {
return regeneratorRuntime.wrap(function _callee22$(_context23) {
while (1) {
switch (_context23.prev = _context23.next) {
case 0:
return _context23.delegateYield(callExpr(a), "t1", 1);
case 1:
_context23.t0 = _context23.t1;
if (_context23.t0) {
_context23.next = 5;
break;
}
return _context23.delegateYield(callExpr(b), "t2", 4);
case 4:
_context23.t0 = _context23.t2;
case 5:
return _context23.abrupt("return", _context23.t0);
case 6:
case "end":
return _context23.stop();
}
}
}, _callee22, this);
}),
'&&': regeneratorRuntime.mark(function _callee23() {
return regeneratorRuntime.wrap(function _callee23$(_context24) {
while (1) {
switch (_context24.prev = _context24.next) {
case 0:
return _context24.delegateYield(callExpr(a), "t1", 1);
case 1:
_context24.t0 = _context24.t1;
if (!_context24.t0) {
_context24.next = 5;
break;
}
return _context24.delegateYield(callExpr(b), "t2", 4);
case 4:
_context24.t0 = _context24.t2;
case 5:
return _context24.abrupt("return", _context24.t0);
case 6:
case "end":
return _context24.stop();
}
}
}, _callee23, this);
})
}[node.operator];
return function () {
// FIXME: Convert to yield*
var iter = cmp();
var res = iter.next();
while (!res.done) {
res = iter.next();
}
return res.value;
};
};
Environment.prototype._genUnaryExpr = function (node) {
if (node.operator === 'delete') {
return this._genDelete(node);
}
var a = this._gen(node.argument);
var op = {
'-': function () {
return -a();
},
'+': function () {
return +a();
},
'!': function () {
return !a();
},
'~': function () {
return ~a();
},
'typeof': function () {
return typeof a();
},
'void': function () {
return void a();
}
}[node.operator];
return function () {
return op();
};
};
Environment.prototype._genDelete = function (node) {
var obj = this._genObj(node.argument);
var attr = this._genName(node.argument);
return function () {
return delete obj()[attr()];
};
};
Environment.prototype._genObjExpr = function (node) {
//TODO property.kind: don't assume init when it can also be set/get
var self = this;
var items = [];
node.properties.forEach(function (property) {
// object expression keys are static so can be calculated
// immediately
var key = self._objKey(property.key)();
items.push({
key: key,
getVal: self._gen(property.value)
});
});
return function () {
var result = {};
items.forEach(function (item) {
result[item.key] = item.getVal();
});
return result;
};
};
Environment.prototype._genArrExpr = function (node) {
var items = node.elements.map(this._boundGen);
return function () {
return items.map(execute);
};
};
Environment.prototype._objKey = function (node) {
var key;
if (node.type === 'Identifier') {
key = node.name;
} else {
key = this._gen(node)();
}
return function () {
return key;
};
};
Environment.prototype._genCallExpr = function (node) {
var self = this;
var callee;
if (node.callee.type === 'MemberExpression') {
var obj = self._genObj(node.callee);
var name = self._genName(node.callee);
callee = function () {
var theObj = obj();
return theObj[name()].bind(theObj);
};
} else {
callee = self._gen(node.callee);
}
var args = node.arguments.map(self._gen.bind(self));
return regeneratorRuntime.mark(function _callee24() {
var c, result, res;
return regeneratorRuntime.wrap(function _callee24$(_context25) {
while (1) {
switch (_context25.prev = _context25.next) {
case 0:
self.emit('line', node.loc.start.line);
c = callee();
if (!(c === undefined)) {
_context25.next = 4;
break;
}
return _context25.abrupt("return", c);
case 4:
if (!c.next) {
_context25.next = 10;
break;
}
return _context25.delegateYield(c, "t0", 6);
case 6:
res = _context25.t0;
result = res.apply(self._globalObj, args.map(execute));
_context25.next = 11;
break;
case 10:
result = c.apply(self._globalObj, args.map(execute));
case 11:
if (!(result !== undefined)) {
_context25.next = 16;
break;
}
if (!result.next) {
_context25.next = 16;
break;
}
return _context25.delegateYield(result, "t1", 14);
case 14:
res = _context25.t1;
return _context25.abrupt("return", res);
case 16:
return _context25.abrupt("return", result);
case 17:
case "end":
return _context25.stop();
}
}
}, _callee24, this);
});
};
Environment.prototype._genNewExpr = function (node) {
var callee = this._gen(node.callee);
var args = node.arguments.map(this._boundGen);
var self = this;
return regeneratorRuntime.mark(function _callee25() {
var cl, ar, newObject, constructor;
return regeneratorRuntime.wrap(function _callee25$(_context26) {
while (1) {
switch (_context26.prev = _context26.next) {
case 0:
self.emit('line', node.loc.start.line);
cl = callee();
ar = args.map(execute);
newObject = Object.create(cl.prototype);
constructor = cl.apply(newObject, ar);
return _context26.delegateYield(constructor, "t0", 6);
case 6:
return _context26.abrupt("return", newObject);
case 7:
case "end":
return _context26.stop();
}
}
}, _callee25, this);
});
};
Environment.prototype._genMemExpr = function (node) {
var self = this;
var obj = this._gen(node.object);
var property = this._memExprProperty(node);
return function () {
self.emit('line', node.loc.start.line);
return obj()[property()];
};
};
Environment.prototype._memExprProperty = function (node) {
return node.computed ? this._gen(node.property) : this._objKey(node.property);
};
Environment.prototype._genThisExpr = function () {
var self = this;
return function () {
return self._curThis;
};
};
Environment.prototype._genSeqExpr = function (node) {
var exprs = node.expressions.map(this._boundGen);
return function () {
var result;
exprs.forEach(function (expr) {
result = expr();
});
return result;
};
};
Environment.prototype._genUpdExpr = function (node) {
var self = this;
var update = {
'--true': function (obj, name) {
return --obj[name];
},
'--false': function (obj, name) {
return obj[name]--;
},
'++true': function (obj, name) {
return ++obj[name];
},
'++false': function (obj, name) {
return obj[name]++;
}
}[node.operator + node.prefix];
var obj = this._genObj(node.argument);
var name = this._genName(node.argument);
return regeneratorRuntime.mark(function _callee26() {
return regeneratorRuntime.wrap(function _callee26$(_context27) {
while (1) {
switch (_context27.prev = _context27.next) {
case 0:
self.emit('line', node.loc.start.line);
_context27.next = 3;
return;
case 3:
return _context27.abrupt("return", update(obj(), name()));
case 4:
case "end":
return _context27.stop();
}
}
}, _callee26, this);
});
};
Environment.prototype._genObj = function (node) {
if (node.type === 'Identifier') {
return this._getVarStore.bind(this, node.name);
} else if (node.type === 'MemberExpression') {
return this._gen(node.object);
} else {
console.warn("Unknown _genObj() type: " + node.type);
return noop;
}
};
Environment.prototype._genName = function (node) {
if (node.type === 'Identifier') {
return function () {
return node.name;
};
} else if (node.type === 'MemberExpression') {
return this._memExprProperty(node);
} else {
console.warn("Unknown _genName() type: " + node.type);
return noop;
}
};
Environment.prototype._genLit = function (node) {
return function () {
return node.value;
};
};
Environment.prototype._genIdent = function (node) {
var self = this;
return function () {
return self._getVarStore(node.name)[node.name];
};
};
Environment.prototype._getVarStore = function (name) {
var store = this._curVarStore;
do {
if (store.vars.hasOwnProperty(name)) {
return store.vars;
}
} while (store = store.parent);
// global object as fallback
return this._globalObj;
};
Environment.prototype._genAssignExpr = function (node) {
var self = this;
var setter = {
'=': function (obj, name, val) {
return obj[name] = val;
},
'+=': function (obj, name, val) {
return obj[name] += val;
},
'-=': function (obj, name, val) {
return obj[name] -= val;
},
'*=': function (obj, name, val) {
return obj[name] *= val;
},
'/=': function (obj, name, val) {
return obj[name] /= val;
},
'%=': function (obj, name, val) {
return obj[name] %= val;
},
'<<=': function (obj, name, val) {
return obj[name] <<= val;
},
'>>=': function (obj, name, val) {
return obj[name] >>= val;
},
'>>>=': function (obj, name, val) {
return obj[name] >>>= val;
},
'|=': function (obj, name, val) {
return obj[name] |= val;
},
'^=': function (obj, name, val) {
return obj[name] ^= val;
},
'&=': function (obj, name, val) {
return obj[name] &= val;
}
}[node.operator];
var obj = this._genObj(node.left);
var name = this._genName(node.left);
var val = this._gen(node.right);
return regeneratorRuntime.mark(function _callee27() {
var v;
return regeneratorRuntime.wrap(function _callee27$(_context28) {
while (1) {
switch (_context28.prev = _context28.next) {
case 0:
self.emit('line', node.left.loc.start.line);
v = val();
if (!(v !== undefined)) {
_context28.next = 6;
break;
}
if (!v.next) {
_context28.next = 6;
break;
}
return _context28.delegateYield(v, "t0", 5);
case 5:
v = _context28.t0;
case 6:
return _context28.abrupt("return", setter(obj(), name(), v));
case 7:
case "end":
return _context28.stop();
}
}
}, _callee27, this);
});
};
Environment.prototype._genFuncDecl = function (node) {
this._curDeclarations[node.id.name] = this._genFuncExpr(node);
return regeneratorRuntime.mark(function _callee28() {
return regeneratorRuntime.wrap(function _callee28$(_context29) {
while (1) {
switch (_context29.prev = _context29.next) {
case 0:
return _context29.abrupt("return", noop);
case 1:
case "end":
return _context29.stop();
}
}
}, _callee28, this);
});
};
Environment.prototype._genVarDecl = function (node) {
var assignments = [];
for (var i = 0; i < node.declarations.length; i++) {
var decl = node.declarations[i];
this._curDeclarations[decl.id.name] = noop;
if (decl.init) {
assignments.push({
type: 'AssignmentExpression',
operator: '=',
left: decl.id,
right: decl.init
});
}
}
return this._gen({
type: 'BlockStatement',
body: assignments
});
};
Environment.prototype.getState = function () {
return this.STATE;
};
Environment.prototype.setState = function (state) {
this.STATE = state;
};
Environment.prototype._genFuncExpr = function (node) {
var self = this;
var oldDeclarations = self._curDeclarations;
self._curDeclarations = {};
var body = self._gen(node.body);
var declarations = self._curDeclarations;
self._curDeclarations = oldDeclarations;
// reset var store
return function () {
var parent = self._curVarStore;
return regeneratorRuntime.mark(function _callee29() {
var args,
i,
oldStore,
oldThis,
result,
_args30 = arguments;
return regeneratorRuntime.wrap(function _callee29$(_context30) {
while (1) {
switch (_context30.prev = _context30.next) {
case 0:
// build arguments object
args = new Arguments();
args.length = _args30.length;
for (i = 0; i < _args30.length; i++) {
args[i] = _args30[i];
}
// switch interpreter 'stack'
oldStore = self._curVarStore;
oldThis = self._curThis;
self._curVarStore = createVarStore(parent);
self._curThis = this;
addDeclarationsToStore(declarations, self._curVarStore);
self._curVarStore.vars.arguments = args;
// add function args to var store
node.params.forEach(function (param, i) {
self._curVarStore.vars[param.name] = args[i];
});
// run function body
return _context30.delegateYield(body(), "t0", 11);
case 11:
result = _context30.t0;
// switch 'stack' back
self._curThis = oldThis;
self._curVarStore = oldStore;
if (!(result instanceof Return)) {
_context30.next = 16;
break;
}
return _context30.abrupt("return", result.value);
case 16:
case "end":
return _context30.stop();
}
}
}, _callee29, this);
});
};
};
function addDeclarationsToStore(declarations, varStore) {
for (var key in declarations) {
if (declarations.hasOwnProperty(key) && !varStore.vars.hasOwnProperty(key)) {
varStore.vars[key] = declarations[key]();
}
}
}
Environment.prototype._genProgram = function (node) {
var self = this;
var stmtClosures = node.body.map(function (stmt) {
return self._gen(stmt);
});
return regeneratorRuntime.mark(function _callee30() {
var result, i;
return regeneratorRuntime.wrap(function _callee30$(_context31) {
while (1) {
switch (_context31.prev = _context31.next) {
case 0:
i = 0;
case 1:
if (!(i < stmtClosures.length)) {
_context31.next = 17;
break;
}
if (!(stmtClosures[i].constructor.name === 'GeneratorFunction')) {
_context31.next = 9;
break;
}
return _context31.delegateYield(stmtClosures[i](), "t0", 4);
case 4:
result = _context31.t0;
_context31.next = 7;
return;
case 7:
_context31.next = 12;
break;
case 9:
result = stmtClosures[i]();
_context31.next = 12;
return;
case 12:
if (!(result === Break || result === Continue || result instanceof Return)) {
_context31.next = 14;
break;
}
return _context31.abrupt("break", 17);
case 14:
i++;
_context31.next = 1;
break;
case 17:
return _context31.abrupt("return", result);
case 18:
case "end":
return _context31.stop();
}
}
}, _callee30, this);
});
};
Environment.prototype._genExprStmt = function (node) {
return this._gen(node.expression);
};
Environment.prototype._genEmptyStmt = function () {
return noop;
};
Environment.prototype._genRetStmt = function (node) {
var self = this;
var arg = node.argument ? this._gen(node.argument) : noop;
return function () {
self.emit('line', node.loc.start.line);
return new Return(arg());
};
};
Environment.prototype._genIfStmt = function (node) {
var self = this;
var test = function () {
self.emit('line', node.loc.start.line);
return self._gen(node.test)();
};
var consequent = this._gen(node.consequent);
var alternate = node.alternate ? this._gen(node.alternate) : regeneratorRuntime.mark(function _callee31() {
return regeneratorRuntime.wrap(function _callee31$(_context32) {
while (1) {
switch (_context32.prev = _context32.next) {
case 0:
return _context32.abrupt("return", noop);
case 1:
case "end":
return _context32.stop();
}
}
}, _callee31, this);
});
return regeneratorRuntime.mark(function _callee32() {
var result;
return regeneratorRuntime.wrap(function _callee32$(_context33) {
while (1) {
switch (_context33.prev = _context33.next) {
case 0:
if (!test()) {
_context33.next = 5;
break;
}
return _context33.delegateYield(consequent(), "t1", 2);
case 2:
_context33.t0 = _context33.t1;
_context33.next = 7;
break;
case 5:
return _context33.delegateYield(alternate(), "t2", 6);
case 6:
_context33.t0 = _context33.t2;
case 7:
result = _context33.t0;
return _context33.abrupt("return", result);
case 9:
case "end":
return _context33.stop();
}
}
}, _callee32, this);
});
};
Environment.prototype._genCondStmt = function (node) {
var self = this;
var test = function () {
self.emit('line', node.loc.start.line);
return self._gen(node.test)();
};
var consequent = this._gen(node.consequent);
var alternate = node.alternate ? this._gen(node.alternate) : noop;
return function () {
return test() ? consequent() : alternate();
};
};
Environment.prototype._genLoopStmt = function (node, body) {
var self = this;
var init = node.init ? this._gen(node.init) : regeneratorRuntime.mark(function _callee33() {
return regeneratorRuntime.wrap(function _callee33$(_context34) {
while (1) {
switch (_context34.prev = _context34.next) {
case 0:
return _context34.abrupt("return", noop);
case 1:
case "end":
return _context34.stop();
}
}
}, _callee33, this);
});
var test = node.test ? regeneratorRuntime.mark(function _callee34() {
return regeneratorRuntime.wrap(function _callee34$(_context35) {
while (1) {
switch (_context35.prev = _context35.next) {
case 0:
self.emit('line', node.loc.start.line);
return _context35.abrupt("return", self._gen(node.test)());
case 2:
case "end":
return _context35.stop();
}
}
}, _callee34, this);
}) : regeneratorRuntime.mark(function _callee35() {
return regeneratorRuntime.wrap(function _callee35$(_context36) {
while (1) {
switch (_context36.prev = _context36.next) {
case 0:
return _context36.abrupt("return", true);
case 1:
case "end":
return _context36.stop();
}
}
}, _callee35, this);
});
var update = node.update ? this._gen(node.update) : regeneratorRuntime.mark(function _callee36() {
return regeneratorRuntime.wrap(function _callee36$(_context37) {
while (1) {
switch (_context37.prev = _context37.next) {
case 0:
return _context37.abrupt("return", noop);
case 1:
case "end":
return _context37.stop();
}
}
}, _callee36, this);
});
body = body || this._gen(node.body);
return regeneratorRuntime.mark(function _callee37() {
var resp, newResp;
return regeneratorRuntime.wrap(function _callee37$(_context38) {
while (1) {
switch (_context38.prev = _context38.next) {
case 0:
self.emit('line', node.loc.start.line);
return _context38.delegateYield(init(), "t0", 2);
case 2:
return _context38.delegateYield(test(), "t1", 3);
case 3:
if (!_context38.t1) {
_context38.next = 16;
break;
}
return _context38.delegateYield(body(), "t2", 5);
case 5:
newResp = _context38.t2;
if (!(newResp === Break)) {
_context38.next = 8;
break;
}
return _context38.abrupt("break", 16);
case 8:
if (!(newResp === Continue)) {
_context38.next = 10;
break;
}
return _context38.abrupt("continue", 13);
case 10:
resp = newResp;
if (!(newResp instanceof Return)) {
_context38.next = 13;
break;
}
return _context38.abrupt("break", 16);
case 13:
return _context38.delegateYield(update(), "t3", 14);
case 14:
_context38.next = 2;
break;
case 16:
return _context38.abrupt("return", resp);
case 17:
case "end":
return _context38.stop();
}
}
}, _callee37, this);
});
};
Environment.prototype._genDoWhileStmt = function (node) {
var body = this._gen(node.body);
var loop = this._genLoopStmt(node, body);
return regeneratorRuntime.mark(function _callee38() {
return regeneratorRuntime.wrap(function _callee38$(_context39) {
while (1) {
switch (_context39.prev = _context39.next) {
case 0:
return _context39.delegateYield(body(), "t0", 1);
case 1:
return _context39.delegateYield(loop(), "t1", 2);
case 2:
case "end":
return _context39.stop();
}
}
}, _callee38, this);
});
};
Environment.prototype._genForInStmt = function (node) {
var self = this;
var right = self._gen(node.right);
var body = self._gen(node.body);
var left = node.left;
if (left.type === 'VariableDeclaration') {
self._curDeclarations[left.declarations[0].id.name] = noop;
left = left.declarations[0].id;
}
return regeneratorRuntime.mark(function _callee39() {
var resp, x;
return regeneratorRuntime.wrap(function _callee39$(_context40) {
while (1) {
switch (_context40.prev = _context40.next) {
case 0:
self.emit('line', node.loc.start.line);
_context40.t0 = regeneratorRuntime.keys(right());
case 2:
if ((_context40.t1 = _context40.t0()).done) {
_context40.next = 10;
break;
}
x = _context40.t1.value;
self.emit('line', node.loc.start.line);
return _context40.delegateYield(self._genAssignExpr({
operator: '=',
left: left,
right: {
type: 'Literal',
value: x
}
})(), "t2", 6);
case 6:
return _context40.delegateYield(body(), "t3", 7);
case 7:
resp = _context40.t3;
_context40.next = 2;
break;
case 10:
return _context40.abrupt("return", resp);
case 11:
case "end":
return _context40.stop();
}
}
}, _callee39, this);
});
};
Environment.prototype._genWithStmt = function (node) {
var self = this;
var obj = self._gen(node.object);
var body = self._gen(node.body);
return regeneratorRuntime.mark(function _callee40() {
var result;
return regeneratorRuntime.wrap(function _callee40$(_context41) {
while (1) {
switch (_context41.prev = _context41.next) {
case 0:
self._curVarStore = createVarStore(self._curVarStore, obj());
return _context41.delegateYield(body(), "t0", 2);
case 2:
result = _context41.t0;
self._curVarStore = self._curVarStore.parent;
return _context41.abrupt("return", result);
case 5:
case "end":
return _context41.stop();
}
}
}, _callee40, this);
});
};
Environment.prototype._genThrowStmt = function (node) {
var arg = this._gen(node.argument);
return function () {
throw arg();
};
};
Environment.prototype._genTryStmt = function (node) {
var block = this._gen(node.block);
var handler = this._genCatchHandler(node.handler);
var finalizer = node.finalizer ? this._gen(node.finalizer) : function (x) {
return x;
};
return function () {
try {
return finalizer(block());
} catch (err) {
return finalizer(handler(err));
}
};
};
Environment.prototype._genCatchHandler = function (node) {
if (!node) {
return noop;
}
var self = this;
var body = self._gen(node.body);
return function (err) {
var old = self._curVarStore.vars[node.param.name];
self._curVarStore.vars[node.param.name] = err;
var resp = body();
self._curVarStore.vars[node.param.name] = old;
return resp;
};
};
Environment.prototype._genContStmt = function () {
return function () {
return Continue;
};
};
Environment.prototype._genBreakStmt = function () {
return function () {
return Break;
};
};
Environment.prototype._genSwitchStmt = function (node) {
var self = this;
var discriminant = self._gen(node.discriminant);
var cases = node.cases.map(function (curCase) {
return {
test: curCase.test ? self._gen(curCase.test) : null,
code: self._genProgram({ body: curCase.consequent })
};
});
return regeneratorRuntime.mark(function _callee41() {
var foundMatch, discriminantVal, resp, defaultCase, i, curCase, newResp;
return regeneratorRuntime.wrap(function _callee41$(_context42) {
while (1) {
switch (_context42.prev = _context42.next) {
case 0:
foundMatch = false;
discriminantVal = discriminant();
i = 0;
case 3:
if (!(i < cases.length)) {
_context42.next = 22;
break;
}
curCase = cases[i];
if (foundMatch) {
_context42.next = 12;
break;
}
if (curCase.test) {
_context42.next = 9;
break;
}
defaultCase = curCase;
return _context42.abrupt("continue", 19);
case 9:
if (!(discriminantVal !== curCase.test())) {
_context42.next = 11;
break;
}
return _context42.abrupt("continue", 19);
case 11:
foundMatch = true;
case 12:
return _context42.delegateYield(curCase.code(), "t0", 13);
case 13:
newResp = _context42.t0;
if (!(newResp === Break)) {
_context42.next = 16;
break;
}
return _context42.abrupt("return", resp);
case 16:
resp = newResp;
if (!(resp === Continue || resp instanceof Return)) {
_context42.next = 19;
break;
}
return _context42.abrupt("return", resp);
case 19:
i++;
_context42.next = 3;
break;
case 22:
if (!(!foundMatch && defaultCase)) {
_context42.next = 25;
break;
}
return _context42.delegateYield(defaultCase.code(), "t1", 24);
case 24:
return _context42.abrupt("return", _context42.t1);
case 25:
case "end":
return _context42.stop();
}
}
}, _callee41, this);
});
};
exports.Environment = Environment;
exports.evaluate = function (code) {
var env = new Environment(global);
var iterator = env.gen(code)();
var result = iterator.next();
while (!result.done) {
result = iterator.next();
}
return result.value;
};
//console.log(exports.evaluate("1 + 1"));