--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/engine-runner.js	Sun May 11 12:51:23 2008 -0700
@@ -0,0 +1,140 @@
+function Zui() {
+}
+
+Zui.prototype = {
+    onLineInput: function(callback) {
+    },
+    onCharacterInput: function(callback) {
+    },
+    onSave: function(callback) {
+    },
+    onRestore: function(callback) {
+    },
+    onQuit: function() {
+    },
+    onRestart: function(callback) {
+    },
+    onWimpOut: function(callback) {
+    },
+    onBreakpoint: function(callback) {
+    },
+    onSetStyle: function(textStyle, foreground, background) {
+    },
+    onSplitWindow: function() {
+    },
+    onSetWindow: function() {
+    },
+    onEraseWindow: function() {
+    },
+    onEraseLine: function() {
+    },
+    onSetCursor: function(x, y) {
+    },
+    onSetBufferMode: function() {
+    },
+    onSetInputStream: function() {
+    },
+    onGetCursor: function() {
+    },
+    onPrintTable: function(lines) {
+    },
+};
+
+function EngineRunner(engine, zui) {
+    this._engine = engine;
+    this._zui = zui;
+    this._isRunning = false;
+    this._isInLoop = false;
+    this._isWaitingForCallback = false;
+
+    var self = this;
+
+    this.__proto__ = {
+        stop: function() {
+            self._isRunning = false;
+        },
+
+        run: function() {
+            self._isRunning = true;
+            self._continueRunning();
+        },
+
+        _continueRunning: function() {
+            while (self._isRunning && !self._isWaitingForCallback) {
+                self._loop();
+            }
+        },
+
+        _receiveLineInput: function(input) {
+            self._isWaitingForCallback = false;
+            self._engine.answer(1, input);
+            if (!self._isInLoop) {
+                self._continueRunning();
+            } else {
+                /* We're still inside _loop(), so just return. */
+            }
+        },
+
+        _loop: function() {
+            if (self._isInLoop)
+                throw Error("Already in loop!");
+
+            self._isInLoop = true;
+            var engine = self._engine;
+
+            engine.run();
+            var effect = '"' + engine.effect(0) + '"';
+
+            switch (effect) {
+            case GNUSTO_EFFECT_INPUT:
+                self._isWaitingForCallback = true;
+                self._zui.onLineInput(self._receiveLineInput);
+                break;
+            case GNUSTO_EFFECT_INPUT_CHAR:
+                break;
+            case GNUSTO_EFFECT_SAVE:
+                break;
+            case GNUSTO_EFFECT_RESTORE:
+                break;
+            case GNUSTO_EFFECT_QUIT:
+                self.stop();
+                self._zui.onQuit();
+                break;
+            case GNUSTO_EFFECT_RESTART:
+                break;
+            case GNUSTO_EFFECT_WIMP_OUT:
+                break;
+            case GNUSTO_EFFECT_BREAKPOINT:
+                break;
+            case GNUSTO_EFFECT_FLAGS_CHANGED:
+                break;
+            case GNUSTO_EFFECT_PIRACY:
+                break;
+            case GNUSTO_EFFECT_STYLE:
+                break;
+            case GNUSTO_EFFECT_SOUND:
+                break;
+            case GNUSTO_EFFECT_SPLITWINDOW:
+                break;
+            case GNUSTO_EFFECT_SETWINDOW:
+                break;
+            case GNUSTO_EFFECT_ERASEWINDOW:
+                break;
+            case GNUSTO_EFFECT_ERASELINE:
+                break;
+            case GNUSTO_EFFECT_SETCURSOR:
+                break;
+            case GNUSTO_EFFECT_SETBUFFERMODE:
+                break;
+            case GNUSTO_EFFECT_SETINPUTSTREAM:
+                break;
+            case GNUSTO_EFFECT_GETCURSOR:
+                break;
+            case GNUSTO_EFFECT_PRINTTABLE:
+                break;
+            }
+
+            self._isInLoop = false;
+        }
+    };
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test_engine_runner.js	Sun May 11 12:51:23 2008 -0700
@@ -0,0 +1,34 @@
+load("gnusto-engine.js");
+load("engine-runner.js");
+
+function FakeEngine() {
+    var self = this;
+
+    this.__proto__ = {
+        run: function() {
+        },
+
+        effect: function() {
+            return GNUSTO_EFFECT_QUIT.slice(1, -1);
+        }
+    };
+}
+
+function QuitOnlyZui() {
+    var self = this;
+
+    self.hasQuit = false;
+
+    this.__proto__ = {
+        onQuit: function() {
+            self.hasQuit = true;
+        }
+    };
+};
+
+var gZui = new QuitOnlyZui();
+var gRunner = new EngineRunner(new FakeEngine(), gZui);
+gRunner.run();
+if (!gZui.hasQuit)
+    throw Error('zui onQuit() not called.');
+print('Engine runner test run successfully.');