suzanne.soy/whalesong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactoring to be closer to the evaluator js in WeScheme

Browse Source
This commit is contained in:
Danny Yoo 2013-03-28 17:19:00 -06:00
parent a371c3ffcf
commit 37551af8b1
3 changed files with 210 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
whalesong/repl-prototype/htdocs/index.html
View File

@ -5,6 +5,7 @@
<script src="collects/library.js"></script>
<script src="easyXDM-min.js"></script>
<script src="repl.js"></script>
<script src="index.js"></script>
</head>
<body>
<h1>Repl experiment</h1>
@ -14,6 +15,6 @@
<div id="output" style="width:500px; height:300px; border:1px solid black; overflow:scroll"></div>
<br/>
<input id="repl" type="text" style="width:500px"></input><img id="break" src="break.png"/>
<input id="prompt" type="text" style="width:500px"></input><img id="break" src="break.png"/>
</body>
</html>

69
whalesong/repl-prototype/htdocs/index.js Normal file
View File

@ -0,0 +1,69 @@
jQuery(document).ready(function() {
"use strict";
var prompt = jQuery("#prompt");
var output = jQuery("#output");
var breakButton = jQuery("#break");
var resetButton = jQuery("#reset");
var write = function(dom) {
output.append(dom);
output.get(0).scrollTop = output.get(0).scrollHeight;
};
var onBreak = function() {
repl.requestBreak(allowInput);
};
var allowInput = function() {
prompt.val('');
prompt.removeAttr('disabled');
breakButton.hide();
};
var onReset = function() {
repl.reset(allowInput);
};
var onExpressionEntered = function() {
var src = prompt.val();
jQuery(this).val("");
prompt.attr('disabled', 'true');
prompt.val("... evaluating...");
breakButton.show();
repl.compileAndExecuteProgram('interactions',
src,
allowInput,
onError);
};
var onError = function(err) {
console.log(err);
if (err.message) {
write(jQuery('<span/>').css('color', 'red').append(err.message));
write(jQuery('<br/>'));
}
allowInput();
};
breakButton.hide();
breakButton.click(onBreak);
resetButton.click(onReset);
prompt.attr('disabled', 'true');
prompt.val('Please wait, initializing...');
prompt.keypress(function(e) {
if (e.which == 13 && !prompt.attr('disabled')) {
onExpressionEntered();
}});
var afterReplSetup = function() {
prompt.val('');
prompt.removeAttr('disabled');
};
var repl = new plt.runtime.Repl({ write: write }, afterReplSetup);
});

305
whalesong/repl-prototype/htdocs/repl.js
View File

@ -1,103 +1,152 @@
jQuery(document).ready(function() {
(function() {
"use strict";
// if (! console.log) { console.log = function() { }; }
// options: { compilerUrl: string,,
// write: (dom-node -> void)
// language: string }
var Repl = function(options, afterSetup) {
this.M = plt.runtime.currentMachine;
var repl = jQuery("#repl");
var output = jQuery("#output");
var breakButton = jQuery("#break");
var resetButton = jQuery("#reset");
// The machine.
var M;
var interactionsCount = 0;
var sendOutputToBottom = function() {
output.get(0).scrollTop = output.get(0).scrollHeight;
};
var xhr = new easyXDM.Rpc(
{ remote: 'rpc.html' },
this.xhr = new easyXDM.Rpc(
{ remote: options.compilerUrl || 'rpc.html' },
{ remote: { replCompile: {} } });
if (options.write) { this.write = options.write; }
var onBreak = function() {
if (M.running) {
interruptEvaluation(function(){});
this.language = (options.language ||
'whalesong/wescheme/lang/semantics.rkt');
setupMachine(this, afterSetup);
};
// write: dom-node -> void
// Expected to be overridden by others via options.write.
Repl.prototype.write = function(dom) {
jQuery(document.body).append(dom)
};
// Return true if the Repl is currently evaluating.
Repl.prototype.isRunning = function() {
return this.M.running;
};
// Request a break on the current evaluation, calling afterBreak
// once the break succeeds. If no evaluation is running, immediately
// call afterBreak.
Repl.prototype.requestBreak = function(afterBreak) {
if (this.M.running) {
interruptEvaluation(this, afterBreak);
} else {
afterBreak();
}
};
var onReset = function() {
if (M.running) {
M.params.currentDisplayer =
var interruptEvaluation = function(that, afterBreak) {
if (! that.M.running) {
throw new Error("internal error: trying to interrupt evaluation but nothing is running.");
}
that.M.scheduleBreak(afterBreak);
};
// Resets the evaluator, quietly interrupting evaluation if
// necessary.
Repl.prototype.reset = function(afterReset) {
var that = this;
if (this.M.running) {
this.M.params.currentDisplayer =
function(MACHINE, domNode) {};
M.params.currentErrorDisplayer =
this.M.params.currentErrorDisplayer =
function(MACHINE, domNode) {};
interruptEvaluation(
that,
function() {
output.empty();
setupMachine();
setupMachine(that, afterReset);
});
} else {
output.empty();
setupMachine();
setupMachine(that, afterReset);
}
};
var setupMachine = function() {
M = plt.runtime.currentMachine;
var setupMachine = function(that, afterSetup) {
var M = that.M;
M.reset();
// We configure output to send it to the "output" DOM node.
// We configure the machine's output to send it to the
// "output" DOM node.
M.params.currentDisplayer = function(MACHINE, domNode) {
jQuery(domNode).appendTo(output);
sendOutputToBottom();
that.write(domNode);
};
M.params.currentErrorDisplayer = function(MACHINE, domNode) {
jQuery(domNode).css("color", "red").appendTo(output);
sendOutputToBottom();
that.write(domNode);
};
// FIXME: add other parameter settings here.
// We then want to initialize the language module.
var initializeLanguage = function(afterLanguageInitialization) {
// Load up the language.
M.loadAndInvoke('whalesong/wescheme/lang/semantics.rkt',
M.loadAndInvoke(
that.language,
function() {
var semanticsModule =
M.modules['whalesong/wescheme/lang/semantics.rkt'];
var semanticsModule = M.modules[that.language];
// FIXME: this should be getting the namespace,
// not the export dictionary...
M.params.currentNamespace = semanticsModule.getExports();
afterLanguageInitialization();
afterSetup();
},
function(err) {
// Nothing should work if we can't get this to work.
alert("uh oh!: language could not be loaded.");
});
};
repl.attr('disabled', 'true');
repl.val('Please wait, initializing...');
initializeLanguage(
function() {
repl.val('');
repl.removeAttr('disabled');
// Hook up a simple one-line REPL with enter triggering evaluation.
repl.keypress(function(e) {
if (e.which == 13 && !repl.attr('disabled')) {
var src = repl.val();
jQuery(this).val("");
repl.attr('disabled', 'true');
repl.val("... evaluating...");
breakButton.show();
compileAndEvaluate(src,
function() { repl.removeAttr('disabled');
repl.val("");
breakButton.hide();});
}
});
});
Repl.prototype.compileAndExecuteProgram = function(programName, code,
onDone, onDoneError) {
var that = this;
this.compileProgram(
programName,
code,
function(compiledCode) {
that.executeCompiledProgram(compiledCode,
onDone,
onDoneError);
},
onDoneError);
};
Repl.prototype.compileProgram = function(programName, code,
onDone, onDoneError) {
this.xhr.replCompile(programName, code, onDone, onDoneError);
};
Repl.prototype.executeCompiledProgram = function(compiledResult,
onDoneSuccess, onDoneFail) {
var that = this;
// compiledResult.compiledCodes is an array of function chunks.
// The evaluation leaves the value register of the machine
// to contain the list of values from toplevel evaluation.
var compiledCodes = compiledResult.compiledCodes;
forEachK(compiledCodes,
function(code, k) {
// Indirect eval usage here is deliberate.
var codeFunction = (0,eval)(code);
var onGoodEvaluation = function() {
var resultList = that.M.v;
while(resultList !== plt.baselib.lists.EMPTY) {
print(that, resultList.first);
resultList = resultList.rest;
};
k();
};
var onBadEvaluation = function(M, err) {
onDoneFail(err);
};
codeFunction(that.M, onGoodEvaluation, onBadEvaluation);
},
onDoneSuccess);
};
@ -115,117 +164,23 @@ jQuery(document).ready(function() {
};
// writeErrorMessage: string -> void
// Write out an error message.
var writeErrorMessage = function(msg) {
M.params.currentErrorDisplayer(M,
jQuery("<span/>")
.text(''+msg)
.css("color", "red"));
M.params.currentErrorDisplayer(M, jQuery("<br/>"));
sendOutputToBottom();
};
// Print: Racket value -> void
// Prints the racket value out.
var print = function(elt) {
var outputPort =
M.params.currentOutputPort;
// Print: Repl racket-value -> void
// Prints the racket value out, followed by a newline,
// unless VOID is being printed.
var print = function(that, elt) {
var outputPort = that.M.params.currentOutputPort;
if (elt !== plt.runtime.VOID) {
outputPort.writeDomNode(
M,
plt.runtime.toDomNode(elt, M.params['print-mode']));
outputPort.writeDomNode(M, plt.runtime.toDomNode("\n", 'display'));
}
};
var interruptEvaluation = function(afterBreak) {
if (! M.running) {
throw new Error("internal error: trying to interrupt evaluation but nothing is running.");
}
M.scheduleBreak(afterBreak);
};
// In evaluation, we'll send compilation requests to the server,
// and get back bytecode that we should evaluate.
var compileAndEvaluate = function(src, after) {
M.params.currentDisplayer(M, jQuery("<tt/>").text('> ' + src));
M.params.currentDisplayer(M, jQuery("<br/>"));
var onCompile = function(compiledResult) {
if (compiledResult.type === 'repl') {
return onGoodReplCompile(compiledResult);
} else if (compiledResult.type === 'module') {
alert('internal error: module unexpected');
after();
} else if (compiledResult.type === 'error') {
return onCompileTimeError(compiledResult);
that.M,
plt.runtime.toDomNode(elt, that.M.params['print-mode']));
outputPort.writeDomNode(that.M,
plt.runtime.toDomNode("\n", 'display'));
}
};
var onCompileTimeError = function(compiledResult) {
writeErrorMessage(compiledResult.message);
after();
};
var onGoodReplCompile = function(compiledResult) {
// compiledResult.compiledCodes is an array of function chunks.
// The evaluation leaves the value register of the machine
// to contain the list of values from toplevel evaluation.
var compiledCodes = compiledResult.compiledCodes;
forEachK(compiledCodes,
function(code, k) {
// Indirect eval usage here is deliberate.
var codeFunction = (0,eval)(code);
var onGoodEvaluation = function() {
var resultList = M.v;
while(resultList !== plt.baselib.lists.EMPTY) {
print(resultList.first);
resultList = resultList.rest;
};
k();
};
var onBadEvaluation = function(M, err) {
if (err.message) {
writeErrorMessage(err.message);
}
after();
};
codeFunction(M, onGoodEvaluation, onBadEvaluation);
},
after);
};
var onServerError = function(err) {
writeErrorMessage("internal server error");
after();
};
xhr.replCompile("<interactions" + interactionsCount + ">",
src, onCompile, onServerError);
interactionsCount = interactionsCount + 1;
};
// Things that we need to make as automated tests:
//
// Make sure: (let () (define (f x) (f x)) (f 42))
// is interruptable.
//
// Test: simple expressions, functions, etc.
//
// Test: multiple value return, even zero
//
// Test: require image library, try drawing a few things.
//
// Test: compile a module.
//
breakButton.hide();
breakButton.click(onBreak);
resetButton.click(onReset);
setupMachine();
});
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Expose to the outside world as plt.runtime.Repl.
plt.runtime.Repl = Repl;
}());