use*_*050 6 javascript interpreter delay pausing-execution
我刚刚在C#中构建了一个C解释器,现在开始将它转换为Javascript.一切都很顺利,直到我意识到js没有睡眠功能.我的解释器使用递归解析器,它暂停用户输入,同时它嵌套了几个深层函数(在C#中我在第二个线程中使用了waithandle).我查看了setInterval和setTimeout,但它们是异步/非阻塞的; 当然,busywait是不可能的,我查看了我在SO上找到的timed_queue实现,但没有运气.我在主窗口和webworker中都尝试过解析器.我正在使用jQuery.我对js的经验有限,我正在寻找想法.我对继续传递风格或收益率知之甚少,我想知道他们是否可能持有关键.这里有一些从代码中删除来显示一些控件脚本.任何想法请...
var STATE = {
START: "START",
RUN: "RUN", //take continuous steps at waitTime delay
STEP: "STEP", //take 1 step
PAUSE: "PAUSE",//wait for next step command
STOP: "STOP",
ERROR: "ERROR"
}
var state = state.STOP;
function parsing_process() //long process we may want to pause or wait in
{
while(token !== end_of_file)//
{
//do lots of stuff - much of it recursive
//the call to getNextToken will be encountered a lot in the recursion
getNextToken();
if (state === STATE.STOP)
break;
}
}
function getNextToken()
{
//retrieve next token from lexer array
if (token === end_of_line)
{
//tell the gui to highlight the current line
if (state === STATE.STOP)
return;
if (state === STATE.STEP)//wait for next step
{
//mimick wait for user input by using annoying alert
alert("click me to continue")
}
if (state === STATE.RUN) {
//a delay here - set by a slider in the window
//a busy wait haults processing of the window
}
}
}
我已经使用task.js在Firefox中使用它
<html>
<head>
<title>task.js examples: sleep</title>
<script type="application/javascript" src="task.js"></script>
</head>
<body>
Only works in FIREFOX
<button onclick="step()">Step</button>
<button onclick="run()">Run</button>
<button onclick="stop()">Stop</button>
<pre style="border: solid 1px black; width: 300px; height: 200px;" id="out">
</pre>
<script type="application/javascript;version=1.8">
function start() {
process();
}
function step() {
if (state === STATE.STOP)
start();
state = STATE.STEP;
}
function run() {
if (state === STATE.STOP)
start();
state = STATE.RUN;
}
function stop() {
state = STATE.STOP;
}
var STATE = {
START: "START",
RUN: "RUN", //take continuous steps at sleepTime delay
STEP: "STEP", //take 1 step
PAUSE: "PAUSE",//wait for next step command
STOP: "STOP",
ERROR: "ERROR"
}
var state = STATE.STOP;
var sleepTime = 500;
function process() {
var { spawn, choose, sleep } = task;
var out = document.getElementById("out");
var i=0;
out.innerHTML = "i="+i;
var sp = spawn(function() {
while(state !== STATE.STOP)
{
i++;
out.innerHTML = "i="+i;
if (state === STATE.RUN)
{
yield sleep(sleepTime);
}
if (state === STATE.STEP)
state = STATE.PAUSE;
while (state===STATE.PAUSE)
{
yield;
}
}
});
}
</script>
</body>
</html>
如果有人对承诺有所了解,可以给我一些更多的线索,我将不胜感激.我的应用程序不是消费者的应用程序,但如果它的运行速度超过Firefox则会很好
作为JSCPP的作者，当我实现一个暂停并继续动态解释程序的调试器时，我遇到了完全相同的问题。最后我决定使用 es6 的生成器函数，但我想在这里分享我的思考过程。
常见的方法是首先将目标代码编译成低级无递归字节码。unconditional jump您标记每个语句，然后使用和处理所有控制流conditional jump。然后在其上运行字节码解释器。如果您不介意完成所有这些编译工作，这是一个不错的选择。
另一种方式是“调用堆栈保存/调用堆栈加载”工作流程。当您需要暂停解释时，您可以递归地将所有参数和所有局部变量推入自定义堆栈，一直回到底部。当您需要继续执行时，您递归地加载所有这些参数和局部变量。您的代码将从
AddExpression.prototype.visit = function(param) {
var leftVal = visit(this.left, param);
var rightVal = visit(this.right, param);
return leftVal + rightVal;
}
到
AddExpression.prototype.visit = function(param) {
if (needToStop) {
stack.push({
method: AddExpression.prototype.visit,
_this: this,
params: [param],
locals: {},
step: 0
});
return;
}
if (recoverFromStop && stack.top().step === 0) {
var thisCall = stack.pop();
if (stack.length > 0) {
var nextCall = stack.top();
nextCall.method.apply(nextCall._this, params);
}
}
var leftvalue = visit(this.left, param);
if (needToStop) {
stack.push({
method: AddExpression.prototype.visit,
_this: this,
params: [],
locals: {
leftvalue: leftvalue
},
step: 1
});
return;
}
if (recoverFromStop && stack.top().step === 1) {
var thisCall = stack.pop();
leftvalue = thisCall.locals.leftvalue;
if (stack.length > 0) {
var nextCall = stack.top();
nextCall.method.apply(nextCall._this, params);
}
}
var rightvalue = visit(this.right, param);
if (needToStop) {
stack.push({
method: AddExpression.prototype.visit,
_this: this,
params: [],
locals: {
leftvalue: leftvalue,
rightvalue: rightvalue
},
step: 2
});
return;
}
if (recoverFromStop && stack.top().step === 2) {
var thisCall = stack.pop();
leftvalue = thisCall.locals.leftvalue;
rightvalue = thisCall.locals.rightvalue;
if (stack.length > 0) {
var nextCall = stack.top();
nextCall.method.apply(nextCall._this, params);
}
}
return leftvalue + rightvalue;
};
此方法不会改变解释器的主要逻辑，但您可以亲眼看到对于简单的 A+B 语法来说，代码是多么疯狂。
最后我决定使用发电机。生成器并不是用于交互式地改变程序执行，而是用于惰性求值的目的。但是通过一些简单的黑客攻击，我们可以在收到“继续”命令时使用惰性评估我们的语句。
function interpret(mainNode, param) {
var step;
var gen = visit(mainNode);
do {
step = gen.next();
} while(!step.done);
return step.value;
}
function visit*(node, param) {
return (yield* node.visit(param));
}
AddExpression.prototype.visit = function*(param) {
var leftvalue = yield* visit(this.left, param);
var rightvalue = yield* visit(this.right, param);
return leftvalue + rightvalue;
}
这里，function*表示我们希望该AddExpression.visit函数成为生成器函数。yield*后面跟的visitcall表示visit函数本身是一个递归生成器函数。
这个解决方案乍一看似乎很完美，但由于使用生成器（ http://jsperf.com/generator-performance ） ，它的性能大幅下降，而且它来自 es6，支持它的浏览器并不多。
总而言之，您可以通过三种不同的方式来实现可中断执行：
| 归档时间： |
|
| 查看次数： |
1558 次 |
| 最近记录： |