708 lines
19 KiB
JavaScript
708 lines
19 KiB
JavaScript
if(this['plt'] === undefined) {
|
|
this['plt'] = {};
|
|
}
|
|
|
|
|
|
// All of the values here are namespaced under "plt.runtime".
|
|
|
|
(function() {
|
|
this['plt']['runtime'] = {};
|
|
var exports = this['plt']['runtime'];
|
|
|
|
|
|
|
|
// Type helpers
|
|
//
|
|
// Defines inheritance between prototypes.
|
|
var heir = function(parentPrototype) {
|
|
var f = function() {}
|
|
f.prototype = parentPrototype;
|
|
return new f();
|
|
};
|
|
|
|
// Consumes a class and creates a predicate that recognizes subclasses.
|
|
var makeClassPredicate = function(aClass) {
|
|
return function(x) { return x instanceof aClass; };
|
|
};
|
|
|
|
|
|
var isNumber = function(x) { return typeof(x) === 'number'; };
|
|
|
|
var isPair = function(x) { return (typeof(x) == 'object' &&
|
|
x.length === 2) }
|
|
var isVector = function(x) { return (typeof(x) == 'object' &&
|
|
x.length !== undefined) }
|
|
|
|
var Machine = function() {
|
|
this.callsBeforeTrampoline = 100;
|
|
this.val = undefined;
|
|
this.proc = undefined;
|
|
this.env = [];
|
|
this.control = []; // Arrayof (U CallFrame PromptFrame)
|
|
this.running = false;
|
|
this.params = { 'currentDisplayer': function(v) {},
|
|
|
|
'currentOutputPort': new StandardOutputPort(),
|
|
'currentSuccessHandler': function(MACHINE) {},
|
|
'currentErrorHandler': function(MACHINE, exn) {},
|
|
|
|
'currentNamespace': {},
|
|
|
|
// These parameters control how often
|
|
// control yields back to the browser
|
|
// for response. The implementation is a
|
|
// simple PID controller.
|
|
//
|
|
// To tune this, adjust desiredYieldsPerSecond.
|
|
// Do no touch numBouncesBeforeYield or
|
|
// maxNumBouncesBeforeYield, because those
|
|
// are adjusted automatically by the
|
|
// recomputeMaxNumBouncesBeforeYield
|
|
// procedure.
|
|
'desiredYieldsPerSecond': 5,
|
|
'numBouncesBeforeYield': 2000, // self-adjusting
|
|
'maxNumBouncesBeforeYield': 2000 // self-adjusting
|
|
};
|
|
this.primitives = Primitives;
|
|
};
|
|
|
|
|
|
|
|
var Frame = function() {};
|
|
// Control stack elements:
|
|
|
|
// A CallFrame represents a call stack frame.
|
|
var CallFrame = function(label, proc) {
|
|
this.label = label;
|
|
this.proc = proc;
|
|
};
|
|
CallFrame.prototype = heir(Frame.prototype);
|
|
|
|
// PromptFrame represents a prompt frame.
|
|
var PromptFrame = function(label, tag) {
|
|
this.label = label;
|
|
this.tag = tag; // ContinuationPromptTag
|
|
};
|
|
PromptFrame.prototype = heir(Frame.prototype);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var OutputPort = function() {};
|
|
var isOutputPort = makeClassPredicate(OutputPort);
|
|
|
|
|
|
var StandardOutputPort = function() {};
|
|
StandardOutputPort.prototype = heir(OutputPort.prototype);
|
|
StandardOutputPort.prototype.write = function(MACHINE, v) {
|
|
MACHINE.params['currentDisplayer'](v);
|
|
};
|
|
|
|
|
|
|
|
var OutputStringPort = function() {
|
|
this.buf = [];
|
|
};
|
|
OutputStringPort.prototype = heir(OutputPort.prototype);
|
|
OutputStringPort.prototype.write = function(MACHINE, v) {
|
|
this.buf.push(String(v));
|
|
};
|
|
OutputStringPort.prototype.getOutputString = function() {
|
|
return this.buf.join('');
|
|
};
|
|
var isOutputStringPort = makeClassPredicate(OutputStringPort);
|
|
|
|
|
|
|
|
|
|
// Function types: a function is either a Primitive or a Closure.
|
|
|
|
// A Primitive is a function that's expected to return. It is not
|
|
// allowed to call into Closures. Its caller is expected to pop off
|
|
// its argument stack space.
|
|
//
|
|
//
|
|
// A Closure is a function that takes on more responsibilities: it is
|
|
// responsible for popping off stack space before it finishes, and it
|
|
// is also explicitly responsible for continuing the computation by
|
|
// popping off the control stack and doing the jump. Because of this,
|
|
// closures can do pretty much anything to the machine.
|
|
|
|
|
|
|
|
// A closure consists of its free variables as well as a label
|
|
// into its text segment.
|
|
var Closure = function(label, arity, closedVals, displayName) {
|
|
this.label = label; // (MACHINE -> void)
|
|
this.arity = arity; // number
|
|
this.closedVals = closedVals; // arrayof number
|
|
this.displayName = displayName; // string
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// A continuation prompt tag labels a prompt frame.
|
|
var ContinuationPromptTag = function(name) {
|
|
this.name = name;
|
|
};
|
|
|
|
|
|
|
|
// There is a single, distinguished default continuation prompt tag
|
|
// that's used to wrap around toplevel prompts.
|
|
var DEFAULT_CONTINUATION_PROMPT_TAG =
|
|
new ContinuationPromptTag("default-continuation-prompt-tag");
|
|
|
|
|
|
var NULL = [];
|
|
|
|
|
|
var raise = function(e) { throw e; }
|
|
|
|
|
|
|
|
|
|
// testArgument: (X -> boolean) X number string string -> boolean
|
|
// Produces true if val is true, and otherwise raises an error.
|
|
var testArgument = function(expectedTypeName,
|
|
predicate,
|
|
val,
|
|
position,
|
|
callerName) {
|
|
if (predicate(val)) {
|
|
return true;
|
|
}
|
|
else {
|
|
raise(new Error(callerName + ": expected " + expectedTypeName
|
|
+ " as argument #" + position
|
|
+ " but received " + val + " instead"));
|
|
}
|
|
};
|
|
|
|
var testArity = function(callerName, observed, minimum, maximum) {
|
|
if (observed < minimum || observed > maximum) {
|
|
raise(new Error(callerName + ": expected at least " + minimum
|
|
+ " arguments "
|
|
+ " but received " + observer));
|
|
|
|
}
|
|
};
|
|
|
|
|
|
|
|
// captureControl implements the continuation-capturing part of
|
|
// call/cc. It grabs the control frames up to (but not including) the
|
|
// prompt tagged by the given tag.
|
|
var captureControl = function(MACHINE, skip, tag) {
|
|
var i;
|
|
for (i = MACHINE.control.length - 1 - skip; i >= 0; i--) {
|
|
if (MACHINE.control[i].tag === tag) {
|
|
return MACHINE.control.slice(i + 1,
|
|
MACHINE.control.length - skip);
|
|
}
|
|
}
|
|
raise(new Error("captureControl: unable to find tag " + tag));
|
|
};
|
|
|
|
|
|
|
|
// restoreControl clears the control stack (up to, but not including the
|
|
// prompt tagged by tag), and then appends the rest of the control frames.
|
|
// At the moment, the rest of the control frames is assumed to be in the
|
|
// top of the environment.
|
|
var restoreControl = function(MACHINE, tag) {
|
|
var i;
|
|
for (i = MACHINE.control.length - 1; i >= 0; i--) {
|
|
if (MACHINE.control[i].tag === tag) {
|
|
MACHINE.control =
|
|
MACHINE.control.slice(0, i+1).concat(
|
|
MACHINE.env[MACHINE.env.length - 1]);
|
|
return;
|
|
}
|
|
}
|
|
raise(new Error("restoreControl: unable to find tag " + tag));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Primtitives are the set of primitive values. Not all primitives
|
|
// are coded here; several of them (including call/cc) are injected by
|
|
// the bootstrapping code.
|
|
var Primitives = {};
|
|
Primitives['display'] = function(MACHINE, arity) {
|
|
testArity('display', arity, 1, 2);
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var outputPort = MACHINE.params.currentOutputPort;
|
|
if (arity == 2) {
|
|
outputPort = MACHINE.env[MACHINE.env.length-2];
|
|
}
|
|
outputPort.write(MACHINE, firstArg);
|
|
};
|
|
|
|
Primitives['newline'] = function(MACHINE, arity) {
|
|
testArity('newline', arity, 0, 1);
|
|
var outputPort = MACHINE.params.currentOutputPort;
|
|
if (arity == 1) {
|
|
outputPort = MACHINE.env[MACHINE.env.length-1];
|
|
}
|
|
outputPort.write(MACHINE, "\n");
|
|
};
|
|
|
|
Primitives['displayln'] = function(MACHINE, arity){
|
|
testArity('displayln', arity, 1, 2);
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var outputPort = MACHINE.params.currentOutputPort;
|
|
if (arity == 2) {
|
|
outputPort = MACHINE.env[MACHINE.env.length-2];
|
|
}
|
|
outputPort.write(MACHINE, firstArg);
|
|
outputPort.write(MACHINE, "\n");
|
|
};
|
|
|
|
Primitives['pi'] = Math.PI;
|
|
|
|
Primitives['e'] = Math.E;
|
|
|
|
Primitives['='] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
testArgument('number', isNumber, firstArg, 0, '=');
|
|
testArgument('number', isNumber, secondArg, 1, '=');
|
|
return firstArg === secondArg;
|
|
};
|
|
|
|
Primitives['<'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
testArgument('number', isNumber, firstArg, 0, '<');
|
|
testArgument('number', isNumber, secondArg, 1, '<');
|
|
return firstArg < secondArg;
|
|
};
|
|
|
|
Primitives['>'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
testArgument('number', isNumber, firstArg, 0, '>');
|
|
testArgument('number', isNumber, secondArg, 1, '>');
|
|
return firstArg > secondArg;
|
|
};
|
|
|
|
Primitives['<='] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
testArgument('number', isNumber, firstArg, 0, '<=');
|
|
testArgument('number', isNumber, secondArg, 1, '<=');
|
|
return firstArg <= secondArg;
|
|
};
|
|
|
|
Primitives['>='] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
testArgument('number', isNumber, firstArg, 0, '>=');
|
|
testArgument('number', isNumber, secondArg, 1, '>=');
|
|
return firstArg >= secondArg;
|
|
};
|
|
|
|
Primitives['+'] = function(MACHINE, arity) {
|
|
var result = 0;
|
|
var i = 0;
|
|
for (i=0; i < arity; i++) {
|
|
testArgument(
|
|
'number',
|
|
isNumber,
|
|
MACHINE.env[MACHINE.env.length - 1 - i],
|
|
i,
|
|
'+');
|
|
result += MACHINE.env[MACHINE.env.length - 1 - i];
|
|
};
|
|
return result;
|
|
};
|
|
|
|
Primitives['*'] = function(MACHINE, arity) {
|
|
var result = 1;
|
|
var i = 0;
|
|
for (i=0; i < arity; i++) {
|
|
testArgument(
|
|
'number',
|
|
isNumber,
|
|
MACHINE.env[MACHINE.env.length - 1 - i],
|
|
i,
|
|
'*');
|
|
result *= MACHINE.env[MACHINE.env.length - 1 - i];
|
|
}
|
|
return result;
|
|
};
|
|
|
|
Primitives['-'] = function(MACHINE, arity) {
|
|
if (arity === 0) { raise(new Error()); }
|
|
if (arity === 1) {
|
|
testArgument('number',
|
|
isNumber,
|
|
MACHINE.env[MACHINE.env.length-1],
|
|
0,
|
|
'-');
|
|
return -(MACHINE.env[MACHINE.env.length-1]);
|
|
}
|
|
var result = MACHINE.env[MACHINE.env.length - 1];
|
|
for (var i = 1; i < arity; i++) {
|
|
testArgument('number',
|
|
isNumber,
|
|
MACHINE.env[MACHINE.env.length-1-i],
|
|
i,
|
|
'-');
|
|
result -= MACHINE.env[MACHINE.env.length - 1 - i];
|
|
}
|
|
return result;
|
|
};
|
|
|
|
Primitives['/'] = function(MACHINE, arity) {
|
|
if (arity === 0) { raise(new Error()); }
|
|
testArgument('number',
|
|
isNumber,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'/');
|
|
var result = MACHINE.env[MACHINE.env.length - 1];
|
|
for (var i = 1; i < arity; i++) {
|
|
result /= MACHINE.env[MACHINE.env.length - 1 - i];
|
|
}
|
|
return result;
|
|
};
|
|
|
|
Primitives['cons'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
return [firstArg, secondArg];
|
|
};
|
|
|
|
Primitives['list'] = function(MACHINE, arity) {
|
|
var result = NULL;
|
|
for (var i = 0; i < arity; i++) {
|
|
result = [MACHINE.env[MACHINE.env.length - (arity - i)],
|
|
result];
|
|
}
|
|
return result;
|
|
};
|
|
|
|
Primitives['car'] = function(MACHINE, arity) {
|
|
testArgument('pair',
|
|
isPair,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'car');
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg[0];
|
|
};
|
|
|
|
Primitives['cdr'] = function(MACHINE, arity) {
|
|
testArgument('pair',
|
|
isPair,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'cdr');
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg[1];
|
|
};
|
|
|
|
Primitives['pair?'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return isPair(firstArg);
|
|
};
|
|
|
|
Primitives['set-car!'] = function(MACHINE, arity) {
|
|
testArgument('pair',
|
|
isPair,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'set-car!');
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
firstArg[0] = secondArg;
|
|
};
|
|
|
|
Primitives['set-cdr!'] = function(MACHINE, arity) {
|
|
testArgument('pair',
|
|
isPair,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'set-cdr!');
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
firstArg[1] = secondArg;
|
|
};
|
|
|
|
Primitives['not'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return (!firstArg);
|
|
};
|
|
|
|
Primitives['null'] = NULL;
|
|
|
|
Primitives['null?'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg === NULL;
|
|
};
|
|
|
|
Primitives['add1'] = function(MACHINE, arity) {
|
|
testArgument('number',
|
|
isNumber,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'add1');
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg + 1;
|
|
};
|
|
|
|
Primitives['sub1'] = function(MACHINE, arity) {
|
|
testArgument('number',
|
|
isNumber,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'sub1');
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg - 1;
|
|
};
|
|
|
|
Primitives['zero?'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg === 0;
|
|
};
|
|
|
|
Primitives['vector'] = function(MACHINE, arity) {
|
|
var i;
|
|
var result = [];
|
|
for (i = 0; i < arity; i++) {
|
|
result.push(MACHINE.env[MACHINE.env.length-1-i]);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
Primitives['vector->list'] = function(MACHINE, arity) {
|
|
testArgument('vector',
|
|
isVector,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'vector->list');
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var i;
|
|
var result = NULL;
|
|
for (i = 0; i < firstArg.length; i++) {
|
|
result = [firstArg[firstArg.length - 1 - i], result];
|
|
}
|
|
return result;
|
|
};
|
|
|
|
Primitives['list->vector'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var result = [];
|
|
while (firstArg !== NULL) {
|
|
result.push(firstArg[0]);
|
|
firstArg = firstArg[1];
|
|
}
|
|
return result;
|
|
};
|
|
|
|
Primitives['vector-ref'] = function(MACHINE, arity) {
|
|
testArgument('vector',
|
|
isVector,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'vector-ref');
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
return firstArg[secondArg];
|
|
};
|
|
|
|
Primitives['vector-set!'] = function(MACHINE, arity) {
|
|
testArgument('vector',
|
|
isVector,
|
|
MACHINE.env[MACHINE.env.length - 1],
|
|
0,
|
|
'vector-set!');
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
var thirdArg = MACHINE.env[MACHINE.env.length-3];
|
|
firstArg[secondArg] = thirdArg;
|
|
return null;
|
|
};
|
|
|
|
Primitives['symbol?'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return typeof(firstArg) === 'string';
|
|
};
|
|
|
|
Primitives['symbol->string'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg;
|
|
};
|
|
|
|
Primitives['string-append'] = function(MACHINE, arity) {
|
|
var buffer = [];
|
|
var i;
|
|
for (i = 0; i < arity; i++) {
|
|
buffer.push(MACHINE.env[MACHINE.env.length - 1 - i]);
|
|
}
|
|
return buffer.join('');
|
|
};
|
|
|
|
Primitives['string-length'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg.length;
|
|
};
|
|
|
|
Primitives['box'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var result = [firstArg];
|
|
return result;
|
|
};
|
|
|
|
Primitives['unbox'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
return firstArg[0];
|
|
};
|
|
|
|
Primitives['set-box!'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
firstArg[0] = secondArg;
|
|
return;
|
|
};
|
|
|
|
Primitives['void'] = function(MACHINE, arity) {
|
|
return;
|
|
};
|
|
|
|
Primitives['eq?'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
return firstArg === secondArg;
|
|
};
|
|
|
|
Primitives['equal?'] = function(MACHINE, arity) {
|
|
var firstArg = MACHINE.env[MACHINE.env.length-1];
|
|
var secondArg = MACHINE.env[MACHINE.env.length-2];
|
|
var lset = [firstArg], rset = [secondArg];
|
|
while (lset.length !== 0 && rset.length !== 0) {
|
|
var lhs = lset.pop();
|
|
var rhs = rset.pop();
|
|
if (lhs === rhs) {
|
|
continue;
|
|
} else if (typeof(lhs) === 'object' &&
|
|
typeof(rhs) === 'object' &&
|
|
typeof(lhs.length) === 'number' &&
|
|
typeof(rhs.length) === 'number' &&
|
|
lhs.length === rhs.length) {
|
|
lset.push.apply(lset, lhs);
|
|
rset.push.apply(rset, rhs);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
|
|
|
|
|
|
// recomputeGas: state number -> number
|
|
var recomputeMaxNumBouncesBeforeYield = function(MACHINE, observedDelay) {
|
|
// We'd like to see a delay of DESIRED_DELAY_BETWEEN_BOUNCES so
|
|
// that we get MACHINE.params.desiredYieldsPerSecond bounces per
|
|
// second.
|
|
var DESIRED_DELAY_BETWEEN_BOUNCES =
|
|
(1000 / MACHINE.params.desiredYieldsPerSecond);
|
|
var ALPHA = 256;
|
|
var delta = (ALPHA * ((DESIRED_DELAY_BETWEEN_BOUNCES -
|
|
observedDelay) /
|
|
DESIRED_DELAY_BETWEEN_BOUNCES));
|
|
MACHINE.params.maxNumBouncesBeforeYield =
|
|
Math.max(MACHINE.params.maxNumBouncesBeforeYield + delta,
|
|
1);
|
|
};
|
|
|
|
|
|
var trampoline = function(MACHINE, initialJump) {
|
|
var thunk = initialJump;
|
|
var startTime = (new Date()).valueOf();
|
|
MACHINE.callsBeforeTrampoline = 100;
|
|
MACHINE.params.numBouncesBeforeYield =
|
|
MACHINE.params.maxNumBouncesBeforeYield;
|
|
MACHINE.running = true;
|
|
|
|
while(thunk) {
|
|
try {
|
|
thunk(MACHINE);
|
|
break;
|
|
} catch (e) {
|
|
if (typeof(e) === 'function') {
|
|
thunk = e;
|
|
MACHINE.callsBeforeTrampoline = 100;
|
|
|
|
if (MACHINE.params.numBouncesBeforeYield-- < 0) {
|
|
recomputeMaxNumBouncesBeforeYield(
|
|
MACHINE,
|
|
(new Date()).valueOf() - startTime);
|
|
setTimeout(
|
|
function() {
|
|
trampoline(MACHINE, thunk);
|
|
},
|
|
0);
|
|
return;
|
|
}
|
|
} else {
|
|
MACHINE.running = false;
|
|
return MACHINE.params.currentErrorHandler(MACHINE, e);
|
|
}
|
|
}
|
|
}
|
|
MACHINE.running = false;
|
|
return MACHINE.params.currentSuccessHandler(MACHINE);
|
|
};
|
|
|
|
|
|
|
|
|
|
// Exports
|
|
exports['Machine'] = Machine;
|
|
exports['CallFrame'] = CallFrame;
|
|
exports['PromptFrame'] = PromptFrame;
|
|
exports['Closure'] = Closure;
|
|
exports['ContinuationPromptTag'] = ContinuationPromptTag;
|
|
exports['DEFAULT_CONTINUATION_PROMPT_TAG'] =
|
|
DEFAULT_CONTINUATION_PROMPT_TAG;
|
|
exports['NULL'] = NULL;
|
|
|
|
exports['testArgument'] = testArgument;
|
|
exports['testArity'] = testArity;
|
|
exports['raise'] = raise;
|
|
|
|
exports['captureControl'] = captureControl;
|
|
exports['restoreControl'] = restoreControl;
|
|
|
|
exports['isNumber'] = isNumber;
|
|
exports['isPair'] = isPair;
|
|
exports['isVector'] = isVector;
|
|
exports['isOutputPort'] = isOutputPort;
|
|
exports['isOutputStringPort'] = isOutputStringPort;
|
|
|
|
exports['heir'] = heir;
|
|
exports['makeClassPredicate'] = makeClassPredicate;
|
|
|
|
exports['trampoline'] = trampoline;
|
|
|
|
}).call(this); |