GLK: QUEST: Initial subengine commit

29 files changed, 8735 insertions, 0 deletions

diff --git a/engines/glk/detection.cpp b/engines/glk/detection.cpp
index 60b2faa01c..f6531723d0 100644
--- a/engines/glk/detection.cpp
+++ b/engines/glk/detection.cpp
@@ -39,6 +39,8 @@
 #include "glk/hugo/hugo.h"
 #include "glk/magnetic/detection.h"
 #include "glk/magnetic/magnetic.h"
+#include "glk/quest/detection.h"
+#include "glk/quest/quest.h"
 #include "glk/scott/detection.h"
 #include "glk/scott/scott.h"
 #include "glk/tads/detection.h"
@@ -163,6 +165,7 @@ Common::Error GlkMetaEngine::createInstance(OSystem *syst, Engine **engine) cons
 	else if ((*engine = create<Glk::Frotz::FrotzMetaEngine, Glk::Frotz::Frotz>(syst, gameDesc)) != nullptr) {}
 	else if ((*engine = create<Glk::Glulxe::GlulxeMetaEngine, Glk::Glulxe::Glulxe>(syst, gameDesc)) != nullptr) {}
 	else if ((*engine = create<Glk::Hugo::HugoMetaEngine, Glk::Hugo::Hugo>(syst, gameDesc)) != nullptr) {}
+	else if ((*engine = create<Glk::Quest::QuestMetaEngine, Glk::Quest::Quest>(syst, gameDesc)) != nullptr) {}
 	else if ((*engine = create<Glk::Scott::ScottMetaEngine, Glk::Scott::Scott>(syst, gameDesc)) != nullptr) {}
 #ifndef RELEASE_BUILD
 	else if ((*engine = create<Glk::Magnetic::MagneticMetaEngine, Glk::Magnetic::Magnetic>(syst, gameDesc)) != nullptr) {}
@@ -211,6 +214,7 @@ PlainGameList GlkMetaEngine::getSupportedGames() const {
 	Glk::Frotz::FrotzMetaEngine::getSupportedGames(list);
 	Glk::Glulxe::GlulxeMetaEngine::getSupportedGames(list);
 	Glk::Hugo::HugoMetaEngine::getSupportedGames(list);
+	Glk::Quest::QuestMetaEngine::getSupportedGames(list);
 	Glk::Scott::ScottMetaEngine::getSupportedGames(list);
 #ifndef RELEASE_BUILD
 	Glk::Magnetic::MagneticMetaEngine::getSupportedGames(list);
@@ -242,6 +246,9 @@ PlainGameDescriptor GlkMetaEngine::findGame(const char *gameId) const {
 	gd = Glk::Hugo::HugoMetaEngine::findGame(gameId);
 	if (gd._description) return gd;
 
+	gd = Glk::Quest::QuestMetaEngine::findGame(gameId);
+	if (gd._description) return gd;
+
 	gd = Glk::Scott::ScottMetaEngine::findGame(gameId);
 	if (gd._description) return gd;
 
@@ -267,6 +274,7 @@ DetectedGames GlkMetaEngine::detectGames(const Common::FSList &fslist) const {
 	Glk::Frotz::FrotzMetaEngine::detectGames(fslist, detectedGames);
 	Glk::Glulxe::GlulxeMetaEngine::detectGames(fslist, detectedGames);
 	Glk::Hugo::HugoMetaEngine::detectGames(fslist, detectedGames);
+	Glk::Quest::QuestMetaEngine::detectGames(fslist, detectedGames);
 	Glk::Scott::ScottMetaEngine::detectGames(fslist, detectedGames);
 
 #ifndef RELEASE_BUILD
@@ -286,6 +294,7 @@ void GlkMetaEngine::detectClashes() const {
 	Glk::Frotz::FrotzMetaEngine::detectClashes(map);
 	Glk::Glulxe::GlulxeMetaEngine::detectClashes(map);
 	Glk::Hugo::HugoMetaEngine::detectClashes(map);
+	Glk::Quest::QuestMetaEngine::detectClashes(map);
 	Glk::Scott::ScottMetaEngine::detectClashes(map);
 
 #ifndef RELEASE_BUILD
diff --git a/engines/glk/glk_types.h b/engines/glk/glk_types.h
index ca20fe8a06..f99d2b1972 100644
--- a/engines/glk/glk_types.h
+++ b/engines/glk/glk_types.h
@@ -48,6 +48,7 @@ enum InterpreterType {
 	INTERPRETER_JACL,
 	INTERPRETER_LEVEL9,
 	INTERPRETER_MAGNETIC,
+	INTERPRETER_QUEST,
 	INTERPRETER_SCARE,
 	INTERPRETER_SCOTT,
 	INTERPRETER_TADS2,
diff --git a/engines/glk/module.mk b/engines/glk/module.mk
index dd63c77952..4f4608af83 100644
--- a/engines/glk/module.mk
+++ b/engines/glk/module.mk
@@ -182,6 +182,17 @@ MODULE_OBJS := \
 	magnetic/graphics.o \
 	magnetic/magnetic.o \
 	magnetic/sound.o \
+	quest/detection.o \
+	quest/geas_file.o \
+	quest/geas_glk.o \
+	quest/geas_runner.o \
+	quest/geas_state.o \
+	quest/geas_util.o \
+	quest/quest.o \
+	quest/tstring.o \
+	quest/read_file.o \
+	quest/string.o \
+	quest/streams.o \
 	scott/detection.o \
 	scott/scott.o \
 	tads/detection.o \
diff --git a/engines/glk/quest/detection.cpp b/engines/glk/quest/detection.cpp
new file mode 100644
index 0000000000..a0aa6b8634
--- /dev/null
+++ b/engines/glk/quest/detection.cpp
@@ -0,0 +1,93 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/detection.h"
+#include "glk/quest/detection_tables.h"
+#include "common/debug.h"
+#include "common/file.h"
+#include "common/md5.h"
+#include "engines/game.h"
+
+namespace Glk {
+namespace Quest {
+
+void QuestMetaEngine::getSupportedGames(PlainGameList &games) {
+	for (const PlainGameDescriptor *pd = QUEST_GAME_LIST; pd->gameId; ++pd)
+		games.push_back(*pd);
+}
+
+GameDescriptor QuestMetaEngine::findGame(const char *gameId) {
+	for (const PlainGameDescriptor *pd = QUEST_GAME_LIST; pd->gameId; ++pd) {
+		if (!strcmp(gameId, pd->gameId))
+			return *pd;
+	}
+
+	return GameDescriptor::empty();
+}
+
+bool QuestMetaEngine::detectGames(const Common::FSList &fslist, DetectedGames &gameList) {
+	// Loop through the files of the folder
+	for (Common::FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
+		// Check for a recognised filename
+		if (file->isDirectory())
+			continue;
+
+		Common::String filename = file->getName();
+		if (!filename.hasSuffixIgnoreCase(".quest"))
+			continue;
+
+		Common::File gameFile;
+		if (!gameFile.open(*file))
+			continue;
+
+		gameFile.seek(0);
+		Common::String md5 = Common::computeStreamMD5AsString(gameFile, 5000);
+		uint32 filesize = gameFile.size();
+
+		// Scan through the Quest game list for a match
+		const GlkDetectionEntry *p = QUEST_GAMES;
+		while (p->_md5 && p->_filesize != filesize && md5 != p->_md5)
+			++p;
+
+		if (!p->_gameId) {
+			const PlainGameDescriptor &desc = QUEST_GAME_LIST[0];
+			gameList.push_back(GlkDetectedGame(desc.gameId, desc.description, filename, md5, filesize));
+		} else {
+			// Found a match
+			PlainGameDescriptor gameDesc = findGame(p->_gameId);
+			gameList.push_back(GlkDetectedGame(p->_gameId, gameDesc.description, filename));
+		}
+	}
+
+	return !gameList.empty();
+}
+
+void QuestMetaEngine::detectClashes(Common::StringMap &map) {
+	for (const PlainGameDescriptor *pd = QUEST_GAME_LIST; pd->gameId; ++pd) {
+		if (map.contains(pd->gameId))
+			error("Duplicate game Id found - %s", pd->gameId);
+		map[pd->gameId] = "";
+	}
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/detection.h b/engines/glk/quest/detection.h
new file mode 100644
index 0000000000..d94e40da95
--- /dev/null
+++ b/engines/glk/quest/detection.h
@@ -0,0 +1,60 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_DETECTION
+#define GLK_QUEST_DETECTION
+
+#include "common/fs.h"
+#include "common/hash-str.h"
+#include "engines/game.h"
+#include "glk/detection.h"
+
+namespace Glk {
+namespace Quest {
+
+class QuestMetaEngine {
+public:
+	/**
+	 * Get a list of supported games
+	 */
+	static void getSupportedGames(PlainGameList &games);
+
+	/**
+	 * Returns a game description for the given game Id, if it's supported
+	 */
+	static GameDescriptor findGame(const char *gameId);
+
+	/**
+	 * Detect supported games
+	 */
+	static bool detectGames(const Common::FSList &fslist, DetectedGames &gameList);
+
+	/**
+	 * Check for game Id clashes with other sub-engines
+	 */
+	static void detectClashes(Common::StringMap &map);
+};
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/detection_tables.h b/engines/glk/quest/detection_tables.h
new file mode 100644
index 0000000000..8e1fe11ba6
--- /dev/null
+++ b/engines/glk/quest/detection_tables.h
@@ -0,0 +1,81 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "engines/game.h"
+#include "common/gui_options.h"
+#include "common/language.h"
+
+namespace Glk {
+namespace Quest {
+
+const PlainGameDescriptor QUEST_GAME_LIST[] = {
+	{ "quest", "Quest Game" },
+
+	{ "attackonfrightside", "Attack On Frightside" },
+	{ "balaclava", "Balaclava" },
+	{ "bearsepicquest", "Bear's Epic Quest" },
+	{ "caught", "Caught!" },
+	{ "cuttings", "Cuttings" },
+	{ "draculacrl", "Dracula: CRL remake" },
+	{ "elections4", "It's election time in Pakistan: Go rich boy, go!" },
+	{ "everyman", "Everyman" },
+	{ "firstTimes", "First Times" },
+	{ "giftofthemagi", "Gift of the Magi" },
+	{ "medievalistsquest", "Medievalist's Quest" },
+	{ "parishotel", "Welcome to the Paris Hotel" },
+	{ "questforloot", "Quest for loot and something else" },
+	{ "sleepingassassin", "El asesino durmiente (The Sleeping Assassin)" },
+	{ "spondre", "Spondre" },
+	{ "thelasthero", "The Last Hero" },
+	{ "tokindlealight", "To Kindle a Light" },
+	{ "xanadu", "Xanadu - The World's Only Hope" },
+
+	{ nullptr, nullptr }
+};
+
+const GlkDetectionEntry QUEST_GAMES[] = {
+  DT_ENTRY0("attackonfrightside", "84542fc6460833bbf2594ed83f8b1fc7", 46019),
+  DT_ENTRY0("balaclava", "8b30af05d9986f9f962c677181ecc766", 57719),
+  DT_ENTRY0("bearsepicquest", "e6896a65527f456b4362aaebcf39e354", 62075),
+  DT_ENTRY0("caught", "4502d89d8e304fe4165d46eb22f21f10", 5168593),
+  DT_ENTRY0("cuttings", "e0ded5a6b78e8c9482e746d55f61972c", 6583866),
+  DT_ENTRY0("draculacrl", "1af3ec877584b290f7ab1a1be8f944a5", 4548737),
+  DT_ENTRY0("elections4", "d0bc0cd54182d6099808767068592b94", 591994),
+  DT_ENTRY0("everyman", "410c7211d3f0c700f34e97ed258e33f1", 56218),
+  DT_ENTRY0("firstTimes", "31d878c82d99856d473762612f154eb6", 10253826),
+  DT_ENTRY0("giftofthemagi", "b33132ce71c8a2eed0f6c1c1af284765", 78647),
+  DT_ENTRY0("medievalistsquest", "e0a15bc2a74a0bd6bb5c24661ea35829", 127977271),
+  DT_ENTRY0("parishotel", "c9a42bc3f306aba5e318b0a74115e0d4", 474983),
+  DT_ENTRY0("questforloot", "f7e32aec0f961a59a69bead3fadff4f0", 1357373),
+  DT_ENTRY0("sleepingassassin", "9c2aa213bb73d8083506ee6f64436d9d", 287227),
+  DT_ENTRY0("spondre", "c639077eb487eb6d1b63cda2c9ba5a9b", 1169469),
+  DT_ENTRY0("thelasthero", "31e10b8a7f11a6289955b89437f8178c", 62512),
+  DT_ENTRY0("tokindlealight", "5d3b57830b003046a621620ba0869d7c", 811845),
+
+
+	DT_ENTRY0("xanadu", "fef25e3473755ec572d4236d56f918e2", 396973),
+
+	DT_END_MARKER
+};
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/geas_file.cpp b/engines/glk/quest/geas_file.cpp
new file mode 100644
index 0000000000..05c78e3e08
--- /dev/null
+++ b/engines/glk/quest/geas_file.cpp
@@ -0,0 +1,659 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/geas_file.h"
+#include "glk/quest/reserved_words.h"
+#include "glk/quest/read_file.h"
+#include "glk/quest/geas_util.h"
+#include "glk/quest/geas_impl.h"
+#include "glk/quest/streams.h"
+#include "glk/quest/string.h"
+
+namespace Glk {
+namespace Quest {
+
+void report_error(const String &s);
+
+reserved_words obj_tag_property("look", "examine", "speak", "take", "alias", "prefix", "suffix", "detail", "displaytype", "gender", "article", "hidden", "invisible", (char *) NULL);
+
+reserved_words room_tag_property("look", "alias", "prefix", "indescription", "description", "north", "south", "east", "west", "northwest", "northeast", "southeast", "southwest", "up", "down", "out", (char *) NULL);
+
+void GeasFile::debug_print(String s) const {
+	if (gi == NULL)
+		cerr << s << endl;
+	else
+		gi->debug_print(s);
+}
+
+const GeasBlock *GeasFile::find_by_name(String type, String name) const {
+	//name = lcase (name);
+	for (uint i = 0; i < size(type); i ++) {
+		//cerr << "find_by_name (" << type << ", " << name << "), vs. '"
+		//     << block(type, i).name << "'\n";
+		//if (block(type, i).lname == name)
+		if (ci_equal(block(type, i).name, name))
+			return &block(type, i);
+	}
+	return NULL;
+}
+
+const GeasBlock &GeasFile::block(String type, uint index) const {
+	StringArrayIntMap::const_iterator iter;
+	iter = type_indecies.find(type);
+	if (!(iter != type_indecies.end() && index < (*iter)._value.size()))
+		cerr << "Unable to find type " << type << "\n";
+
+	assert(iter != type_indecies.end() && index < (*iter)._value.size());
+	//assert (index >= 0 && index < size(type));
+	return blocks[(*iter)._value[index]];
+}
+
+uint GeasFile::size(String type) const {
+	//cerr << "GeasFile::size (" << type << ")" << endl;
+
+	// SENSITIVE?
+	//std::map<String, Common::Array<int>, CI_LESS>::const_iterator iter;
+	StringArrayIntMap::const_iterator iter;
+	//cerr << type_indecies << endl;
+	iter = type_indecies.find(type);
+	if (iter == type_indecies.end()) {
+		//cerr << "  returning 0" << endl;
+		return 0;
+	}
+	//cerr << "  returning " << (*iter)._value.size() << endl;
+	return (*iter)._value.size();
+}
+
+
+bool GeasFile::obj_has_property(String objname, String propname) const {
+	String tmp;
+	return get_obj_property(objname, propname, tmp);
+}
+
+Common::WriteStream &operator<< (Common::WriteStream &, const Set<String> &);
+
+/**
+ * Currently only works for actual objects, not rooms or the game
+ */
+//Set<String, CI_LESS> GeasFile::get_obj_keys (String obj) const
+Set<String> GeasFile::get_obj_keys(String obj) const {
+	//Set<String, CI_LESS> rv;
+	Set<String> rv;
+	get_obj_keys(obj, rv);
+	return rv;
+}
+
+void GeasFile::get_obj_keys(String obj, Set<String> &rv) const {
+	cerr << "get_obj_keys (gf, <" << obj << ">)\n";
+	//Set<String> rv;
+
+	uint c1, c2;
+	String tok, line;
+	reserved_words *rw = NULL;
+
+	const GeasBlock *gb = find_by_name("object", obj);
+	rw = &obj_tag_property;
+
+	if (gb == NULL) {
+		cerr << "No such object found, aborting\n";
+		//return rv;
+		return;
+	}
+
+	for (uint i = 0; i < gb->data.size(); i ++) {
+		line = gb->data[i];
+		cerr << "  handling line <" << line << ">\n";
+		tok = first_token(line, c1, c2);
+		// SENSITIVE?
+		if (tok == "properties") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok)) {
+				vstring params = split_param(param_contents(tok));
+				for (uint j = 0; j < params.size(); j ++) {
+					cerr << "   handling parameter <" << params[j] << ">\n";
+					uint k = params[j].find('=');
+					// SENSITIVE?
+					if (starts_with(params[j], "not ")) {
+						rv.insert(trim(params[j].substr(4)));
+						cerr << "     adding <" << trim(params[j].substr(4))
+						     << ">\n";
+					} else if (k == -1) {
+						rv.insert(params[j]);
+						cerr << "     adding <" << params[j] << ">\n";
+					} else {
+						rv.insert(trim(params[j].substr(0, k)));
+						cerr << "     adding <" << trim(params[j].substr(0, k))
+						     << ">\n";
+					}
+				}
+			}
+		}
+		// SENSITIVE?
+		else if (tok == "type") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok))
+				get_type_keys(param_contents(tok), rv);
+		}
+		//else if (has (tag_property, tok) && tag_property[tok])
+		else if (rw != NULL && rw->has(tok)) {
+			String tok1 = next_token(line, c1, c2);
+			if (is_param(tok1))
+				rv.insert(tok);
+		}
+	}
+
+	cerr << "Returning (" << rv << ")\n";
+}
+
+void GeasFile::get_type_keys(String typen, Set<String> &rv) const {
+	cerr << "get_type_keys (" << typen << ", " << rv << ")\n";
+	const GeasBlock *gb = find_by_name("type", typen);
+	if (gb == NULL) {
+		cerr << "  g_t_k: Nonexistent type\n";
+		return;
+	}
+	String line, tok;
+	uint c1, c2;
+	for (uint i = 0; i < gb->data.size(); i ++) {
+		line = gb->data[i];
+		//cerr << "    g_t_k: Handling line '" << line << "'\n";
+		tok = first_token(line, c1, c2);
+		// SENSISTIVE?
+		if (tok == "type") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok)) {
+				get_type_keys(param_contents(tok), rv);
+				cerr << "      g_t_k: Adding <" << tok << "> to rv: " << rv << "\n";
+			}
+		}
+		// SENSITIVE?
+		else if (tok == "action") {
+			cerr << "       action, skipping\n";
+		} else {
+			uint ch = line.find('=');
+			if (ch != -1) {
+				rv.insert(trim(line.substr(0, ch)));
+				cerr << "      adding <" << trim(line.substr(0, ch)) << ">\n";
+			}
+		}
+	}
+	cerr << "Returning (" << rv << ")\n";
+}
+
+bool GeasFile::get_obj_property(String objname, String propname, String &string_rv) const {
+	cerr << "g_o_p: Getting prop <" << propname << "> of obj <" << objname << ">\n";
+	string_rv = "!";
+	bool bool_rv = false;
+
+	//cerr << "obj_types == " << obj_types << endl;
+	/*
+	cerr << "obj_types == \n";
+	for (map<String, String>::const_iterator iter = obj_types.begin();
+	     iter != obj_types.end(); iter ++)
+	  cerr << "  " << (*iter)._key << " -> " << (*iter)._value << "\n";
+	cerr << ".\n";
+	*/
+
+	/*
+	String objtype;
+
+	if (objname == "game")
+	  objtype = "game";
+	else if (!has (obj_types, objname))
+	  {
+	    debug_print ("Checking property of nonexistent object " + objname);
+	    return false;
+	  }
+	else
+	  objtype = (*obj_types.find(objname))._value;
+	*/
+
+	if (!has(obj_types, objname)) {
+		debug_print("Checking nonexistent object <" + objname + "> for property <" + propname + ">");
+		return false;
+	}
+	String objtype = (*obj_types.find(objname))._value;
+
+	const GeasBlock *block = find_by_name(objtype, objname);
+
+	String not_prop = "not " + propname;
+	uint c1, c2;
+	assert(block != NULL);
+	//assert (block->data != NULL);
+	for (uint i = 0; i < block->data.size(); i ++) {
+		String line = block->data[i];
+		//cerr << "  g_o_p: Handling line <" << line << ">\n";
+		String tok = first_token(line, c1, c2);
+		// SENSITIVE?
+		if (tok == "type") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok))
+				get_type_property(param_contents(tok), propname, bool_rv, string_rv);
+			else {
+				debug_print("Expected parameter for type in " + line);
+			}
+		}
+		// SENSITIVE?
+		else if (tok == "properties") {
+			tok = next_token(line, c1, c2);
+			if (!is_param(tok)) {
+				debug_print("Expected param on line " + line);
+				continue;
+			}
+			Common::Array<String> props = split_param(param_contents(tok));
+			for (uint j = 0; j < props.size(); j ++) {
+				//cerr << "    g_o_p: Comparing against <" << props[j] << ">\n";
+				uint index;
+				if (props[j] == propname) {
+					//cerr << "      g_o_p: Present but empty, blanking\n";
+					string_rv = "";
+					bool_rv = true;
+				} else if (props[j] == not_prop) {
+					//cerr << "      g_o_p: Negation, removing\n";
+					string_rv = "!";
+					bool_rv = false;
+				} else if ((index = props[j].find('=')) != -1 &&
+				           (trim(props[j].substr(0, index)) == propname)) {
+					string_rv = props[j].substr(index + 1);
+					bool_rv = true;
+					//cerr << "      g_o_p: Normal prop, now to <" << string_rv << ">\n";
+				}
+			}
+		}
+	}
+	cerr << "g_o_p: Ultimately returning " << (bool_rv ? "true" : "false")
+	     << ", with String <" << string_rv << ">\n\n";
+	return bool_rv;
+}
+
+void GeasFile::get_type_property(String typenamex, String propname, bool &bool_rv, String &string_rv) const {
+	//cerr << "  Checking type <" << typenamex << "> for prop <" << propname << ">\n";
+	const GeasBlock *block = find_by_name("type", typenamex);
+	if (block == NULL) {
+		debug_print("Object of nonexistent type " + typenamex);
+		return;
+	}
+	for (uint i = 0; i < block->data.size(); i ++) {
+		String line = block->data[i];
+		//cerr << "    Comparing vs. line <" << line << ">\n";
+		uint c1, c2;
+		String tok = first_token(line, c1, c2);
+
+		// SENSITIVE?
+		if (tok == "type") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok))
+				get_type_property(param_contents(tok), propname, bool_rv, string_rv);
+		} else if (line == propname) {
+			bool_rv = true;
+			string_rv = "";
+		} else {
+			c1 = line.find('=');
+			if (c1 != -1) {
+				tok = trim(line.substr(0, c1));
+				if (tok == propname) {
+					string_rv = trim(line.substr(c1 + 1));
+					bool_rv = true;
+				}
+			}
+		}
+		/*
+		if (tok == propname)
+		{
+		  cerr << "      match...";
+		  tok = next_token (line, c1, c2);
+		  if (tok == "")
+		    {
+		      bool_rv = true;
+		      string_rv = "";
+		      //cerr << " present but empty\n";
+		    }
+		  else if (tok == "=")
+		    {
+		      bool_rv = true;
+		      string_rv = trim (line.substr (c2));
+		      //cerr << " now <" << string_rv << ">\n";
+		    }
+		  else
+		    {
+		      cerr << "Bad line while checking " << typenamex << " for prop "
+		      << propname << ": " << line << endl;
+		    }
+		}
+		     else if (tok == "type")
+		{
+		  tok = next_token (line, c1, c2);
+		  if (is_param (tok))
+		    get_type_property (param_contents(tok), propname, bool_rv, string_rv);
+		}
+		*/
+	}
+}
+
+
+
+bool GeasFile::obj_of_type(String objname, String typenamex) const {
+	if (!has(obj_types, objname)) {
+		debug_print("Checking nonexistent obj <" + objname + "> for type <" +
+		            typenamex + ">");
+		return false;
+	}
+	String objtype = (*obj_types.find(objname))._value;
+
+	const GeasBlock *block = find_by_name(objtype, objname);
+
+	uint c1, c2;
+	assert(block != NULL);
+	for (uint i = 0; i < block->data.size(); i ++) {
+		String line = block->data[i];
+		String tok = first_token(line, c1, c2);
+		// SENSITIVE?
+		if (tok == "type") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok)) {
+				if (type_of_type(param_contents(tok), typenamex))
+					return true;
+			} else {
+				debug_print("Eg_o_p: xpected parameter for type in " + line);
+			}
+		}
+	}
+	return false;
+}
+
+
+bool GeasFile::type_of_type(String subtype, String supertype) const {
+	if (ci_equal(subtype, supertype))
+		return true;
+	//cerr << "  Checking type <" << subtype << "> for type <" << supertype << ">\n";
+	const GeasBlock *block = find_by_name("type", subtype);
+	if (block == NULL) {
+		debug_print("t_o_t: Nonexistent type " + subtype);
+		return false;
+	}
+	for (uint i = 0; i < block->data.size(); i ++) {
+		String line = block->data[i];
+		//cerr << "    Comparing vs. line <" << line << ">\n";
+		uint c1, c2;
+		String tok = first_token(line, c1, c2);
+		// SENSITIVE?
+		if (tok == "type") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok) && type_of_type(param_contents(tok), supertype))
+				return true;
+		}
+	}
+	return false;
+}
+
+
+
+bool GeasFile::get_obj_action(String objname, String propname, String &string_rv) const {
+	cerr << "g_o_a: Getting action <" << propname << "> of object <" << objname << ">\n";
+	string_rv = "!";
+	bool bool_rv = false;
+
+	//cerr << "obj_types == " << obj_types << endl;
+	/*
+	cerr << "obj_types == \n";
+	for (map<String, String>::const_iterator iter = obj_types.begin();
+	     iter != obj_types.end(); iter ++)
+	  cerr << "  " << (*iter)._key << " -> " << (*iter)._value << "\n";
+	cerr << ".\n";
+	*/
+	if (!has(obj_types, objname)) {
+		debug_print("Checking nonexistent object <" + objname + "> for action <" + propname + ">.");
+		return false;
+	}
+	String objtype = (*obj_types.find(objname))._value;
+
+	//reserved_words *rw;
+
+	const GeasBlock *block = find_by_name(objtype, objname);
+	String not_prop = "not " + propname;
+	uint c1, c2;
+	for (uint i = 0; i < block->data.size(); i ++) {
+		String line = block->data[i];
+		//cerr << "  g_o_a: Handling line <" << line << ">\n";
+		String tok = first_token(line, c1, c2);
+		// SENSITIVE?
+		if (tok == "type") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok))
+				get_type_action(param_contents(tok), propname, bool_rv, string_rv);
+			else {
+				gi->debug_print("Expected parameter for type in " + line);
+			}
+		}
+		/*
+		else if (rw != NULL && tok == propname && rw->has(propname))
+		{
+		  tok = next_token (line, c1, c2);
+		  if (is_param(tok))
+		    {
+		      cerr << "   Parameter, skipping\n";
+		    }
+		  else
+		    {
+		      //cerr << "   Action, skipping\n";
+		      cerr << "   Action, string_rv is now <" << string_rv << ">\n";
+		      string_rv = line.substr (c1);
+		      bool_rv = true;
+		    }
+		}
+		     */
+		// SENSITIVE?
+		else if (tok == "action") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok) && param_contents(tok) == propname) {
+				if (c2 + 1 < line.length())
+					string_rv = line.substr(c2 + 1);
+				else
+					string_rv = "";
+				bool_rv = true;
+				cerr << "   Action line, string_rv now <" << string_rv << ">\n";
+			}
+		}
+	}
+
+	cerr << "g_o_a: Ultimately returning value " << (bool_rv ? "true" : "false")  << ", with String <" << string_rv << ">\n\n";
+
+	return bool_rv;
+}
+
+void GeasFile::get_type_action(String typenamex, String actname, bool &bool_rv, String &string_rv) const {
+	//cerr << "  Checking type <" << typenamex << "> for action <" << actname << ">\n";
+	const GeasBlock *block = find_by_name("type", typenamex);
+	if (block == NULL) {
+		debug_print("Object of nonexistent type " + typenamex);
+		return;
+	}
+	for (uint i = 0; i < block->data.size(); i ++) {
+		String line = block->data[i];
+		//cerr << "    g_t_a: Comparing vs. line <" << line << ">\n";
+		uint c1, c2;
+		String tok = first_token(line, c1, c2);
+		// SENSITIVE?
+		if (tok == "action") {
+			//cerr << "      match...\n";
+			tok = next_token(line, c1, c2);
+			if (is_param(tok) && param_contents(tok) == actname) {
+				bool_rv = true;
+				string_rv = line.substr(c2);
+				//cerr << " present: {" + string_rv + "}\n";
+			}
+		}
+		// SENSITIVE?
+		else if (tok == "type") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok))
+				get_type_action(param_contents(tok), actname, bool_rv, string_rv);
+		}
+	}
+}
+
+void GeasFile::register_block(String blockname, String blocktype) {
+	cerr << "registering block " << blockname << " / " << blocktype << endl;
+	if (has(obj_types, blockname)) {
+		String errdesc = "Trying to register block of named <" + blockname +
+		                 "> of type <" + blocktype + "> when there is already one, of type <" +
+		                 obj_types[blockname] + ">";
+		debug_print(errdesc);
+		throw errdesc;
+	}
+	obj_types[blockname] = blocktype;
+}
+
+String GeasFile::static_svar_lookup(String varname) const {
+	cerr << "static_svar_lookup(" << varname << ")" << endl;
+	//varname = lcase (varname);
+	for (uint i = 0; i < size("variable"); i ++)
+		//if (blocks[i].lname == varname)
+		if (ci_equal(blocks[i].name, varname)) {
+			String rv;
+			String tok;
+			uint c1, c2;
+			bool found_typeline = false;
+			for (uint j = 0; j < blocks[i].data.size(); j ++) {
+				String line = blocks[i].data[j];
+				tok = first_token(line, c1, c2);
+				// SENSITIVE?
+				if (tok == "type") {
+					tok = next_token(line, c1, c2);
+					// SENSITIVE?
+					if (tok == "numeric")
+						throw String("Trying to evaluate int var '" + varname +
+						             "' as String");
+					// SENSITIVE?
+					if (tok != "String")
+						throw String("Bad variable type " + tok);
+					found_typeline = true;
+				}
+				// SENSITIVE?
+				else if (tok == "value") {
+					tok = next_token(line, c1, c2);
+					if (!is_param(tok))
+						throw String("Expected param after value in " + line);
+					rv = param_contents(tok);
+				}
+			}
+			if (!found_typeline)
+				throw String(varname + " is a numeric variable");
+			cerr << "static_svar_lookup(" << varname << ") -> \"" << rv << "\"" << endl;
+			return rv;
+		}
+	debug_print("Variable <" + varname + "> not found.");
+	return "";
+}
+
+String GeasFile::static_ivar_lookup(String varname) const {
+	//varname = lcase (varname);
+	for (uint i = 0; i < size("variable"); i ++)
+		//if (blocks[i].lname == varname)
+		if (ci_equal(blocks[i].name, varname)) {
+			String rv;
+			String tok;
+			uint c1, c2;
+			for (uint j = 0; j < blocks[i].data.size(); j ++) {
+				String line = blocks[i].data[j];
+				tok = first_token(line, c1, c2);
+				// SENSITIVE?
+				if (tok == "type") {
+					tok = next_token(line, c1, c2);
+					// SENSITIVE?
+					if (tok == "String")
+						throw String("Trying to evaluate String var '" + varname +
+						             "' as numeric");
+					// SENSITIVE?
+					if (tok != "numeric")
+						throw String("Bad variable type " + tok);
+				}
+				// SENSITIVE?
+				else if (tok == "value") {
+					tok = next_token(line, c1, c2);
+					if (!is_param(tok))
+						throw String("Expected param after value in " + line);
+					rv = param_contents(tok);
+				}
+			}
+			return rv;
+		}
+	debug_print("Variable <" + varname + "> not found");
+	return "-32768";
+}
+
+String GeasFile::static_eval(String input) const {
+	//cerr << "static_eval (" << input << ")" << endl;
+	String rv = "";
+	for (uint i = 0; i < input.length(); i ++) {
+		if (input[i] == '#') {
+			uint j;
+			for (j = i + 1; j < input.length() && input[j] != '#'; j ++)
+				;
+			if (j == input.length())
+				throw String("Error processing '" + input + "', odd hashes");
+			uint k;
+			for (k = i + 1; k < j && input[k] != ':'; k ++)
+				;
+			if (k == ':') {
+				String objname;
+				if (input[i + 1] == '(' && input[k - 1] == ')')
+					objname = static_svar_lookup(input.substr(i + 2, k - i - 4));
+				else
+					objname = input.substr(i + 1, k - i - 2);
+				cerr << "  objname == '" << objname << endl;
+				//rv += get_obj_property (objname, input.substr (k+1, j-k-2));
+				String tmp;
+				bool had_var;
+
+				String objprop = input.substr(k + 1, j - k - 2);
+				cerr << "  objprop == " << objprop << endl;
+				had_var = get_obj_property(objname, objprop, tmp);
+				rv += tmp;
+				if (!had_var)
+					debug_print("Requesting nonexistent property <" + objprop +
+					            "> of object <" + objname + ">");
+			} else {
+				cerr << "i == " << i << ", j == " << j << ", length is " << input.length() << endl;
+				cerr << "Looking up static var " << input.substr(i + 1, j - i - 1) << endl;
+				rv += static_svar_lookup(input.substr(i + 1, j - i - 1));
+			}
+			i = j;
+		} else if (input[i] == '%') {
+			uint j;
+			for (j = i; j < input.length() && input[j] != '%'; j ++)
+				;
+			if (j == input.length())
+				throw String("Error processing '" + input + "', unmatched %");
+			rv += static_ivar_lookup(input.substr(i + 1, j - i - 2));
+			i = j;
+		} else
+			rv += input[i];
+	}
+	if (rv != input)
+		cerr << "*** CHANGED ***\n";
+	//cerr << "static_eval (" << input << ") --> \"" << rv << "\"" << endl;
+	return rv;
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/geas_file.h b/engines/glk/quest/geas_file.h
new file mode 100644
index 0000000000..e9558cadd8
--- /dev/null
+++ b/engines/glk/quest/geas_file.h
@@ -0,0 +1,123 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_GEAS_FILE
+#define GLK_QUEST_GEAS_FILE
+
+#include "glk/quest/string.h"
+#include "common/algorithm.h"
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+#include "common/stream.h"
+
+namespace Glk {
+namespace Quest {
+
+class GeasInterface;
+
+class reserved_words;
+
+/**
+ * Ordered array of items
+ */
+template<class T>
+class Set : public Common::Array<T> {
+public:
+	/**
+	 * Insert a new item
+	 */
+	void insert(T val) {
+		this->push_back(val);
+		Common::sort(this->begin(), this->end());
+	}
+};
+
+struct GeasBlock {
+	////// lname == lowercase name
+	////// nname == normal name
+	////// parent == initial parent object (lowercased)
+	// name == name
+	// parent == initial parent object
+	String blocktype, name, parent;
+	Common::Array<String> data;
+	//GeasBlock (const Common::Array<String> &, String, uint, bool);
+	GeasBlock() {}
+};
+
+struct GeasFile {
+	GeasInterface *gi;
+	void debug_print(String s) const;
+
+	//vector<GeasBlock> rooms, objects, textblocks, functions, procedures, types;
+	//GeasBlock synonyms, game;
+	Common::Array <GeasBlock> blocks;
+
+	//Common::Array<GeasBlock> rooms, objects, textblocks, functions, procedures,
+	//  types, synonyms, game, variables, timers, choices;
+	StringMap obj_types;
+	StringArrayIntMap type_indecies;
+
+	void register_block(String blockname, String blocktype);
+
+	const GeasBlock &block(String type, uint index) const;
+	uint size(String type) const;
+
+	void read_into(const Common::Array<String> &, String, uint, bool, const reserved_words &, const reserved_words &);
+
+
+
+	GeasFile() : gi(nullptr) {}
+	explicit GeasFile(const Common::Array<String> &in_data,
+	                  GeasInterface *gi);
+
+	bool obj_has_property(String objname, String propname) const;
+	bool get_obj_property(String objname, String propname,
+	                      String &rv) const;
+
+	void get_type_property(String typenamex, String propname,
+	                       bool &, String &) const;
+	bool obj_of_type(String object, String type) const;
+	bool type_of_type(String subtype, String supertype) const;
+
+	Set<String> get_obj_keys(String obj) const;
+	void get_obj_keys(String, Set<String> &) const;
+	void get_type_keys(String, Set<String> &) const;
+
+	bool obj_has_action(String objname, String propname) const;
+	bool get_obj_action(String objname, String propname,
+	                    String &rv) const;
+	void get_type_action(String typenamex, String propname,
+	                     bool &, String &) const;
+	String static_eval(String) const;
+	String static_ivar_lookup(String varname) const;
+	String static_svar_lookup(String varname) const;
+
+	const GeasBlock *find_by_name(String type, String name) const;
+};
+
+Common::WriteStream &operator<<(Common::WriteStream &, const GeasBlock &);
+Common::WriteStream &operator<<(Common::WriteStream &, const GeasFile &);
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/geas_glk.cpp b/engines/glk/quest/geas_glk.cpp
new file mode 100644
index 0000000000..8f48799d9a
--- /dev/null
+++ b/engines/glk/quest/geas_glk.cpp
@@ -0,0 +1,240 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/geas_glk.h"
+#include "glk/quest/geas_runner.h"
+#include "glk/quest/quest.h"
+#include "glk/quest/streams.h"
+#include "glk/windows.h"
+
+namespace Glk {
+namespace Quest {
+
+void glk_put_cstring(const char *);
+
+
+winid_t mainglkwin;
+winid_t inputwin;
+winid_t bannerwin;
+strid_t inputwinstream;
+
+const bool use_inputwindow = false;
+
+int ignore_lines;			// count of lines to ignore in game output
+
+void draw_banner() {
+	uint32 width;
+	uint32 index;
+	if (bannerwin) {
+		g_vm->glk_window_clear(bannerwin);
+		g_vm->glk_window_move_cursor(bannerwin, 0, 0);
+		strid_t stream = g_vm->glk_window_get_stream(bannerwin);
+
+		g_vm->glk_set_style_stream(stream, style_User1);
+		g_vm->glk_window_get_size(bannerwin, &width, NULL);
+		for (index = 0; index < width; index++)
+			g_vm->glk_put_char_stream(stream, ' ');
+		g_vm->glk_window_move_cursor(bannerwin, 1, 0);
+
+		if (g_vm->banner.empty())
+			g_vm->glk_put_string_stream(stream, (char *)"Geas 0.4");
+		else
+			g_vm->glk_put_string_stream(stream, (char *)g_vm->banner.c_str());
+	}
+}
+
+void glk_put_cstring(const char *s) {
+	/* The cast to remove const is necessary because g_vm->glk_put_string
+	 * receives a "char *" despite the fact that it could equally well use
+	 * "const char *". */
+	g_vm->glk_put_string((char *)s);
+}
+
+GeasResult GeasGlkInterface::print_normal(const String &s) {
+	if (!ignore_lines)
+		glk_put_cstring(s.c_str());
+	return r_success;
+}
+
+GeasResult GeasGlkInterface::print_newline() {
+	if (!ignore_lines)
+		glk_put_cstring("\n");
+	else
+		ignore_lines--;
+	return r_success;
+}
+
+GeasResult GeasGlkInterface::set_style(const GeasFontStyle &style) {
+	// Glk styles are defined before the window opens, so at this point we can only
+	// pick the most suitable style, not define a new one.
+	uint match;
+	if (style.is_italic && style.is_bold)
+		match = style_Alert;
+	else if (style.is_italic)
+		match = style_Emphasized;
+	else if (style.is_bold)
+		match = style_Subheader;
+	else if (style.is_underlined)
+		match = style_User2;
+	else
+		match = style_Normal;
+
+	g_vm->glk_set_style_stream(g_vm->glk_window_get_stream(mainglkwin), match);
+	return r_success;
+}
+
+void GeasGlkInterface::set_foreground(String s) {
+	if (s != "") {
+	}
+}
+
+void GeasGlkInterface::set_background(String s) {
+	if (s != "") {
+	}
+}
+
+/* Code lifted from GeasWindow.  Should be common.  Maybe in
+ * GeasInterface?
+ */
+String GeasGlkInterface::get_file(const String &fname) const {
+	Common::File ifs;
+	if (ifs.open(fname)) {
+		glk_put_cstring("Couldn't open ");
+		glk_put_cstring(fname.c_str());
+		g_vm->glk_put_char(0x0a);
+		return "";
+	}
+
+	// Read entirety of the file
+	char *buf = new char[ifs.size()];
+	ifs.read(buf, ifs.size());
+	
+	String result(buf, buf + ifs.size());
+	delete[] buf;
+
+	return result;
+}
+
+String GeasGlkInterface::get_string() {
+	char buf[200];
+	g_vm->glk_request_line_event(inputwin, buf, (sizeof buf) - 1, 0);
+	while (1) {
+		event_t ev;
+
+		g_vm->glk_select(&ev);
+
+		if (ev.type == evtype_LineInput && ev.window == inputwin) {
+			return String(buf, ev.val1);
+		}
+		/* All other events, including timer, are deliberately
+		 * ignored.
+		 */
+	}
+}
+
+uint GeasGlkInterface::make_choice(String label, Common::Array<String> v) {
+	size_t n;
+
+	g_vm->glk_window_clear(inputwin);
+
+	glk_put_cstring(label.c_str());
+	g_vm->glk_put_char(0x0a);
+	n = v.size();
+	for (size_t i = 0; i < n; ++i) {
+		StringStream t;
+		String s;
+		t << i + 1;
+		t >> s;
+		glk_put_cstring(s.c_str());
+		glk_put_cstring(": ");
+		glk_put_cstring(v[i].c_str());
+		glk_put_cstring("\n");
+	}
+
+	StringStream t;
+	String s;
+	String s1;
+	t << n;
+	t >> s;
+	s1 = "Choose [1-" + s + "]> ";
+	g_vm->glk_put_string_stream(inputwinstream, (char *)(s1.c_str()));
+
+	int choice = atoi(get_string().c_str());
+	if (choice < 1) {
+		choice = 1;
+	}
+	if ((size_t)choice > n) {
+		choice = n;
+	}
+
+	StringStream u;
+	u << choice;
+	u >> s;
+	s1 = "Chosen: " +  s + "\n";
+	glk_put_cstring(s1.c_str());
+
+	return choice - 1;
+}
+
+String GeasGlkInterface::absolute_name(String rel_name, String parent) const {
+	cerr << "absolute_name ('" << rel_name << "', '" << parent << "')\n";
+	if (parent[0] != '/')
+		return rel_name;
+
+	if (rel_name[0] == '/') {
+		cerr << "  --> " << rel_name << "\n";
+		return rel_name;
+	}
+	Common::Array<String> path;
+	uint dir_start = 1, dir_end;
+	while (dir_start < parent.length()) {
+		dir_end = dir_start;
+		while (dir_end < parent.length() && parent[dir_end] != '/')
+			dir_end ++;
+		path.push_back(parent.substr(dir_start, dir_end - dir_start));
+		dir_start = dir_end + 1;
+	}
+	path.pop_back();
+	dir_start = 0;
+	String tmp;
+	while (dir_start < rel_name.length()) {
+		dir_end = dir_start;
+		while (dir_end < rel_name.length() && rel_name[dir_end] != '/')
+			dir_end ++;
+		tmp = rel_name.substr(dir_start, dir_end - dir_start);
+		dir_start = dir_end + 1;
+		if (tmp == ".")
+			continue;
+		else if (tmp == "..")
+			path.pop_back();
+		else
+			path.push_back(tmp);
+	}
+	String rv;
+	for (uint i = 0; i < path.size(); i ++)
+		rv = rv + "/" + path[i];
+	cerr << " ---> " << rv << "\n";
+	return rv;
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/geas_glk.h b/engines/glk/quest/geas_glk.h
new file mode 100644
index 0000000000..2647bf13b5
--- /dev/null
+++ b/engines/glk/quest/geas_glk.h
@@ -0,0 +1,92 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_GEAS_GLK
+#define GLK_QUEST_GEAS_GLK
+
+#include "glk/quest/geas_runner.h"
+#include "glk/windows.h"
+
+namespace Glk {
+namespace Quest {
+
+
+/* User interface bridge from Geas Core to Glk.
+
+  Glk Window arrangment.
+
+    +---------+
+    |    B    |
+    +---------+
+    |    M    |
+    |         |
+    +---------+
+    |    I    |
+    +---------+
+
+  B is a one line "banner window", showing the game name and author.  Kept
+  in the global variable, it's optional, null if unavailable.
+  optional.
+  M is the main window where the text of the game appears.  Kept in the
+  global variable mainglkwin.
+  I is a one line "input window" where the user inputs their commands.
+  Kept in the global variable inputwin, it's optional, and if not separate
+  is set to mainglkwin.
+
+  Maybe in future revisions there will be a status window (including a
+  compass rose).
+*/
+
+class GeasGlkInterface : public GeasInterface {
+protected:
+	virtual String get_file(const String &fname) const;
+	virtual GeasResult print_normal(const String &s);
+	virtual GeasResult print_newline();
+
+	virtual void set_foreground(String);
+	virtual void set_background(String);
+	virtual GeasResult set_style(const GeasFontStyle &);
+
+	virtual String get_string();
+	virtual uint make_choice(String, Common::Array<String>);
+
+	virtual String absolute_name(String, String) const;
+public:
+	GeasGlkInterface() {
+		;
+	}
+};
+
+extern winid_t mainglkwin;
+extern winid_t inputwin;
+extern winid_t bannerwin;
+extern strid_t inputwinstream;
+extern int ignore_lines;
+extern const bool use_inputwindow;
+
+extern void glk_put_cstring(const char *);
+extern void draw_banner();
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/geas_impl.h b/engines/glk/quest/geas_impl.h
new file mode 100644
index 0000000000..1bdbbfdd9a
--- /dev/null
+++ b/engines/glk/quest/geas_impl.h
@@ -0,0 +1,214 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_GEAS_IMPL
+#define GLK_QUEST_GEAS_IMPL
+
+#include "glk/quest/geas_runner.h"
+#include "glk/quest/geas_state.h"
+#include "glk/quest/limit_stack.h"
+
+namespace Glk {
+namespace Quest {
+
+struct match_binding {
+	String var_name;
+	String var_text;
+	uint start, end;
+	//operator String();
+	String tostring();
+	match_binding(String vn, uint i) : var_name(vn), start(i) {}
+	void set(String vt, uint i) {
+		var_text = vt;
+		end = i;
+	}
+};
+
+Common::WriteStream &operator<< (Common::WriteStream &, const match_binding &);
+
+
+struct match_rv {
+	bool success;
+	Common::Array<match_binding> bindings;
+	//match_rv (bool b, const Common::Array<String> &v) : success(b), bindings(v) {}
+	match_rv() : success(false) {}
+	match_rv(bool b, const match_rv &rv) : success(b), bindings(rv.bindings) {}
+	operator bool () {
+		return success;
+	}
+};
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const match_rv &rv);
+/*
+  inline ostream &operator<< (ostream &o, const match_rv &rv)
+{
+  //o << "match_rv {" << (rv.success ? "TRUE" : "FALSE") << ": " << rv.bindings << "}";
+  o << "match_rv {" << (rv.success ? "TRUE" : "FALSE") << ": [";
+  //o << rv.bindings.size();
+  //o << rv.bindings;
+  for (uint i = 0; i < rv.bindings.size(); i ++)
+    o << rv.bindings[i] << ", ";
+  o << "]}";
+  return o;
+}
+*/
+
+class geas_implementation : public GeasRunner {
+	//GeasInterface *gi;
+	GeasFile gf;
+	//bool running;
+	bool dont_process, outputting;
+	LimitStack <GeasState> undo_buffer;
+	Common::Array <String> function_args;
+	String this_object;
+	v2string current_places;
+	bool is_running_;
+	Logger logger;
+
+public:
+	geas_implementation(GeasInterface *in_gi)
+		: GeasRunner(in_gi), undo_buffer(20), is_running_(true) {}
+	void set_game(const String &fname);
+
+	bool is_running() const;
+	String get_banner();
+	void run_command(String);
+	bool try_match(String s, bool, bool);
+	match_rv match_command(String input, String action) const;
+	match_rv match_command(String input, uint ichar,
+	                       String action, uint achar, match_rv rv) const;
+	bool dereference_vars(Common::Array<match_binding> &bindings, bool is_internal) const;
+	bool dereference_vars(Common::Array<match_binding> &, const Common::Array<String> &, bool is_internal) const;
+	bool match_object(String text, String name, bool is_internal = false) const;
+	void set_vars(const Common::Array<match_binding> &v);
+	bool run_commands(String, const GeasBlock *, bool is_internal = false);
+
+	void display_error(String errorname, String object = "");
+
+	String substitute_synonyms(String) const;
+
+	void set_svar(String, String);
+	void set_svar(String, uint, String);
+	void set_ivar(String, int);
+	void set_ivar(String, uint, int);
+
+	String get_svar(String) const;
+	String get_svar(String, uint) const;
+	int get_ivar(String) const;
+	int get_ivar(String, uint) const;
+
+	bool find_ivar(String, uint &) const;
+	bool find_svar(String, uint &) const;
+
+	void regen_var_look();
+	void regen_var_dirs();
+	void regen_var_objects();
+	void regen_var_room();
+
+	void look();
+
+	String displayed_name(String object) const;
+	//String get_obj_name (const Common::Array<String> &args) const;
+	String get_obj_name(String name, const Common::Array<String> &where, bool is_internal) const;
+
+	bool has_obj_property(String objname, String propname) const;
+	bool get_obj_property(String objname, String propname,
+	                      String &rv) const;
+	bool has_obj_action(String obj, String prop) const;
+	bool get_obj_action(String objname, String actname,
+	                    String &rv) const;
+	String exit_dest(String room, String dir, bool *is_act = NULL) const;
+	Common::Array<Common::Array<String> > get_places(String room);
+
+	void set_obj_property(String obj, String prop);
+	void set_obj_action(String obj, String act);
+	void move(String obj, String dest);
+	void goto_room(String room);
+	String get_obj_parent(String obj);
+
+	void print_eval(String);
+	void print_eval_p(String);
+	String eval_string(String s);
+	String eval_param(String s) {
+		assert(is_param(s));
+		return eval_string(param_contents(s));
+	}
+
+
+	void run_script_as(String, String);
+	void run_script(String);
+	void run_script(String, String &);
+	void run_procedure(String);
+	void run_procedure(String, Common::Array<String> args);
+	String run_function(String);
+	String run_function(String, Common::Array<String> args);
+	String bad_arg_count(String);
+
+	bool eval_conds(String);
+	bool eval_cond(String);
+	GeasState state;
+
+	virtual void tick_timers();
+	virtual v2string get_inventory();
+	virtual v2string get_room_contents();
+	v2string get_room_contents(String);
+	virtual vstring get_status_vars();
+	virtual Common::Array<bool> get_valid_exits();
+
+
+	inline void print_formatted(String s) const {
+		if (outputting) gi->print_formatted(s);
+	}
+	inline void print_normal(String s) const {
+		if (outputting) gi->print_normal(s);
+	}
+	inline void print_newline() const {
+		if (outputting) gi->print_newline();
+	}
+
+	/*
+	inline void print_formatted (String s) const {
+	  if (outputting)
+	    gi->print_formatted(s);
+	  else
+	    gi->print_formatted ("{{" + s + "}}");
+	}
+	inline void print_normal (String s) const
+	{
+	  if (outputting)
+	    gi->print_normal (s);
+	  else
+	    gi->print_normal("{{" + s + "}}");
+	}
+	inline void print_newline() const {
+	  if (outputting)
+	    gi->print_newline();
+	  else
+	    gi->print_normal ("{{|n}}");
+	}
+	*/
+};
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/geas_runner.cpp b/engines/glk/quest/geas_runner.cpp
new file mode 100644
index 0000000000..a029c07824
--- /dev/null
+++ b/engines/glk/quest/geas_runner.cpp
@@ -0,0 +1,3675 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/geas_runner.h"
+#include "glk/quest/read_file.h"
+#include "glk/quest/geas_state.h"
+#include "glk/quest/geas_util.h"
+#include "glk/quest/reserved_words.h"
+#include "glk/quest/geas_impl.h"
+#include "glk/quest/quest.h"
+#include "glk/quest/streams.h"
+#include "glk/quest/String.h"
+
+namespace Glk {
+namespace Quest {
+
+class GeasInterface;
+
+static const char *dir_names[] = {"north", "south", "east", "west", "northeast", "northwest", "southeast", "southwest", "up", "down", "out"};
+static const char *short_dir_names[] = {"n", "s", "e", "w", "ne", "nw", "se", "sw", "u", "d", "out"};
+
+const ObjectRecord *get_obj_record(const Common::Array<ObjectRecord> &v, const String &name) {
+	for (uint i = 0; i < v.size(); i ++)
+		if (ci_equal(v[i].name, name))
+			return &v[i];
+	return nullptr;
+}
+
+
+
+GeasRunner *GeasRunner::get_runner(GeasInterface *gi) {
+	return new geas_implementation(gi);
+}
+
+bool geas_implementation::find_ivar(String name, uint &rv) const {
+	for (uint n = 0; n < state.ivars.size(); n ++)
+		if (ci_equal(state.ivars[n].name, name)) {
+			rv = n;
+			return true;
+		}
+	return false;
+}
+
+bool geas_implementation::find_svar(String name, uint &rv) const {
+	//name = lcase (name);
+	for (uint n = 0; n < state.svars.size(); n ++)
+		if (ci_equal(state.svars[n].name, name)) {
+			rv = n;
+			return true;
+		}
+	return false;
+}
+
+void geas_implementation::set_svar(String varname, String varval) {
+	cerr << "set_svar (" << varname << ", " << varval << ")\n";
+	int i1 = varname.find('[');
+	if (i1 == -1)
+		return set_svar(varname, 0, varval);
+	if (varname[varname.length() - 1] != ']') {
+		gi->debug_print("set_svar: Badly formatted name " + varname);
+		return;
+	}
+	String arrayname = varname.substr(0, i1);
+	String indextext = varname.substr(i1 + 1, varname.length() - i1 - 2);
+	cerr << "set_svar(" << varname << ") --> set_svar (" << arrayname << ", " << indextext << ")\n";
+	for (uint c3 = 0; c3 < indextext.size(); c3 ++)
+		if (indextext[c3] < '0' || indextext[c3] > '9') {
+			set_svar(arrayname, get_ivar(indextext), varval);
+			return;
+		}
+	set_svar(arrayname, parse_int(indextext), varval);
+	return;
+}
+
+void geas_implementation::set_svar(String varname, uint index, String varval) {
+	uint n, m;
+	if (!find_svar(varname, n)) {
+		if (find_ivar(varname, m)) {
+			gi->debug_print("Defining " + varname + " as String variable when there is already a numeric variable of that name.");
+			return;
+		}
+		SVarRecord svr;
+		svr.name = varname;
+		n = state.svars.size();
+		state.svars.push_back(svr);
+	}
+	state.svars[n].set(index, varval);
+	if (index == 0) {
+		for (uint varn = 0; varn < gf.size("variable"); varn ++) {
+			const GeasBlock &go(gf.block("variable", varn));
+			if (ci_equal(go.name, varname)) {
+				String script = "";
+				uint c1, c2;
+				for (uint j = 0; j < go.data.size(); j ++)
+					// SENSITIVE ?
+					if (first_token(go.data[j], c1, c2) == "onchange")
+						script = trim(go.data[j].substr(c2 + 1));
+				if (script != "")
+					run_script(script);
+			}
+		}
+	}
+}
+
+String geas_implementation::get_svar(String varname) const {
+	int i1 = varname.find('[');
+	if (i1 == -1)
+		return get_svar(varname, 0);
+	if (varname[varname.length() - 1] != ']') {
+		gi->debug_print("get_svar: badly formatted name " + varname);
+		return "";
+	}
+	String arrayname = varname.substr(0, i1);
+	String indextext = varname.substr(i1 + 1, varname.length() - i1 - 2);
+	cerr << "get_svar(" << varname << ") --> get_svar (" << arrayname << ", " << indextext << ")\n";
+	for (uint c3 = 0; c3 < indextext.size(); c3 ++)
+		if (indextext[c3] < '0' || indextext[c3] > '9')
+			return get_svar(arrayname, get_ivar(indextext));
+	return get_svar(arrayname, parse_int(indextext));
+}
+String geas_implementation::get_svar(String varname, uint index) const {
+	for (uint i = 0; i < state.svars.size(); i ++) {
+		if (ci_equal(state.svars[i].name, varname))
+			return state.svars[i].get(index);
+	}
+
+	gi->debug_print("get_svar (" + varname + ", " + string_int(index) + "): No such variable defined.");
+	return "";
+}
+
+int geas_implementation::get_ivar(String varname) const {
+	int i1 = varname.find('[');
+	if (i1 == -1)
+		return get_ivar(varname, 0);
+	if (varname[varname.length() - 1] != ']') {
+		gi->debug_print("get_ivar: Badly formatted name " + varname);
+		return -32767;
+	}
+	String arrayname = varname.substr(0, i1);
+	String indextext = varname.substr(i1 + 1, varname.length() - i1 - 2);
+	cerr << "get_ivar(" << varname << ") --> get_ivar (" << arrayname << ", " << indextext << ")\n";
+	for (uint c3 = 0; c3 < indextext.size(); c3 ++)
+		if (indextext[c3] < '0' || indextext[c3] > '9')
+			return get_ivar(arrayname, get_ivar(indextext));
+	return get_ivar(arrayname, parse_int(indextext));
+}
+int geas_implementation::get_ivar(String varname, uint index) const {
+	for (uint i = 0; i < state.ivars.size(); i ++)
+		if (ci_equal(state.ivars[i].name, varname))
+			return state.ivars[i].get(index);
+	gi->debug_print("get_ivar: Tried to read undefined int '" + varname +
+	                "' [" + string_int(index) + "]");
+	return -32767;
+}
+void geas_implementation::set_ivar(String varname, int varval) {
+	int i1 = varname.find('[');
+	if (i1 == -1)
+		return set_ivar(varname, 0, varval);
+	if (varname[varname.length() - 1] != ']') {
+		gi->debug_print("set_ivar: Badly formatted name " + varname);
+		return;
+	}
+	String arrayname = varname.substr(0, i1);
+	String indextext = varname.substr(i1 + 1, varname.length() - i1 - 2);
+	cerr << "set_svar(" << varname << ") --> set_svar (" << arrayname << ", " << indextext << ")\n";
+	for (uint c3 = 0; c3 < indextext.size(); c3 ++)
+		if (indextext[c3] < '0' || indextext[c3] > '9') {
+			set_ivar(arrayname, get_ivar(indextext), varval);
+			return;
+		}
+	set_ivar(arrayname, parse_int(indextext), varval);
+}
+
+void geas_implementation::set_ivar(String varname, uint index, int varval) {
+	uint n, m;
+	if (!find_ivar(varname, n)) {
+		if (find_svar(varname, m)) {
+			gi->debug_print("Defining " + varname + " as numeric variable when there is already a String variable of that name.");
+			return;
+		}
+		IVarRecord ivr;
+		ivr.name = varname;
+		n = state.ivars.size();
+		state.ivars.push_back(ivr);
+	}
+	state.ivars[n].set(index, varval);
+	if (index == 0) {
+		for (uint varn = 0; varn < gf.size("variable"); varn ++) {
+			const GeasBlock &go(gf.block("variable", varn));
+			//if (go.lname == varname)
+			if (ci_equal(go.name, varname)) {
+				String script = "";
+				uint c1, c2;
+				for (uint j = 0; j < go.data.size(); j ++)
+					// SENSITIVE?
+					if (first_token(go.data[j], c1, c2) == "onchange")
+						script = trim(go.data[j].substr(c2 + 1));
+				if (script != "")
+					run_script(script);
+			}
+		}
+	}
+}
+
+
+
+Common::WriteStream &operator<<(Common::WriteStream &o, const match_binding &mb) {
+	o << "MB['" << mb.var_name << "' == '" << mb.var_text << "' @ "
+	  << mb.start << " to " << mb.end << "]";
+	return o;
+}
+
+String match_binding::tostring() {
+	ostringstream oss;
+	oss << *this;
+	return oss.str();
+}
+
+Common::WriteStream &operator<<(Common::WriteStream &o, const Set<String> &s) {
+	o << "{ ";
+	for (Set<String>::const_iterator i = s.begin(); i != s.end(); i ++) {
+		if (i != s.begin())
+			o << ", ";
+		o << (*i);
+	}
+	o << " }";
+	return o;
+}
+
+bool geas_implementation::has_obj_action(String obj, String prop) const {
+	String tmp;
+	return get_obj_action(obj, prop, tmp);
+}
+
+
+bool geas_implementation::get_obj_action(String objname, String actname,
+        String &rv) const {
+	//String backup_object = this_object;
+	//this_object = objname;
+
+	cerr << "get_obj_action (" << objname << ", " << actname << ")\n";
+	String tok;
+	uint c1, c2;
+	for (uint i = state.props.size() - 1; i + 1 > 0; i --)
+		if (state.props[i].name == objname) {
+			String line = state.props[i].data;
+			// SENSITIVE?
+			if (first_token(line, c1, c2) != "action")
+				continue;
+			tok = next_token(line, c1, c2);
+			if (!is_param(tok) || ci_equal(param_contents(tok), actname))
+				continue;
+			rv = trim(line.substr(c2));
+			cerr << "  g_o_a: returning true, \"" << rv << "\".";
+			return true;
+		}
+	return gf.get_obj_action(objname, actname, rv);
+	//bool bool_rv = gf.get_obj_action (objname, actname, rv);
+	//this_object = backup_object;
+	//return bool_rv;
+}
+
+bool geas_implementation::has_obj_property(String obj, String prop) const {
+	String tmp;
+	return get_obj_property(obj, prop, tmp);
+}
+
+bool geas_implementation::get_obj_property(String obj, String prop,
+        String &string_rv) const {
+	String is_prop = "properties " + prop;
+	String not_prop = "properties not " + prop;
+	for (uint i = state.props.size() - 1; i + 1 > 0; i --)
+		if (ci_equal(state.props[i].name, obj)) {
+			String dat = state.props[i].data;
+			//cerr << "In looking for " << obj << ":" << prop << ", got line "
+			//     << dat << endl;
+			if (ci_equal(dat, not_prop)) {
+				//cerr << "   not_prop, returning false\n";
+				string_rv = "!";
+				return false;
+			}
+			if (ci_equal(dat, is_prop)) {
+				//cerr << "   is_prop, returning true\n";
+				string_rv = "";
+				return true;
+			}
+			int index = dat.find('=');
+			if (index != -1 && ci_equal(dat.substr(0, index), is_prop)) {
+				string_rv = dat.substr(index + 1);
+				return true;
+			}
+		}
+	return gf.get_obj_property(obj, prop, string_rv);
+}
+
+void geas_implementation::set_obj_property(String obj, String prop) {
+	state.props.push_back(PropertyRecord(obj, "properties " + prop));
+	if (ci_equal(prop, "hidden") || ci_equal(prop, "not hidden") ||
+	        ci_equal(prop, "invisible") || ci_equal(prop, "not invisible")) {
+		gi->update_sidebars();
+		regen_var_objects();
+	}
+}
+
+void geas_implementation::set_obj_action(String obj, String act) {
+	state.props.push_back(PropertyRecord(obj, "action " + act));
+}
+
+void geas_implementation::move(String obj, String dest) {
+	for (uint i = 0; i < state.objs.size(); i ++)
+		if (ci_equal(state.objs[i].name, obj)) {
+			state.objs[i].parent = dest;
+			gi->update_sidebars();
+			regen_var_objects();
+			return;
+		}
+	gi->debug_print("Tried to move nonexistent object '" + obj +
+	                "' to '" + dest + "'.");
+}
+
+String geas_implementation::get_obj_parent(String obj) {
+	//obj = lcase (obj);
+	for (uint i = 0; i < state.objs.size(); i ++)
+		if (ci_equal(state.objs[i].name, obj))
+			return state.objs[i].parent;
+	gi->debug_print("Tried to find parent of nonexistent object " + obj);
+	return "";
+}
+
+void geas_implementation::goto_room(String room) {
+	state.location = room;
+	regen_var_room();
+	regen_var_dirs();
+	regen_var_look();
+	regen_var_objects();
+	String scr;
+	if (get_obj_action(room, "script", scr))
+		run_script_as(room, scr);
+	//run_script (scr);
+	look();
+}
+
+void geas_implementation::display_error(String errorname, String obj) {
+	cerr << "display_error (" << errorname << ", " << obj << ")\n";
+	if (obj != "") {
+		String tmp;
+		if (!get_obj_property(obj, "gender", tmp))
+			tmp = "it";
+		set_svar("quest.error.gender", tmp);
+
+		if (!get_obj_property(obj, "article", tmp))
+			tmp = "it";
+		set_svar("quest.error.article", tmp);
+
+		cerr << "In erroring " << errorname << " / " << obj << ", qeg == "
+		     << get_svar("quest.error.gender") << ", qea == "
+		     << get_svar("quest.error.article") << endl;
+		// TODO quest.error.charactername
+	}
+
+	const GeasBlock *game = gf.find_by_name("game", "game");
+	assert(game != NULL);
+	String tok;
+	uint c1, c2;
+	for (uint i = 0; i < game->data.size(); i ++) {
+		String line = game->data[i];
+		tok = first_token(line, c1, c2);
+		// SENSITIVE?
+		if (tok == "error") {
+			tok = next_token(line, c1, c2);
+			if (is_param(tok)) {
+				String text = param_contents(tok);
+				int index = text.find(';');
+				String errortype = trim(text.substr(0, index));
+				// SENSITIVE?
+				if (errortype == errorname) {
+					print_eval_p(trim(text.substr(index + 1)));
+					return;
+				}
+			} else
+				gi->debug_print("Bad error line: " + line);
+		}
+	}
+	//print_formatted ("Default error " + errorname);
+
+	// ARE THESE SENSITIVE?
+	if (errorname == "badcommand")
+		print_eval("I don't understand your command. Type HELP for a list of valid commands.");
+	else if (errorname == "badgo")
+		print_eval("I don't understand your use of 'GO' - you must either GO in some direction, or GO TO a place.");
+	else if (errorname == "badgive")
+		print_eval("You didn't say who you wanted to give that to.");
+	else if (errorname == "badcharacter")
+		print_eval("I can't see anybody of that name here.");
+	else if (errorname == "noitem")
+		print_eval("You don't have that.");
+	else if (errorname == "itemunwanted")
+		print_eval_p("#quest.error.gender# doesn't want #quest.error.article#.");
+	else if (errorname == "badlook")
+		print_eval("You didn't say what you wanted to look at.");
+	else if (errorname == "badthing")
+		print_eval("I can't see that here.");
+	else if (errorname == "defaultlook")
+		print_eval("Nothing out of the ordinary.");
+	else if (errorname == "defaultspeak")
+		print_eval_p("#quest.error.gender# says nothing.");
+	else if (errorname == "baditem")
+		print_eval("I can't see that anywhere.");
+	else if (errorname == "defaulttake")
+		print_eval("You pick #quest.error.article# up.");
+	else if (errorname == "baduse")
+		print_eval("You didn't say what you wanted to use that on.");
+	else if (errorname == "defaultuse")
+		print_eval("You can't use that here.");
+	else if (errorname == "defaultout")
+		print_eval("There's nowhere you can go out to around here.");
+	else if (errorname == "badplace")
+		print_eval("You can't go there.");
+	else if (errorname == "defaultexamine")
+		print_eval("Nothing out of the ordinary.");
+	else if (errorname == "badtake")
+		print_eval("You can't take #quest.error.article#.");
+	else if (errorname == "cantdrop")
+		print_eval("You can't drop that here.");
+	else if (errorname == "defaultdrop")
+		print_eval("You drop #quest.error.article#.");
+	else if (errorname == "baddrop")
+		print_eval("You are not carrying such a thing.");
+	else if (errorname == "badpronoun")
+		print_eval("I don't know what '#quest.error.pronoun#' you are referring to.");
+	else if (errorname == "badexamine")
+		print_eval("You didn't say what you wanted to examine.");
+	else
+		gi->debug_print("Bad error name " + errorname);
+}
+
+String geas_implementation::displayed_name(String obj) const {
+	String rv = obj, tmp;
+
+	if (get_obj_property(obj, "alias", tmp))
+		rv = tmp;
+	else {
+		for (uint i = 0; i < gf.blocks.size(); i ++)
+			if (ci_equal(gf.blocks[i].name, obj)) {
+				rv = gf.blocks[i].name;
+				break;
+			}
+	}
+	return rv;
+}
+
+/* For each destination, give:
+ * - printed name
+ * - accepted name, with prefix
+ * - accepted name, without prefix
+ * - destination, internal format
+ * - script (optional)
+ */
+Common::Array<Common::Array<String> > geas_implementation::get_places(String room) {
+	Common::Array<Common::Array<String> > rv;
+
+	const GeasBlock *gb = gf.find_by_name("room", room);
+	if (gb == NULL)
+		return rv;
+
+	String line, tok;
+	uint c1, c2;
+	for (uint i = 0; i < gb->data.size(); i ++) {
+		line = gb->data[i];
+		tok = first_token(line, c1, c2);
+		if (tok == "place") {
+			tok = next_token(line, c1, c2);
+			if (!is_param(tok)) {
+				gi->debug_print("Expected parameter after 'place' in " + line);
+				continue;
+			}
+			String dest_param = eval_param(tok);
+			if (dest_param == "") {
+				gi->debug_print("Parameter empty in " + line);
+				continue;
+			}
+
+			int j = dest_param.find(';');
+			String dest, prefix = "";
+			if (j == -1)
+				dest = trim(dest_param);
+			else {
+				dest = trim(dest_param.substr(j + 1));
+				prefix = trim(dest_param.substr(0, j));
+			}
+			String displayed = displayed_name(dest);
+			String printed_dest = (prefix != "" ? prefix + " " : "") +
+			                      "|b" + displayed + "|xb";
+
+			Common::Array<String> tmp;
+			tmp.push_back(printed_dest);
+			tmp.push_back(prefix + " " + displayed);
+			tmp.push_back(displayed);
+			tmp.push_back(dest);
+			String rest = trim(line.substr(c2));
+			if (rest != "")
+				tmp.push_back(rest);
+			rv.push_back(tmp);
+		}
+	}
+
+	for (uint i = 0; i < state.exits.size(); i ++) {
+		if (state.exits[i].src != room)
+			continue;
+		line = state.exits[i].dest;
+		tok = first_token(line, c1, c2);
+		if (tok == "exit") {
+			tok = next_token(line, c1, c2);
+			if (!is_param(tok))
+				continue;
+			tok = next_token(line, c1, c2);
+			assert(is_param(tok));
+			tok = param_contents(tok);
+			Common::Array<String> args = split_param(tok);
+			if (args.size() != 2) {
+				gi->debug_print("Expected two arguments in " + tok);
+				continue;
+			}
+			assert(args[0] == room);
+			Common::Array<String> tmp;
+			String displayed = displayed_name(args[1]);
+			tmp.push_back("|b" + displayed + "|xb");
+			tmp.push_back(displayed);
+			tmp.push_back(displayed);
+			tmp.push_back(args[1]);
+			rv.push_back(tmp);
+		} else if (tok == "destroy") {
+			tok = next_token(line, c1, c2);
+			assert(tok == "exit");
+			tok = next_token(line, c1, c2);
+
+			for (v2string::iterator j = rv.begin(); j != rv.end(); j ++)
+				if ((*j)[3] == tok) {
+					rv.erase(j);
+					break;
+				}
+		}
+
+
+	}
+
+	cerr << "get_places (" << room << ") -> " << rv << "\n";
+	return rv;
+}
+
+String geas_implementation::exit_dest(String room, String dir, bool *is_script) const {
+	uint c1, c2;
+	String tok;
+	if (is_script != NULL)
+		*is_script = false;
+	for (uint i = state.exits.size() - 1; i + 1 > 0; i --)
+		if (state.exits[i].src == room) {
+			String line = state.exits[i].dest;
+			cerr << "Processing exit line '" << state.exits[i].dest << "'\n";
+			tok = first_token(line, c1, c2);
+			cerr << "   first tok is " << tok << " (vs. exit)\n";
+			// SENSITIVE?
+			if (tok != "exit")
+				continue;
+			tok = next_token(line, c1, c2);
+			cerr << "   second tok is " << tok << " (vs. " << dir << ")\n";
+			if (tok != dir)
+				continue;
+			tok = next_token(line, c1, c2);
+			cerr << "   third tok is " << tok << " (expecting parameter)\n";
+			assert(is_param(tok));
+			Common::Array<String> p = split_param(param_contents(tok));
+			assert(p.size() == 2);
+			assert(ci_equal(p[0], room));
+			return p[1];
+		}
+	/*
+	if (gf.get_obj_action (room, dir, tok))
+	  {
+	    if (is_script != NULL)
+	*is_script = true;
+	    return tok;
+	  }
+	if (gf.get_obj_property (room, dir, tok))
+	  return tok;
+	else
+	  return "";
+	*/
+
+	const GeasBlock *gb = gf.find_by_name("room", room);
+	if (gb == NULL) {
+		gi->debug_print(String("Trying to find exit <") + dir +
+		                "> of nonexistent room <" + room + ">.");
+		return "";
+	}
+	// TODO: what's the priority on this?
+	for (uint i = 0; i < gb->data.size(); i ++) {
+		String line = gb->data[i];
+		tok = first_token(line, c1, c2);
+		if (tok == dir) {
+			uint line_start = c2;
+			tok = next_token(line, c1, c2);
+			if (is_param(tok))
+				return param_contents(tok);
+			if (tok != "") {
+				if (is_script != NULL)
+					*is_script = true;
+				return trim(line.substr(line_start + 1));
+			}
+			return "";
+		}
+	}
+	return "";
+}
+
+void geas_implementation::look() {
+	String tmp;
+	if (get_obj_action(state.location, "description", tmp))
+		run_script_as(state.location, tmp);
+	//run_script(tmp);
+	else if (get_obj_property(state.location, "description", tmp))
+		print_formatted(tmp);
+	else if (get_obj_action("game", "description", tmp))
+		run_script_as("game", tmp);
+	//run_script (tmp);
+	else if (get_obj_property("game", "description", tmp))
+		print_formatted(tmp);
+	else {
+		String in_desc;
+		if (get_obj_property(state.location, "indescription", tmp))
+			in_desc = tmp;
+		else
+			in_desc = "You are in";
+		print_formatted(in_desc + " " + get_svar("quest.formatroom"));
+
+		if ((tmp = get_svar("quest.formatobjects")) != "")
+			//print_formatted ("There is " + tmp + " here.");
+			print_eval("There is #quest.formatobjects# here.");
+		if ((tmp = get_svar("quest.doorways.out")) != "")
+			print_formatted("You can go out to " + tmp + ".");
+		if ((tmp = get_svar("quest.doorways.dirs")) != "")
+			//print_formatted ("You can go " + tmp + ".");
+			print_eval("You can go #quest.doorways.dirs#.");
+		if ((tmp = get_svar("quest.doorways.places")) != "")
+			print_formatted("You can go to " + tmp + ".");
+		if ((tmp = get_svar("quest.lookdesc")) != "")
+			print_formatted(tmp);
+	}
+}
+
+void geas_implementation::set_game(const String &fname) {
+	cerr << "set_game (...)\n";
+
+	gf = read_geas_file(gi, fname);
+	if (gf.blocks.size() == 0) {
+		is_running_ = false;
+		return;
+	}
+	//print_formatted ("Ready...|n|cbblack|crred|clblue|cggreen|cyyellow|n|uunderlined: |cbblack|crred|clblue|cggreen|cyyellow|xu|n");
+	//cerr << "Read game " << gf << endl;
+	uint tok_start, tok_end;
+	outputting = true;
+
+	state = GeasState(*gi, gf);
+
+	state.running = true;
+
+	for (uint gline = 0; gline < gf.block("game", 0).data.size(); gline ++) {
+		String s = gf.block("game", 0).data[gline];
+		String tok = first_token(s, tok_start, tok_end);
+		// SENSITIVE?
+		if (tok == "asl-version") {
+			String ver = next_token(s, tok_start, tok_end);
+			if (!is_param(ver)) {
+				gi->debug_print("Version " + s + " has invalid version " +
+					            ver);
+				continue;
+			}
+			int vernum = parse_int(param_contents(ver));
+			if (vernum < 311 || vernum > 353)
+				gi->debug_print("Warning: Geas only supports ASL "
+					            " versions 3.11 to 3.53");
+		}
+		// SENSITIVE?
+		else if (tok == "background") {
+			tok = next_token(s, tok_start, tok_end);
+			if (!is_param(tok))
+				gi->debug_print(nonparam("background color", s));
+			else
+				gi->set_background(param_contents(tok));
+		}
+		// SENSITIVE?
+		else if (tok == "default") {
+			tok = next_token(s, tok_start, tok_end);
+			// SENSITIVE?
+			if (tok == "fontname") {
+				tok = next_token(s, tok_start, tok_end);
+				if (!is_param(tok))
+					gi->debug_print(nonparam("font name", s));
+				else
+					gi->set_default_font(param_contents(tok));
+			}
+			// SENSITIVE?
+			else if (tok == "fontsize") {
+				tok = next_token(s, tok_start, tok_end);
+				if (!is_param(tok))
+					gi->debug_print(nonparam("font size", s));
+				else
+					gi->set_default_font_size(param_contents(tok));
+			}
+		}
+		// SENSITIVE?
+		else if (tok == "foreground") {
+			tok = next_token(s, tok_start, tok_end);
+			if (!is_param(tok))
+				gi->debug_print(nonparam("foreground color", s));
+			else
+				gi->set_foreground(param_contents(tok));
+		}
+		// SENSITIVE?
+		else if (tok == "gametype") {
+			tok = next_token(s, tok_start, tok_end);
+			// SENSITIVE?
+			if (tok == "singleplayer")
+				continue;
+			// SENSITIVE?
+			if (tok == "multiplayer")
+				throw String("Error: geas is single player only.");
+			gi->debug_print("Unexpected game type " + s);
+		}
+		// SENSITIVE?
+		else if (tok == "nodebug") {
+		}
+		// SENSITIVE?
+		else if (tok == "start") {
+			tok = next_token(s, tok_start, tok_end);
+			if (!is_param(tok))
+				gi->debug_print(nonparam("start room", s));
+			else {
+				state.location = param_contents(tok);
+			}
+		}
+	}
+
+	const GeasBlock &game = gf.block("game", 0);
+	cerr << gf << endl;
+	//print_formatted ("Done loading " + game.name);
+	uint c1, c2;
+	String tok;
+
+	/* TODO do I run the startscript or print the opening text first? */
+	run_script("displaytext <intro>");
+
+	for (uint i = 0; i < game.data.size(); i ++)
+		// SENSITIVE?
+		if (first_token(game.data[i], c1, c2) == "startscript") {
+			run_script_as("game", game.data[i].substr(c2 + 1));
+			//run_script (game.data[i].substr (c2 + 1));
+			break;
+		}
+
+	regen_var_room();
+	regen_var_objects();
+	regen_var_dirs();
+	regen_var_look();
+	look();
+
+	cerr << "s_g: done with set_game (...)\n\n";
+}
+
+void geas_implementation::regen_var_objects() {
+	String tmp;
+	Common::Array <String> objs;
+	for (uint i = 0; i < state.objs.size(); i ++) {
+		//cerr << "r_v_o: Checking '" << state.objs[i].name << "' (" << state.objs[i].parent << "): " << ((state.objs[i].parent == state.location) ? "YES" : "NO") << endl;
+		if (ci_equal(state.objs[i].parent, state.location) &&
+		        !get_obj_property(state.objs[i].name, "hidden", tmp) &&
+		        !get_obj_property(state.objs[i].name, "invisible", tmp))
+			//!state.objs[i].hidden &&
+			//!state.objs[i].invisible)
+			objs.push_back(state.objs[i].name);
+	}
+	String qobjs = "", qfobjs = "";
+	String objname, prefix, main, suffix, propval, print1, print2;
+	for (uint i = 0; i < objs.size(); i ++) {
+		objname = objs[i];
+		if (!get_obj_property(objname, "alias", main))
+			main = objname;
+		print1 = main;
+		print2 = "|b" + main + "|xb";
+		if (get_obj_property(objname, "prefix", prefix)) {
+			print1 = prefix + " " + print1;
+			print2 = prefix + " " + print2;
+		}
+		if (get_obj_property(objname, "suffix", suffix)) {
+			print1 = print1 + " " + suffix;
+			print2 = print2 + " " + suffix;
+		}
+		qobjs = qobjs + print1;
+		qfobjs = qfobjs + print2;
+		if (i + 2 < objs.size()) {
+			qobjs = qobjs + ", ";
+			qfobjs = qfobjs + ", ";
+		} else if (i + 2 == objs.size()) {
+			qobjs = qobjs + " and ";
+			qfobjs = qfobjs + " and ";
+		}
+	}
+	set_svar("quest.objects", qobjs);
+	set_svar("quest.formatobjects", qfobjs);
+}
+
+void geas_implementation::regen_var_room() {
+	set_svar("quest.currentroom", state.location);
+
+	String tmp, formatroom;
+	if (!get_obj_property(state.location, "alias", formatroom))
+		formatroom = state.location;
+	formatroom = "|cr" + formatroom + "|cb";
+	if (get_obj_property(state.location, "prefix", tmp))
+		formatroom = tmp + " " + formatroom;
+	if (get_obj_property(state.location, "suffix", tmp))
+		formatroom = formatroom + " " + tmp;
+	//set_svar ("quest.formatroom", displayed_name (state.location));
+	set_svar("quest.formatroom", formatroom);
+
+	// regen_var_objects();
+	/*
+	String out_dest = exit_dest (state.location, "out");
+	if (out_dest == "")
+	  {
+	    set_svar ("quest.doorways.out", "");
+	    set_svar ("quest.doorways.out.display", "");
+	  }
+	else
+	  {
+	    cerr << "Updating quest.doorways.out; out_dest == {" << out_dest << "}";
+	    uint i = out_dest.find (';');
+	    cerr << ", i == " << i;
+	    String prefix = "";
+	    if (i != -1)
+	{
+	  prefix = trim (out_dest.substr (0, i-1));
+	  out_dest = trim (out_dest.substr (i + 1));
+	  cerr << "; prefix == {" << prefix << "}, out_dest == {" << out_dest << "}";
+	}
+	    cerr << "  quest.doorways.out == {" << out_dest << "}";
+	    set_svar ("quest.doorways.out", out_dest);
+	    cerr << endl;
+
+	    String tmp = displayed_name (out_dest);
+
+	    cerr << ", tmp == {" << tmp << "}";
+
+	    if (tmp != "")
+	tmp = "|b" + tmp + "|xb";
+	    else if (prefix != "")
+	tmp = prefix + " |b" + out_dest + "|xb";
+	    else
+	tmp = "|b" + out_dest + "|xb";
+
+	    cerr << ",    final value {" << tmp << "}" << endl;
+
+	    set_svar ("quest.doorways.out.display", tmp);
+	  }
+	*/
+}
+
+
+void geas_implementation::regen_var_look() {
+	String look_tag;
+	if (!get_obj_property(state.location, "look", look_tag))
+		look_tag = "";
+	set_svar("quest.lookdesc", look_tag);
+}
+
+
+void geas_implementation::regen_var_dirs() {
+	Common::Array <String> dirs;
+	// the -1 is so that it skips 'out'
+	for (uint i = 0; i < ARRAYSIZE(dir_names) - 1; i ++)
+		if (exit_dest(state.location, dir_names[i]) != "")
+			dirs.push_back(dir_names[i]);
+	String exits = "";
+	if (dirs.size() == 1)
+		exits = "|b" + dirs[0] + "|xb";
+	else if (dirs.size() > 1) {
+		for (uint i = 0; i < dirs.size(); i ++) {
+			exits = exits + "|b" + dirs[i] + "|xb";
+			if (i < dirs.size() - 2)
+				exits = exits + ", ";
+			else if (i == dirs.size() - 2)
+				exits = exits + " or ";
+		}
+	}
+	set_svar("quest.doorways.dirs", exits);
+
+	/*
+	String tmp;
+	if ((tmp = exit_dest (state.location, "out")) != "")
+	  set_svar ("quest.doorways.out", displayed_name (tmp));
+	else
+	  set_svar ("quest.doorways.out", "");
+	*/
+
+	String out_dest = exit_dest(state.location, "out");
+	if (out_dest == "") {
+		set_svar("quest.doorways.out", "");
+		set_svar("quest.doorways.out.display", "");
+	} else {
+		cerr << "Updating quest.doorways.out; out_dest == {" << out_dest << "}";
+		int i = out_dest.find(';');
+		cerr << ", i == " << i;
+		String prefix = "";
+		if (i != -1) {
+			prefix = trim(out_dest.substr(0, i - 1));
+			out_dest = trim(out_dest.substr(i + 1));
+			cerr << "; prefix == {" << prefix << "}, out_dest == {" << out_dest << "}";
+		}
+		cerr << "  quest.doorways.out == {" << out_dest << "}";
+		set_svar("quest.doorways.out", out_dest);
+		cerr << endl;
+
+		String tmp = displayed_name(out_dest);
+
+		cerr << ", tmp == {" << tmp << "}";
+
+		if (tmp != "")
+			tmp = "|b" + tmp + "|xb";
+		else if (prefix != "")
+			tmp = prefix + " |b" + out_dest + "|xb";
+		else
+			tmp = "|b" + out_dest + "|xb";
+
+		cerr << ",    final value {" << tmp << "}" << endl;
+
+		set_svar("quest.doorways.out.display", tmp);
+	}
+
+	/* TODO handle this */
+	//set_svar ("quest.doorways.places", "");
+	current_places = get_places(state.location);
+	String printed_places = "";
+	for (uint i = 0; i < current_places.size(); i ++) {
+		if (i == 0)
+			printed_places = current_places[i][0];
+		else if (i < current_places.size() - 1)
+			printed_places = printed_places + ", " + current_places[i][0];
+		else if (current_places.size() == 2)
+			printed_places = printed_places + " or " + current_places[i][0];
+		else
+			printed_places = printed_places + ", or " + current_places[i][0];
+	}
+	set_svar("quest.doorways.places", printed_places);
+}
+
+
+
+// TODO:  SENSITIVE???
+String geas_implementation::substitute_synonyms(String s) const {
+	String orig = s;
+	cerr << "substitute_synonyms (" << s << ")\n";
+	const GeasBlock *gb = gf.find_by_name("synonyms", "");
+	if (gb != NULL) {
+		/* TODO: exactly in what order does it try synonyms?
+		 * Does it have to be flanked by whitespace?
+		 */
+		for (uint i = 0; i < gb->data.size(); i ++) {
+			String line = gb->data[i];
+			int index = line.find('=');
+			if (index == -1)
+				continue;
+			Common::Array<String> words = split_param(line.substr(0, index));
+			String rhs = trim(line.substr(index + 1));
+			if (rhs == "")
+				continue;
+			for (uint j = 0; j < words.size(); j ++) {
+				String lhs = words[j];
+				if (lhs == "")
+					continue;
+				int k = 0;
+				while ((k = s.find(lhs, k)) != -1) {
+					uint end_index = k + lhs.length();
+					if ((k == 0 || s[k - 1] == ' ') &&
+					        (end_index == s.length() || s[end_index] == ' ')) {
+						s = s.substr(0, k) + rhs + s.substr(k + lhs.length());
+						k = k + rhs.length();
+					} else
+						k ++;
+				}
+			}
+		}
+	}
+	cerr << "substitute_synonyms (" << orig << ") -> '" << s << "'\n";
+	return s;
+}
+
+bool geas_implementation::is_running() const {
+	return is_running_;
+}
+
+String geas_implementation::get_banner() {
+	String banner;
+	const GeasBlock *gb = gf.find_by_name("game", "game");
+	if (gb) {
+		String line = gb->data[0];
+		uint c1, c2;
+		String tok = first_token(line, c1, c2);
+		tok = next_token(line, c1, c2);
+		tok = next_token(line, c1, c2);
+		if (is_param(tok)) {
+			banner = eval_param(tok);
+
+			for (uint i = 0; i < gb->data.size(); i ++) {
+				line = gb->data[i];
+				if (first_token(line, c1, c2) == "game" &&
+				        next_token(line, c1, c2) == "version" &&
+				        is_param(tok = next_token(line, c1, c2))) {
+					banner += ", v";
+					banner += eval_param(tok);
+				}
+			}
+
+			for (uint i = 0; i < gb->data.size(); i ++) {
+				line = gb->data[i];
+				if (first_token(line, c1, c2) == "game" &&
+				        next_token(line, c1, c2) == "author" &&
+				        is_param(tok = next_token(line, c1, c2))) {
+					banner += " | ";
+					banner += eval_param(tok);
+				}
+			}
+		}
+	}
+	return banner;
+}
+
+void geas_implementation::run_command(String s) {
+	/* if s == "restore" or "restart" or "quit" or "undo" */
+
+	if (!is_running_)
+		return;
+
+	print_newline();
+	print_normal("> " + s);
+	print_newline();
+
+	if (s == "dump status") {
+		//cerr << state << endl;
+		ostringstream oss;
+		oss << state;
+		print_normal(oss.str());
+		return;
+	}
+
+	if (s == "undo") {
+		if (undo_buffer.size() < 2) {
+			print_formatted("(No more undo information available!)");
+			return;
+		}
+		undo_buffer.pop();
+		state = undo_buffer.peek();
+		print_formatted("Undone.");
+		return;
+	}
+
+	if (!state.running)
+		return;
+	// TODO: does this get the original command, or the lowercased version?
+	set_svar("quest.originalcommand", s);
+	s = substitute_synonyms(lcase(s));
+	set_svar("quest.command", s);
+
+	bool overridden = false;
+	dont_process = false;
+
+	const GeasBlock *gb = gf.find_by_name("room", state.location);
+	if (gb != NULL) {
+		String line, tok;
+		uint c1, c2;
+		for (uint i = 0; i < gb->data.size(); i ++) {
+			line = gb->data[i];
+			tok = first_token(line, c1, c2);
+			// SENSITIVE?
+			if (tok == "beforeturn") {
+				uint scr_starts = c2;
+				tok = next_token(line, c1, c2);
+				// SENSITIVE?
+				if (tok == "override") {
+					overridden = true;
+					scr_starts = c2;
+				}
+				String scr = line.substr(scr_starts);
+				run_script(state.location, scr);
+				//run_script (scr);
+			}
+		}
+	} else
+		gi->debug_print("Unable to find block " + state.location + ".\n");
+
+	if (!overridden) {
+		gb = gf.find_by_name("game", "game");
+		if (gb != NULL) {
+			String line, tok;
+			uint c1, c2;
+			for (uint i = 0; i < gb->data.size(); i ++) {
+				line = gb->data[i];
+				tok = first_token(line, c1, c2);
+				// SENSITIVE?
+				if (tok == "beforeturn") {
+					uint scr_starts = c2;
+					tok = next_token(line, c1, c2);
+					// SENSITIVE?
+					if (tok == "override") {
+						overridden = true;
+						scr_starts = c2;
+					}
+					String scr = line.substr(scr_starts);
+					run_script_as("game", scr);
+					//run_script (scr);
+				}
+			}
+		} else
+			gi->debug_print("Unable to find block game.\n");
+	}
+
+	if (!dont_process) {
+		if (try_match(s, false, false)) {
+			/* TODO TODO */
+			// run after turn events ???
+		} else
+			display_error("badcommand");
+	}
+
+	overridden = false;
+
+	gb = gf.find_by_name("room", state.location);
+	if (gb != NULL) {
+		String line, tok;
+		uint c1, c2;
+		for (uint i = 0; i < gb->data.size(); i ++) {
+			line = gb->data[i];
+			tok = first_token(line, c1, c2);
+			// SENSITIVE?
+			if (tok == "afterturn") {
+				uint scr_starts = c2;
+				tok = next_token(line, c1, c2);
+				// SENSITIVE?
+				if (tok == "override") {
+					overridden = true;
+					scr_starts = c2;
+				}
+				String scr = line.substr(scr_starts);
+				run_script_as(state.location, scr);
+				//run_script (scr);
+			}
+		}
+	}
+	if (!overridden) {
+		gb = gf.find_by_name("game", "game");
+		if (gb != NULL) {
+			String line, tok;
+			uint c1, c2;
+			for (uint i = 0; i < gb->data.size(); i ++) {
+				line = gb->data[i];
+				tok = first_token(line, c1, c2);
+				// SENSITIVE?
+				if (tok == "afterturn") {
+					uint scr_starts = c2;
+					tok = next_token(line, c1, c2);
+					// SENSITIVE?
+					if (tok == "override") {
+						overridden = true;
+						scr_starts = c2;
+					}
+					String scr = line.substr(scr_starts);
+					run_script_as("game", scr);
+					//run_script (scr);
+				}
+			}
+		}
+	}
+
+	if (state.running)
+		undo_buffer.push(state);
+}
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const match_rv &rv) {
+	//o << "match_rv {" << (rv.success ? "TRUE" : "FALSE") << ": " << rv.bindings << "}";
+	o << "match_rv {" << (rv.success ? "TRUE" : "FALSE") << ": [";
+	//o << rv.bindings.size();
+	o << rv.bindings;
+	//for (uint i = 0; i < rv.bindings.size(); i ++)
+	//  o << rv.bindings[i] << ", ";
+	o << "]}";
+	return o;
+}
+
+match_rv geas_implementation::match_command(String input, String action) const {
+	//cerr << "match_command (\"" << input << "\", \"" << action << "\")" << endl;
+	match_rv rv = match_command(input, 0, action, 0, match_rv());
+	cerr << "match_command (\"" << input << "\", \"" << action << "\") -> " << rv << endl;
+	return rv;
+	//return match_command (input, 0, action, 0, match_rv ());
+}
+
+match_rv geas_implementation::match_command(String input, uint ichar, String action, uint achar, match_rv rv) const {
+	//cerr << "match_command (\"" << input << "\", " << ichar << ", \"" << action << "\", " << achar << ", " << rv << ")" << endl;
+	for (;;) {
+		if (achar == action.length()) {
+			//cerr << "End of action, returning " << (ichar == input.length()) << "\n";
+			return match_rv(ichar == input.length(), rv);
+		}
+		if (action[achar] == '#') {
+
+			achar ++;
+			String varname;
+			while (achar != action.length() && action[achar] != '#') {
+				varname += action[achar];
+				achar ++;
+			}
+			if (achar == action.length())
+				throw String("Unpaired hashes in command String " + action);
+			//rv.bindings.push_back (varname);
+			int index = rv.bindings.size();
+			rv.bindings.push_back(match_binding(varname, ichar));
+			achar ++;
+			varname = "";
+			//rv.bindings.push_back (varname);
+			rv.bindings[index].set(varname, ichar);
+			while (ichar < input.length()) {
+				match_rv tmp = match_command(input, ichar, action, achar, rv);
+				if (tmp.success)
+					return tmp;
+				varname += input[ichar];
+				ichar ++;
+				//rv.bindings[index] = varname;
+				rv.bindings[index].set(varname, ichar);
+			}
+			return match_rv(achar == action.length(), rv);
+		}
+		// SENSITIVE?
+		if (ichar == input.length() || !c_equal_i(input[ichar], action[achar]))
+			return match_rv();
+		//cerr << "Matched " << input[ichar] << " to " << action[achar] << endl;
+		++ achar;
+		++ ichar;
+	}
+}
+
+bool match_object_alts(String text, const Common::Array<String> &alts, bool is_internal) {
+	for (uint i = 0; i < alts.size(); i ++) {
+		cerr << "m_o_a: Checking '" << text << "' v. alt '" << alts[i] << "'.\n";
+		if (starts_with(text, alts[i])) {
+			uint len = alts[i].length();
+			if (text.length() == len)
+				return true;
+			if (text.length() > len  &&  text[len] == ' '  &&
+			        match_object_alts(text.substr(len + 1), alts, is_internal))
+				return true;
+		}
+	}
+	return false;
+}
+
+
+bool geas_implementation::match_object(String text, String name, bool is_internal) const {
+	cerr << "* * * match_object (" << text << ", " << name << ", "
+	     << (is_internal ? "true" : "false") << ")\n";
+
+	String alias, alt_list, prefix, suffix;
+
+	if (is_internal && ci_equal(text, name)) return true;
+
+	if (get_obj_property(name, "prefix", prefix) &&
+	        starts_with(text, prefix + " ") &&
+	        match_object(text.substr(prefix.length() + 1), name, false))
+		return true;
+
+	if (get_obj_property(name, "suffix", suffix) &&
+	        ends_with(text, " " + suffix) &&
+	        match_object(text.substr(0, text.length() - suffix.length() - 1), name, false))
+		return true;
+
+	if (!get_obj_property(name, "alias", alias))
+		alias = name;
+	if (ci_equal(text, alias))
+		return true;
+
+	const GeasBlock *gb = gf.find_by_name("object", name);
+	if (gb != NULL) {
+		String tok, line;
+		uint c1, c2;
+		for (uint ln = 0; ln < gb->data.size(); ln ++) {
+			line = gb->data[ln];
+			tok = first_token(line, c1, c2);
+			// SENSITIVE?
+			if (tok == "alt") {
+				tok = next_token(line, c1, c2);
+				if (!is_param(tok))
+					gi->debug_print("Expected param after alt in " + line);
+				else {
+					Common::Array<String> alts = split_param(param_contents(tok));
+					cerr << "  m_o: alt == " << alts << "\n";
+					return match_object_alts(text, alts, is_internal);
+				}
+			}
+		}
+	}
+
+	return false;
+}
+
+
+bool geas_implementation::dereference_vars(Common::Array<match_binding> &bindings, bool is_internal) const {
+	/* TODO */
+	Common::Array<String> where;
+	where.push_back("inventory");
+	where.push_back(state.location);
+	return dereference_vars(bindings, where, is_internal);
+}
+
+bool geas_implementation::dereference_vars(Common::Array<match_binding> &bindings, const Common::Array<String> &where, bool is_internal) const {
+	bool rv = true;
+	for (uint i = 0; i < bindings.size(); i ++)
+		if (bindings[i].var_name[0] == '@') {
+			String obj_name = get_obj_name(bindings[i].var_text, where, is_internal);
+			if (obj_name == "!") {
+				print_formatted("You don't see any " + bindings[i].var_text + ".");
+				rv = false;
+			} else {
+				bindings[i].var_text = obj_name;
+				bindings[i].var_name = bindings[i].var_name.substr(1);
+			}
+		}
+	return rv;
+}
+
+String geas_implementation::get_obj_name(String name, const Common::Array<String> &where, bool is_internal) const {
+	Common::Array<String> objs, printed_objs;
+	for (uint objnum = 0; objnum < state.objs.size(); objnum ++) {
+		bool is_used = false;
+		for (uint j = 0; j < where.size(); j ++) {
+			cerr << "Object #" << objnum << ": " << state.objs[objnum].name
+			     << "@" << state.objs[objnum].parent << " vs. "
+			     << where[j] << endl;
+			// SENSITIVE?
+			if (where[j] == "game" || state.objs[objnum].parent == where[j])
+				is_used = true;
+		}
+		if (is_used && !has_obj_property(state.objs[objnum].name, "hidden") &&
+		        match_object(name, state.objs[objnum].name, is_internal)) {
+			String printed_name, tmp, oname = state.objs[objnum].name;
+			objs.push_back(oname);
+			if (!get_obj_property(oname, "alias", printed_name))
+				printed_name = oname;
+			if (get_obj_property(oname, "detail", tmp))
+				printed_name = tmp;
+			printed_objs.push_back(printed_name);
+		}
+	}
+	cerr << "objs == " << objs << ", printed_objs == " << printed_objs << "\n";
+	if (objs.size() > 1) {
+		//bindings[i].var_name = bindings[i].var_name.substr(1);
+		uint num = 0;
+		//if (objs.size() > 1)
+		num = gi->make_choice("Which " + name + " do you mean?", printed_objs);
+
+		//bindings[i].var_text = objs[num];
+		return objs[num];
+	}
+	if (objs.size() == 1)
+		return objs[0];
+	return "!";
+}
+
+
+void geas_implementation::set_vars(const Common::Array<match_binding> &v) {
+	for (uint i = 0; i < v.size(); i ++)
+		set_svar(v[i].var_name, v[i].var_text);
+}
+
+
+bool geas_implementation::run_commands(String cmd, const GeasBlock *room, bool is_internal) {
+	uint c1, c2;
+	String line, tok;
+	match_rv match;
+
+	if (room != NULL) {
+		for (uint i = 0; i < room->data.size(); i++) {
+			line = room->data[i];
+			tok = first_token(line, c1, c2);
+			// SENSITIVE?
+			if (tok == "command") {
+				tok = next_token(line, c1, c2);
+				if (is_param(tok)) {
+					Common::Array<String> tmp = split_param(param_contents(tok));
+
+					for (uint j = 0; j < tmp.size(); j++)
+						if (match = match_command(cmd, tmp[j])) {
+							if (!dereference_vars(match.bindings, is_internal))
+								return false;
+							set_vars(match.bindings);
+							run_script_as(state.location, line.substr(c2 + 1));
+							//run_script (line.substr (c2+1));
+							return true;
+						}
+					/*
+					  if (match = match_command (cmd, param_contents(tok)))
+					  {
+					  if (!dereference_vars (match.bindings))
+					  return false;
+					  set_vars (match.bindings);
+					  run_script (line.substr (c2+1));
+					  return true;
+					  }
+					*/
+				} else {
+					gi->debug_print("Bad command line: " + line);
+				}
+			}
+		}
+	} else
+		gi->debug_print("room is null\n");
+
+	return false;
+}
+
+bool geas_implementation::try_match(String cmd, bool is_internal, bool is_normal) {
+	//print_formatted ("geas_impl registers " + cmd);
+
+	String line, tok;
+	match_rv match;
+
+	if (!is_normal) {
+		if (run_commands(cmd, gf.find_by_name("room", state.location)) ||
+		        run_commands(cmd, gf.find_by_name("game", "game")))
+			return true;
+	}
+
+	if ((match = match_command(cmd, "look at #@object#")) ||
+	        (match = match_command(cmd, "look #@object#"))) {
+		if (!dereference_vars(match.bindings, is_internal))
+			return true;
+
+		String object = match.bindings[0].var_text;
+
+		if (get_obj_action(object, "look", tok))
+			run_script_as(object, tok);
+		//run_script (tok);
+		else if (get_obj_property(object, "look", tok))
+			print_formatted(tok);
+		else
+			display_error("defaultlook", object);
+
+		return true;
+	}
+
+	if ((match = match_command(cmd, "examine #@object#")) ||
+	        (match = match_command(cmd, "x #@object#"))) {
+		if (!dereference_vars(match.bindings, is_internal))
+			return true;
+
+		String object = match.bindings[0].var_text;
+		if (get_obj_action(object, "examine", tok))
+			run_script_as(object, tok);
+		//run_script (tok);
+		else if (get_obj_property(object, "examine", tok))
+			print_formatted(tok);
+		else if (get_obj_action(object, "look", tok))
+			run_script_as(object, tok);
+		//run_script (tok);
+		else if (get_obj_property(object, "look", tok))
+			print_formatted(tok);
+		else
+			display_error("defaultexamine", object);
+		return true;
+	}
+
+	if (match = match_command(cmd, "look")) {
+		look();
+		return true;
+	}
+
+	if (match = match_command(cmd, "give #@first# to #@second#")) {
+		if (!dereference_vars(match.bindings, is_internal))
+			return true;
+		String script, first = match.bindings[0].var_text, second = match.bindings[1].var_text;
+		if (! ci_equal(get_obj_parent(first), "inventory"))
+			display_error("noitem", first);
+		else if (get_obj_action(second, "give " + first, script))
+			run_script(second, script);
+		//run_script (script);
+		else if (get_obj_action(first, "give to " + second, script))
+			run_script_as(first, script);
+		//run_script (script);
+		else if (get_obj_action(second, "give anything", script)) {
+			set_svar("quest.give.object.name", first);
+			run_script_as(second, script);
+			//run_script (script);
+		} else if (get_obj_action(first, "give to anything", script)) {
+			set_svar("quest.give.object.name", second);
+			run_script_as(first, script);
+			//run_script (script);
+		} else {
+			String tmp;
+			if (!get_obj_property(second, "gender", tmp))
+				tmp = "it";
+			set_svar("quest.error.gender", tmp);
+			if (!get_obj_property(first, "article", tmp))
+				tmp = "it";
+			set_svar("quest.error.article", tmp);
+			display_error("itemunwanted");
+		}
+		return true;
+	}
+
+	if ((match = match_command(cmd, "use #@first# on #@second#")) ||
+	        (match = match_command(cmd, "use #@first# with #@second#"))) {
+		if (!dereference_vars(match.bindings, is_internal))
+			return true;
+		String script, first = match.bindings[0].var_text, second = match.bindings[1].var_text;
+		if (! ci_equal(get_obj_parent(first), "inventory"))
+			display_error("noitem", first);
+		else if (get_obj_action(second, "use " + first, script)) {
+			//set_svar ("quest.use.object", first);
+			run_script_as(second, script);
+			//run_script (script);
+		} else if (get_obj_action(first, "use on " + second, script)) {
+			//set_svar ("quest.use.object", second);
+			run_script_as(first, script);
+			//run_script (script);
+		} else if (get_obj_action(second, "use anything", script)) {
+			set_svar("quest.use.object", first);
+			run_script(second, script);
+			//run_script (script);
+		} else if (get_obj_action(first, "use on anything", script)) {
+			set_svar("quest.use.object", second);
+			run_script_as(first, script);
+			//run_script (script);
+		} else
+			display_error("defaultuse");
+
+		return true;
+	}
+
+	if (match = match_command(cmd, "use #@first#")) {
+		if (!dereference_vars(match.bindings, is_internal))
+			return true;
+		String tmp, obj = match.bindings[0].var_text;
+		if (!ci_equal(get_obj_parent(obj), "inventory"))
+			display_error("noitem", obj);
+		else if (get_obj_action(obj, "use", tmp))
+			run_script_as(obj, tmp);
+		//run_script (tmp);
+		else if (get_obj_property(obj, "use", tmp))
+			print_formatted(tmp);
+		else
+			display_error("defaultuse", obj);
+		return true;
+	}
+
+
+	if ((match = match_command(cmd, "take #@object#")) ||
+	        (match = match_command(cmd, "get #@object#"))) {
+		if (!dereference_vars(match.bindings, is_internal))
+			return true;
+
+		String object = match.bindings[0].var_text;
+		if (get_obj_action(object, "take", tok)) {
+			cerr << "Running script '" << tok << "' for take " << object << endl;
+			run_script_as(object, tok);
+			//run_script (tok);
+		} else if (get_obj_property(object, "take", tok)) {
+			cerr << "Found property '" << tok << "' for take " << object << endl;
+			if (tok != "")
+				print_formatted(tok);
+			else
+				display_error("defaulttake", object);
+			String tmp;
+			move(object, "inventory");
+			if (get_obj_action(object, "gain", tmp))
+				run_script(object, tmp);
+			//run_script (tmp);
+			else if (get_obj_property(object, "gain", tmp))
+				print_formatted(tmp);
+		} else {
+			cerr << "No match found for take " << object << endl;
+			// TODO set variable with object name
+			display_error("badtake", object);
+		}
+		return true;
+	}
+
+
+	if (match = match_command(cmd, "drop #@object#")) {
+		if (!dereference_vars(match.bindings, is_internal))
+			return true;
+		String scr, obj = match.bindings[0].var_text;
+		if (get_obj_action(obj, "drop", scr)) {
+			run_script_as(obj, scr);
+			//run_script (scr);
+			return true;
+		}
+
+		const GeasBlock *gb = gf.find_by_name("object", obj);
+		if (gb != NULL) {
+			uint c1, c2, script_begins;
+			for (uint i = 0; i < gb->data.size(); i ++) {
+				line = gb->data[i];
+				tok = first_token(line, c1, c2);
+				// SENSITIVE?
+				if (tok == "drop") {
+					script_begins = c2;
+					tok = next_token(line, c1, c2);
+					// SENSITIVE?
+					if (tok == "everywhere") {
+						tok = next_token(line, c1, c2);
+						move(obj, state.location);
+						if (is_param(tok))
+							print_eval(tok);
+						else
+							gi->debug_print("Expected param after drop everywhere in " + line);
+						return true;
+					}
+					// SENSITIVE?
+					if (tok == "nowhere") {
+						if (is_param(tok))
+							print_eval(tok);
+						else
+							gi->debug_print("Expected param after drop nowhere in " + line);
+						return true;
+					}
+					run_script_as(obj, line.substr(script_begins));
+					//run_script (line.substr (script_begins));
+					return true;
+				}
+			}
+		}
+		move(obj, state.location);
+		display_error("defaultdrop", obj);
+		return true;
+	}
+
+	if ((match = match_command(cmd, "speak to #@object#")) ||
+	        (match = match_command(cmd, "speak #@object#")) ||
+	        (match = match_command(cmd, "talk to #@object#")) ||
+	        (match = match_command(cmd, "talk #@object#"))) {
+		//print_formatted ("Talk to <" + String (match.bindings[0]) + ">");
+		if (!dereference_vars(match.bindings, is_internal))
+			return true;
+		String obj = match.bindings[0].var_text;
+		String script;
+		if (get_obj_action(obj, "speak", script))
+			run_script_as(obj, script);
+		//run_script (script);
+		else
+			display_error("defaultspeak", obj);
+		//print_formatted ("Talk to <" + String (match.bindings[0]) + ">");
+		return true;
+	}
+
+	if (cmd == "exit" || cmd == "out" || cmd == "go out") {
+		const GeasBlock *gb = gf.find_by_name("room", state.location);
+		if (gb == NULL) {
+			gi->debug_print("Bad room");
+			return true;
+		}
+
+		line = "";
+		int c1 = -1, c2 = -1;
+		uint uc1, uc2;
+		// TODO: Use the first matching line or the last?
+		for (uint i = 0; i < gb->data.size(); i ++) {
+			if (first_token(gb->data[i], uc1, uc2) == "out")
+				line = gb->data[i];
+			c1 = uc1;
+			c2 = uc2;
+		}
+
+		//gi->debug_print ("COMMAND " + cmd + ": line == " + line);
+
+		if (line == "")
+			display_error("defaultout");
+		else {
+			c1 = line.find('<');
+			if (c1 != -1)
+				c2 = line.find('>', c1);
+
+			if (c1 == -1 || c2 == -1)
+				gi->debug_print("Bad out line: " + line);
+			else {
+				String tmp = trim(line.substr(c2 + 1));
+				//gi->debug_print ("tmp1 == {" + tmp + "}");
+				if (tmp != "")
+					run_script_as(state.location, tmp);
+				//run_script (tmp);
+				else {
+					tmp = line.substr(c1, c2 - c1 + 1);
+					//gi->debug_print ("tmp2 == {" + tmp + "}");
+					assert(is_param(tmp));
+					tmp = param_contents(tmp);
+					c1 = tmp.find(';');
+					if (c1 == -1)
+						goto_room(trim(tmp));
+					else
+						goto_room(trim(tmp.substr(c1 + 1)));
+				}
+			}
+		}
+		return true;
+	}
+
+	for (uint i = 0; i < ARRAYSIZE(dir_names); i ++)
+		if (cmd == dir_names[i] || cmd == (String("go ") + dir_names[i]) ||
+		        cmd == short_dir_names[i] || cmd == (String("go ") + short_dir_names[i])) {
+			bool is_script = false;
+			//print_formatted ("Trying to go " + dir_names[i]);
+			if ((tok = exit_dest(state.location, dir_names[i], &is_script)) == "") {
+				// TODO Which display_error do I use?
+				print_formatted("You can't go that way.");
+				return true;
+			}
+			if (is_script)
+				run_script_as(state.location, tok);
+			//run_script (tok);
+			else {
+				int index = tok.find(';');
+				if (index == -1)
+					goto_room(trim(tok));
+				else
+					goto_room(trim(tok.substr(index + 1)));
+			}
+			return true;
+		}
+
+	if ((match = match_command(cmd, "go to #@room#")) ||
+	        (match = match_command(cmd, "go #@room#"))) {
+		assert(match.bindings.size() == 1);
+		String destination = match.bindings[0].var_text;
+		for (uint i = 0; i < current_places.size(); i ++) {
+			if (ci_equal(destination, current_places[i][1]) ||
+			        ci_equal(destination, current_places[i][2])) {
+				if (current_places[i].size() == 5)
+					run_script_as(state.location, current_places[i][4]);
+				//run_script (current_places[i][4]);
+				else
+					goto_room(current_places[i][3]);
+				return true;
+			}
+		}
+		display_error("badplace", destination);
+		return true;
+	}
+
+	if (ci_equal(cmd, "inventory") || ci_equal(cmd, "i")) {
+		Common::Array<Common::Array<String> > inv = get_inventory();
+		if (inv.size() == 0)
+			print_formatted("You are carrying nothing.");
+		else
+			print_formatted("You are carrying:");
+		for (uint i = 0; i < inv.size(); i ++) {
+			print_normal(inv[i][0]);
+			print_newline();
+		}
+		return true;
+	}
+
+	if (ci_equal(cmd, "help")) {
+		print_formatted("|b|cl|s14Quest Quick Help|xb|cb|s00|n|n|cl|bMoving|xb|cb Press the direction buttons in the 'Compass' pane, or type |bGO NORTH|xb, |bSOUTH|xb, |bE|xb, etc. |xnTo go into a place, type |bGO TO ...|xb . To leave a place, type |bOUT, EXIT|xb or |bLEAVE|xb, or press the '|crOUT|cb' button.|n|cl|bObjects and Characters|xb|cb Use |bTAKE ...|xb, |bGIVE ... TO ...|xb, |bTALK|xb/|bSPEAK TO ...|xb, |bUSE ... ON|xb/|bWITH ...|xb, |bLOOK AT ...|xb, etc.|n|cl|bExit Quest|xb|cb Type |bQUIT|xb to leave Quest.|n|cl|bMisc|xb|cb Type |bABOUT|xb to get information on the current game.");
+		return true;
+	}
+
+	if (ci_equal(cmd, "about")) {
+		const GeasBlock *gb = gf.find_by_name("game", "game");
+		if (gb == NULL)
+			return true;
+		cerr << *gb << endl;
+
+		uint c1, c2;
+		//print_formatted ("Game name: ");
+		line = gb->data[0];
+		tok = first_token(line, c1, c2);  // game
+		tok = next_token(line, c1, c2);  // name
+		tok = next_token(line, c1, c2);  // <whatever>
+		if (is_param(tok))
+			print_formatted("Game name: " + eval_param(tok));
+
+
+		for (uint i = 0; i < gb->data.size(); i ++) {
+			line = gb->data[i];
+			// SENSITIVE?
+			if (first_token(line, c1, c2) == "game" &&
+			        next_token(line, c1, c2) == "version" &&
+			        is_param(tok = next_token(line, c1, c2)))
+				print_formatted("Version " + eval_param(tok));
+		}
+
+		for (uint i = 0; i < gb->data.size(); i ++) {
+			line = gb->data[i];
+			// SENSITIVE?
+			if (first_token(line, c1, c2) == "game" &&
+			        next_token(line, c1, c2) == "author" &&
+			        is_param(tok = next_token(line, c1, c2)))
+				print_formatted("Author: " + eval_param(tok));
+		}
+
+		for (uint i = 0; i < gb->data.size(); i ++) {
+			line = gb->data[i];
+			// SENSITIVE?
+			if (first_token(line, c1, c2) == "game" &&
+			        next_token(line, c1, c2) == "copyright" &&
+			        is_param(tok = next_token(line, c1, c2)))
+				print_formatted("Copyright: " + eval_param(tok));
+		}
+
+		for (uint i = 0; i < gb->data.size(); i ++) {
+			line = gb->data[i];
+			// SENSITIVE?
+			if (first_token(line, c1, c2) == "game" &&
+			        next_token(line, c1, c2) == "info" &&
+			        is_param(tok = next_token(line, c1, c2)))
+				print_formatted(eval_param(tok));
+		}
+
+		return true;
+	}
+
+	if (ci_equal(cmd, "quit")) {
+		is_running_ = false;
+		return true;
+	}
+
+	return false;
+}
+
+void geas_implementation::run_script_as(String obj, String scr) {
+	String backup_object, garbage;
+	backup_object = this_object;
+	this_object = obj;
+	run_script(scr, garbage);
+	this_object = backup_object;
+}
+
+void geas_implementation::run_script(String s) {
+	String garbage;
+	run_script(s, garbage);
+}
+
+void geas_implementation::run_script(String s, String &rv) {
+	//print_formatted ("     Running script " + s + ".");
+	cerr << "Script line '" << s << "'\n";
+	String tok;
+	uint c1, c2;
+
+	tok = first_token(s, c1, c2);
+
+	if (tok == "") return;
+
+	if (tok[0] == '{') {
+		uint brace1 = c1 + 1, brace2;
+		for (brace2 = s.length() - 1; brace2 >= brace1 && s[brace2] != '}'; brace2 --)
+			;
+		if (brace2 >= brace1)
+			run_script(s.substr(brace1, brace2 - brace1));
+		else
+			gi->debug_print("Unterminated brace block in " + s);
+		return;
+	}
+
+	// SENSITIVE?
+	if (tok == "action") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after action in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		int index = tok.find(';');
+		if (index == -1) {
+			gi->debug_print("Error: no semicolon in " + s);
+			return;
+		}
+		set_obj_action(trim(tok.substr(0, index)),
+		               "<" + trim(tok.substr(index + 1)) + "> " + s.substr(c2 + 1));
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "animate") {
+	}
+	// SENSITIVE?
+	else if (tok == "background") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			gi->set_background(eval_param(tok));
+		else
+			gi->debug_print("Expected parameter after foreground in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "choose") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after choose in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		const GeasBlock *gb = gf.find_by_name("selection", tok);
+		if (gb == NULL) {
+			gi->debug_print("No selection called " + tok + " found");
+			return;
+		}
+		String question, line;
+		Common::Array<String> choices, actions;
+		for (uint ln = 0; ln < gb->data.size(); ln ++) {
+			line = gb->data[ln];
+			tok = first_token(line, c1, c2);
+			// SENSITIVE?
+			if (tok == "info") {
+				tok = next_token(line, c1, c2);
+				if (is_param(tok))
+					question = eval_param(tok);
+				else
+					gi->debug_print("Expected parameter after info in " + line);
+			}
+			// SENSITIVE?
+			else if (tok == "choice") {
+				tok = next_token(line, c1, c2);
+				if (is_param(tok)) {
+					choices.push_back(eval_param(tok));
+					actions.push_back(line.substr(c2));
+				} else
+					gi->debug_print("Expected parameter after choice in " + line);
+			} else
+				gi->debug_print("Bad line " + line + " in selection");
+		}
+		if (choices.size() == 0)
+			//gi->debug_print ("No choices in selection " + gb->lname);
+			gi->debug_print("No choices in selection " + gb->name);
+		else
+			run_script(actions[gi->make_choice(question, choices)]);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "clear") {
+		gi->clear_screen();
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "clone") {
+		/* TODO */
+	}
+	// SENSITIVE?
+	else if (tok == "create") {
+		tok = next_token(s, c1, c2);
+		// SENSITIVE?
+		if (tok == "exit") { // create exit
+			String dir = "";
+
+			tok = next_token(s, c1, c2);
+			if (!is_param(tok)) {
+				dir = tok;
+				tok = next_token(s, c1, c2);
+			}
+
+			if (!is_param(tok)) {
+				gi->debug_print("Expected param after create exit in " + s);
+				return;
+			}
+			tok = eval_param(tok);
+			Common::Array<String> args = split_param(tok);
+			if (args.size() != 2) {
+				gi->debug_print("Expected 2 elements in param in " + s);
+				return;
+			}
+			if (dir != "")
+				state.exits.push_back(ExitRecord(args[0],
+				                                 "exit " + dir + " <" + tok + ">"));
+			else
+				state.exits.push_back(ExitRecord(args[0], "exit <" + tok + ">"));
+			//gi->debug_print ("Not yet able to create place type exits");
+			regen_var_dirs();
+			return;
+		}
+		// SENSITIVE?
+		else if (tok == "object") { // create object
+			/* TODO */
+		}
+		// SENSITIVE?
+		else if (tok == "room") { // create room
+			/* TODO */
+		} else
+			gi->debug_print("Bad create line " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "debug") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			gi->debug_print(eval_param(tok));
+		else
+			gi->debug_print("Expected param after debug in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "destroy") {
+		tok = next_token(s, c1, c2);
+		if (tok != "exit") {
+			gi->debug_print("expected 'exit' after 'destroy' in " + s);
+			return;
+		}
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected param after 'destroy exit' in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		Common::Array<String> args = split_param(tok);
+		if (args.size() != 2) {
+			gi->debug_print("Expected two arguments in " + s);
+			return;
+		}
+		//state.exits.push_back (ExitRecord (args[0], "destroy exit <" + tok + ">"));
+		state.exits.push_back(ExitRecord(args[0], "destroy exit " + args[1]));
+		regen_var_dirs();
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "disconnect") {
+		/* QNSO */
+	}
+	// SENSITIVE?
+	else if (tok == "displaytext") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after displaytext in " + s);
+			return;
+		}
+		const GeasBlock *gb = gf.find_by_name("text", param_contents(tok));
+		if (gb != NULL) {
+			for (uint i = 0; i < gb->data.size(); i ++) {
+				print_formatted(gb->data[i]);
+				print_newline();
+			}
+		} else
+			gi->debug_print("No such text block " + tok);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "do") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after do in " + s);
+			return;
+		}
+		String fname = eval_param(tok);
+		int index = fname.find('(');
+		if (index != -1) {
+			int index2 = fname.find(')');
+			run_procedure(trim(fname.substr(0, index)),
+			              split_f_args(fname.substr(index + 1, index2 - index - 1)));
+		} else
+			run_procedure(fname);
+
+		//run_procedure (fname);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "doaction") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after doaction in " + s);
+			return;
+		}
+		String line = eval_param(tok);
+		int index = line.find(';');
+		String obj = trim(line.substr(0, index));
+		String act = trim(line.substr(index + 1));
+		String old_object = this_object;
+		this_object = obj;
+		if (get_obj_action(obj, act, tok))
+			run_script_as(obj, tok);
+		//run_script (tok);
+		else
+			gi->debug_print("No action defined for " + obj + " // " + act);
+		this_object = old_object;
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "dontprocess") {
+		dont_process = true;
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "enter") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after enter in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		set_svar(tok, gi->get_string());
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "exec") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after exec in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		int index = tok.find(';');
+		if (index != -1) {
+			String tmp = trim(tok.substr(index + 1));
+			// SENSITIVE?
+			if (tmp == "normal") {
+				//run_command (trim (tok.substr (0, index)), true, true);
+				try_match(trim(tok.substr(0, index)), true, true);
+			} else {
+				gi->debug_print("Bad " + tmp + " in exec in " + s);
+				//run_command (trim (tok.substr (0, index)), true, false);
+				try_match(trim(tok.substr(0, index)), true, false);
+			}
+		} else {
+			//run_command (trim (tok.substr (0, index)), true, false);
+			try_match(trim(tok.substr(0, index)), true, false);
+		}
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "flag") {
+		tok = next_token(s, c1, c2);
+		bool is_on;
+		// SENSITIVE?
+		if (tok == "on")
+			is_on = true;
+		// SENSITIVE?
+		else if (tok == "off")
+			is_on = false;
+		else {
+			gi->debug_print("Expected 'on' or 'off' after flag in " + s);
+			return;
+		}
+		String onoff = tok;
+
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			set_obj_property("game", (is_on ? "" : "not ") + eval_param(tok));
+		else
+			gi->debug_print("Expected param after flag " + onoff + " in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "font") {
+		/* TODO */
+	}
+	// SENSITIVE?
+	else if (tok == "for") {
+		tok = next_token(s, c1, c2);
+		// SENSITIVE?
+		if (tok == "each") {
+			// SENSITIVE?
+			if (next_token(s, c1, c2) == "object" &&
+			        next_token(s, c1, c2) == "in") {
+				tok = next_token(s, c1, c2);
+				// SENSITIVE?
+				if (tok == "game") {
+					/* TODO: This will run over the game, rooms, and objects */
+					/* It should just do the objects. */
+					String script = s.substr(c2);
+					// Start at 1 to skip game
+					for (uint i = 1; i < state.objs.size(); i ++) {
+						cerr << "  quest.thing -> " + state.objs[i].name + "\n";
+						set_svar("quest.thing", state.objs[i].name);
+						run_script(script);
+					}
+					return;
+				} else if (is_param(tok)) {
+					tok = trim(eval_param(tok));
+					String script = s.substr(c2);
+					for (uint i = 0; i < state.objs.size(); i ++)
+						if (state.objs[i].parent == tok) {
+							set_svar("quest.thing", state.objs[i].name);
+							run_script(script);
+						}
+					return;
+				}
+			}
+		} else if (is_param(tok)) {
+			Common::Array<String> args = split_param(eval_param(tok));
+			String varname = args[0];
+			String script = s.substr(c2);
+			int startindex = parse_int(args[1]);
+			int endindex = parse_int(args[2]);
+			int step = 1;
+			if (args.size() > 3)
+				step = parse_int(args[3]);
+			for (set_ivar(varname, startindex); get_ivar(varname) < endindex;
+			        set_ivar(varname, get_ivar(varname) + step))
+				run_script(script);
+			return;
+		}
+
+	}
+	// SENSITIVE?
+	else if (tok == "foreground") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			gi->set_foreground(eval_param(tok));
+		else
+			gi->debug_print("Expected parameter after foreground in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "give") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after give in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		move(tok, "inventory");
+		String tmp;
+		if (get_obj_action(tok, "gain", tmp))
+			run_script_as(tok, tmp);
+		//run_script (tmp);
+		else if (get_obj_property(tok, "gain", tmp))
+			print_formatted(tmp);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "goto") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			goto_room(trim(eval_param(tok)));
+		else
+			gi->debug_print("Expected parameter after goto in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "helpclear") {
+	}
+	// SENSITIVE?
+	else if (tok == "helpclose") {
+	}
+	// SENSITIVE?
+	else if (tok == "helpdisplaytext") {
+	}
+	// SENSITIVE?
+	else if (tok == "helpmsg") {
+	}
+	// SENSITIVE?
+	else if (tok == "hide") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			set_obj_property(eval_param(tok), "hidden");
+		else
+			gi->debug_print("Expected param after conceal in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "show") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			set_obj_property(eval_param(tok), "not hidden");
+		else
+			gi->debug_print("Expected param after conceal in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "if") {
+		/* TODO TODO */
+		uint begin_cond = c2 + 1, end_cond, begin_then, end_then;
+
+		do {
+			tok = next_token(s, c1, c2);
+			// SENSITIVE?
+		} while (tok != "then" && tok != "");
+
+		if (tok == "") {
+			gi->debug_print("Expected then in if: " + s);
+			return;
+		}
+		end_cond = c1;
+		String cond_str = s.substr(begin_cond, end_cond - begin_cond);
+
+		begin_then = c2 + 1;
+		int brace_count = 0;
+		do {
+			tok = next_token(s, c1, c2);
+			for (uint i = 0; i < tok.length(); i ++)
+				if (tok[i] == '{')
+					brace_count ++;
+				else if (tok[i] == '}')
+					brace_count --;
+			// SENSITIVE?
+		} while (tok != "" && !(brace_count == 0 && tok == "else"));
+		end_then = c1;
+
+
+		if (eval_conds(cond_str))
+			run_script(s.substr(begin_then, end_then - begin_then), rv);
+		else if (c2 < s.length())
+			run_script(s.substr(c2), rv);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "inc" || tok == "dec") {
+		// SENSITIVE?
+		bool is_dec = (tok == "dec");
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after inc in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		int diff;
+		int index = tok.find(';');
+		String varname;
+		if (index == -1) {
+			varname = trim(tok);
+			diff = 1;
+		} else {
+			varname = trim(tok.substr(0, index));
+			diff = eval_int(tok.substr(index + 1));
+		}
+		if (is_dec)
+			set_ivar(varname, get_ivar(varname) - diff);
+		else
+			set_ivar(varname, get_ivar(varname) + diff);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "lose") {
+		/* TODO TODO */
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after lose in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+
+		/* TODO: is the object always moved to location, or only
+		 * when it had been in the inventory ?
+		 */
+		bool was_lost = (ci_equal(get_obj_parent(tok), "inventory"));
+		if (was_lost) {
+			move(tok, state.location);
+			String tmp;
+			if (get_obj_action(tok, "lose", tmp))
+				run_script_as(tok, tmp);
+			//run_script (tmp);
+			else if (get_obj_property(tok, "lose", tmp))
+				print_formatted(tmp);
+		}
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "mailto") {
+	}
+	// SENSITIVE?
+	else if (tok == "modvolume") {
+	}
+	// SENSITIVE?
+	else if (tok == "move") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after move in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		int index = tok.find(';');
+		if (index == -1) {
+			gi->debug_print("No semi in " + tok + " in " + s);
+			return;
+		}
+		move(trim(tok.substr(0, index)), trim(tok.substr(index + 1)));
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "msg") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			print_eval(param_contents(tok));
+		else
+			gi->debug_print("Expected parameter after msg in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "msgto") {
+		/* QNSO */
+	}
+	// SENSITIVE?
+	else if (tok == "outputoff") {
+		//print_formatted ("<<");
+		outputting = false;
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "outputon") {
+		outputting = true;
+		//print_formatted (">>");
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "panes") {
+		/* TODO */
+	}
+	// SENSITIVE?
+	else if (tok == "pause") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after pause in " + s);;
+			return;
+		}
+		int i = eval_int(param_contents(tok));
+		gi->pause(i);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "picture") {
+	}
+	// SENSITIVE?
+	else if (tok == "playerlose") {
+		run_script("displaytext <lose>");
+		state.running = false;
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "playerwin") {
+		run_script("displaytext <win>");
+		state.running = false;
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "playmidi") {
+	}
+	// SENSITIVE?
+	else if (tok == "playmod") {
+	}
+	// SENSITIVE?
+	else if (tok == "playwav") {
+	}
+	// SENSITIVE?
+	else if (tok == "property") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter in '" + s + "'");
+			return;
+		}
+		Common::Array<String> args = split_param(eval_param(tok));
+		for (uint i = 1; i < args.size(); i ++) {
+			String val = args[i];
+			/*
+			if (val[0] == '[' && val[val.length() - 1] == ']')
+			  val = val.substr (1, val.length() - 2);
+			//state.props.push_back (PropertyRecord (args[0], val));
+			*/
+			val = trim_braces(val);
+			set_obj_property(args[0], val);
+		}
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "repeat") {
+		/* TODO TODO: assumes script is a "do ..." */
+		tok = next_token(s, c1, c2);
+		// SENSITIVE?
+		if (tok != "while" && tok != "until") {
+			gi->debug_print("Expected while or until after repeat in " + s);
+			return;
+		}
+		bool is_while = (tok == "while");
+		uint start_cond = c2, end_cond = (uint) -1;
+		while ((tok = next_token(s, c1, c2)) != "") {
+			// SENSITIVE?
+			if (tok == "do") {
+				end_cond = c1;
+				break; // TODO: Do I break here?
+			}
+		}
+		if (end_cond == -1) {
+			gi->debug_print("No script found after condition in " + s);
+			return;
+		}
+		String cond = trim(s.substr(start_cond, end_cond - start_cond));
+		String script = trim(s.substr(end_cond));
+		cerr << "Interpreting '" << s << "' as ("
+		     << (is_while ? "WHILE" : "UNTIL") << ") ("
+		     << cond << ") {" << script << "}\n";
+		while (eval_conds(cond) == is_while)
+			run_script(script);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "return") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			rv = eval_param(tok);
+		else
+			gi->debug_print("Expected parameter after return in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "reveal") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			set_obj_property(eval_param(tok), "not invisible");
+		else
+			gi->debug_print("Expected param after reveal in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "conceal") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			set_obj_property(eval_param(tok), "invisible");
+		else
+			gi->debug_print("Expected param after conceal in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "say") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok)) {
+			tok = eval_param(tok);
+			print_formatted("\"" + tok + "\"");
+		} else
+			gi->debug_print("Expected param after say in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "set") {
+		String vartype = "";
+		tok = next_token(s, c1, c2);
+		// SENSITIVE?
+		if (tok == "interval") {
+			tok = next_token(s, c1, c2);
+			if (!is_param(tok)) {
+				gi->debug_print("Expected param after set interval in " + s);
+				return;
+			}
+			tok = eval_param(tok);
+			int index = tok.find(';');
+			if (index == -1) {
+				gi->debug_print("No semicolon in param in " + s);
+				return;
+			}
+			//String timer_name = lcase (trim (tok.substr (0, index)));
+			String timer_name = trim(tok.substr(0, index));
+			uint time_val = parse_int(trim(tok.substr(index + 1)));
+
+			for (uint i = 0; i < state.timers.size(); i ++)
+				if (state.timers[i].name == timer_name) {
+					state.timers[i].interval = time_val;
+					return;
+				}
+			gi->debug_print("no interval named " + timer_name + " found!");
+			return;
+		}
+		// SENSITIVE?
+		if (tok == "String" || tok == "numeric") {
+			vartype = tok;
+			tok = next_token(s, c1, c2);
+		}
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter in " + s);
+			return;
+		}
+		if (tok.find(';') == -1) {
+			gi->debug_print("Only one expression in set in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		int index = tok.find(';');
+		//String varname = lcase (trim (tok.substr (0, index)));
+		String varname = trim(tok.substr(0, index));
+		if (vartype == "") {
+			for (uint varn = 0; varn < state.ivars.size(); varn ++)
+				if (state.ivars[varn].name == varname) {
+					vartype = "numeric";
+					break;
+				}
+			if (vartype == "")
+				for (uint varn = 0; varn < state.svars.size(); varn ++)
+					if (state.svars[varn].name == varname) {
+						vartype = "String";
+						break;
+					}
+		}
+		if (vartype == "") {
+			gi->debug_print("Undefined variable " + varname + " in " + s);
+			return;
+		}
+		if (vartype == "String")
+			set_svar(varname, trim_braces(trim(tok.substr(index + 1))));
+		else
+			set_ivar(varname, eval_int(tok.substr(index + 1)));
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "setstring") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter in " + s);
+			return;
+		}
+		if (tok.find(';') == -1) {
+			gi->debug_print("Only one expression in set in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		int index = tok.find(';');
+		String varname = trim(tok.substr(0, index));
+		set_svar(varname, trim_braces(trim(tok.substr(index + 1))));
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "setvar") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter in " + s);
+			return;
+		}
+		if (tok.find(';') == -1) {
+			gi->debug_print("Only one expression in set in " + s);
+			return;
+		}
+		tok = eval_param(tok);
+		int index = tok.find(';');
+		String varname = trim(tok.substr(0, index));
+		set_ivar(varname, eval_int(tok.substr(index + 1)));
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "shell") {
+
+	}
+	// SENSITIVE?
+	else if (tok == "shellexe") {
+	}
+	// SENSITIVE?
+	else if (tok == "speak") {
+		tok = next_token(s, c1, c2);
+		if (is_param(tok))
+			gi->speak(eval_param(tok));
+		else
+			gi->debug_print("Expected param after speak in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "stop") {
+		state.running = false;
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "timeron" || tok == "timeroff") {
+		// SENSITIVE?
+		bool running = (tok == "timeron");
+		//tok = lcase (next_token (s, c1, c2));
+		tok = next_token(s, c1, c2);
+		if (is_param(tok)) {
+			tok = eval_param(tok);
+			for (uint i = 0; i < state.timers.size(); i ++)
+				if (state.timers[i].name == tok) {
+					if (running)
+						state.timers[i].timeleft = state.timers[i].interval;
+					state.timers[i].is_running = running;
+					return;
+				}
+			gi->debug_print("No timer " + tok + " found");
+			return;
+		}
+		gi->debug_print(String("Expected parameter after timer") +
+		                (running ? "on" : "off") + " in " + s);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "type") {
+		/* TODO */
+	}
+	// SENSITIVE?
+	else if (tok == "wait") {
+		tok = next_token(s, c1, c2);
+		if (tok != "") {
+			if (!is_param(tok)) {
+				gi->debug_print("Expected parameter after wait in " + s);
+				return;
+			}
+			tok = eval_param(tok);
+		}
+		gi->wait_keypress(tok);
+		return;
+	}
+	// SENSITIVE?
+	else if (tok == "with") {
+		// QNSO
+	}
+	gi->debug_print("Unrecognized script " + s);
+}
+
+bool geas_implementation::eval_conds(String s) {
+	cerr << "if (" + s + ")" << endl;
+
+	uint c1, c2;
+	String tok = first_token(s, c1, c2);
+
+	if (tok == "") return true;
+
+	bool rv = eval_cond(s);
+
+	while (tok != "" && tok != "and")
+		tok = next_token(s, c1, c2);
+
+	if (tok == "and")
+		rv = rv && eval_conds(s.substr(c2));
+	else {
+		tok = first_token(s, c1, c2);
+		while (tok != "" && tok != "or")
+			tok = next_token(s, c1, c2);
+		if (tok == "or")
+			rv = rv || eval_conds(s.substr(c2));
+	}
+
+	cerr << "if (" << s << ") --> " << (rv ? "true" : "false") << endl;
+	return rv;
+}
+
+bool geas_implementation::eval_cond(String s) {
+	uint c1, c2;
+	String tok = first_token(s, c1, c2);
+	// SENSITIVE?
+	if (tok == "not")
+		return !eval_cond(s.substr(c2));
+	// SENSITIVE?
+	else if (tok == "action") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("expected parameter after property in " + s);
+			return false;
+		}
+		tok = eval_param(tok);
+		int index = tok.find(';');
+		if (index == -1) {
+			gi->debug_print("Only one argument to property in " + s);
+			return false;
+		}
+		String obj = trim(tok.substr(0, index));
+		String act = trim(tok.substr(index + 1));
+		return has_obj_action(obj, act);
+	}
+	// SENSITIVE?
+	else if (tok == "ask") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("expected parameter after ask in " + s);
+			return false;
+		}
+		tok = eval_param(tok);
+		return gi->choose_yes_no(tok);
+	}
+	// SENSITIVE?
+	else if (tok == "exists") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("expected parameter after exists in " + s);
+			return false;
+		}
+		Common::Array<String> args = split_param(eval_param(tok));
+		bool do_report = false;
+		for (uint i = 1; i < args.size(); i ++)
+			// SENSITIVE?
+			if (args[i] == "report")
+				do_report = true;
+			else
+				gi->debug_print("Got modifier " + args[i] + " after exists");
+		//args[0] = lcase (args[0]);
+		for (uint i = 0; i < state.objs.size(); i ++)
+			if (ci_equal(state.objs[i].name, args[0]))
+				return state.objs[i].parent != "";
+		if (do_report)
+			gi->debug_print("exists " + args[0] + " failed due to nonexistence");
+		return false;
+	}
+	// SENSITIVE?
+	else if (tok == "flag") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("expected parameter after flag in " + s);
+			return false;
+		}
+		tok = trim(eval_param(tok));
+		return has_obj_property("game", tok);
+	}
+	// SENSITIVE?
+	else if (tok == "got") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("expected parameter after got in " + s);
+			return false;
+		}
+		//tok = lcase (trim (eval_param (tok)));
+		tok = trim(eval_param(tok));
+		for (uint i = 0; i < state.objs.size(); i ++)
+			if (ci_equal(state.objs[i].name, tok))
+				return ci_equal(state.objs[i].parent, "inventory");
+		gi->debug_print("No object " + tok + " found while evaling " + s);
+		return false;
+	}
+	// SENSITIVE?
+	else if (tok == "here") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("expected parameter after here in " + s);
+			return false;
+		}
+		//tok = lcase (trim (eval_param (tok)));
+		tok = trim(eval_param(tok));
+		for (uint i = 0; i < state.objs.size(); i ++)
+			if (ci_equal(state.objs[i].name, tok)) {
+				//return (ci_equal (state.objs[i].parent, state.location) &&
+				//    !has_obj_property (tok, "invisible"));
+				return (ci_equal(state.objs[i].parent, state.location));
+			}
+		/* TODO: is it invisible or hidden? */
+		gi->debug_print("No object " + tok + " found while evaling " + s);
+		return false;
+	}
+	// SENSITIVE?
+	else if (tok == "is") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("expected parameter after is in " + s);
+			return false;
+		}
+		tok = eval_param(tok);
+		int index;
+		// SENSITIVE?
+		if ((index = tok.find("!=;")) != -1) {
+			uint index1 = index;
+			do {
+				-- index1;
+			} while (index1 > 0 && tok[index1] != ';');
+
+			cerr << "Comparing <" << trim_braces(trim(tok.substr(0, index1)))
+			     << "> != <" << trim_braces(trim(tok.substr(index + 3)))
+			     << ">\n";
+			return ci_notequal(trim_braces(trim(tok.substr(0, index - 1))),
+			                   trim_braces(trim(tok.substr(index + 3))));
+		}
+		if ((index = tok.find("lt=;")) != -1) {
+			cerr << "Comparing <" << trim_braces(trim(tok.substr(0, index)))
+			     << "> < <" << trim_braces(trim(tok.substr(index + 4)))
+			     << ">\n";
+			return eval_int(tok.substr(0, index - 1))
+			       <= eval_int(tok.substr(index + 4));
+		}
+		if ((index = tok.find("gt=;")) != -1)
+			return eval_int(tok.substr(0, index))
+			       >= eval_int(tok.substr(index + 4));
+		if ((index = tok.find("lt;")) != -1)
+			return eval_int(tok.substr(0, index))
+			       < eval_int(tok.substr(index + 3));
+		if ((index = tok.find("gt;")) != -1)
+			return eval_int(tok.substr(0, index))
+			       > eval_int(tok.substr(index + 3));
+		if ((index = tok.find(";")) != -1) {
+			cerr << "Comparing <" << trim_braces(trim(tok.substr(0, index)))
+			     << "> == <" << trim_braces(trim(tok.substr(index + 1)))
+			     << ">\n";
+			return ci_equal(trim_braces(trim(tok.substr(0, index))),
+			                trim_braces(trim(tok.substr(index + 1))));
+		}
+		gi->debug_print("Bad is condition " + tok + " in " + s);
+		return false;
+	}
+	// SENSITIVE?
+	else if (tok == "property") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("expected parameter after property in " + s);
+			return false;
+		}
+		tok = eval_param(tok);
+		int index = tok.find(';');
+		if (index == -1) {
+			gi->debug_print("Only one argument to property in " + s);
+			return false;
+		}
+		String obj = trim(tok.substr(0, index));
+		String prop = trim(tok.substr(index + 1));
+		return has_obj_property(obj, prop);
+	}
+	// SENSITIVE?
+	else if (tok == "real") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("expected parameter after real in " + s);
+			return false;
+		}
+		Common::Array<String> args = split_param(eval_param(tok));
+		bool do_report = false;
+		for (uint i = 1; i < args.size(); i ++)
+			// SENSITIVE?
+			if (args[i] == "report")
+				do_report = true;
+			else
+				gi->debug_print("Got modifier " + args[i] + " after exists");
+		//args[0] = lcase (args[0]);
+		for (uint i = 0; i < state.objs.size(); i ++)
+			if (ci_equal(state.objs[i].name, args[0]))
+				return true;
+		if (do_report)
+			gi->debug_print("real " + args[0] + " failed due to nonexistence");
+		return false;
+	}
+	// SENSITIVE?
+	else if (tok == "type") {
+		tok = next_token(s, c1, c2);
+		if (!is_param(tok)) {
+			gi->debug_print("Expected parameter after type in " + s);
+			return false;
+		}
+		Common::Array<String> args = split_param(eval_param(tok));
+		if (args.size() != 2) {
+			gi->debug_print("Expected two parameters to type in " + s);
+			return false;
+		}
+		return gf.obj_of_type(args[0], args[1]);
+	}
+
+	gi->debug_print("Bad condition " + s);
+	return false;
+}
+
+void geas_implementation::run_procedure(String pname, Common::Array<String> args) {
+	cerr << "run_procedure " << pname << " (" << args << ")\n";
+	Common::Array<String> backup = function_args;
+	function_args = args;
+	run_procedure(pname);
+	function_args = backup;
+}
+
+void geas_implementation::run_procedure(String pname) {
+	for (uint i = 0; i < gf.size("procedure"); i ++)
+		if (ci_equal(gf.block("procedure", i).name, pname)) {
+			const GeasBlock &proc = gf.block("procedure", i);
+			//cerr << "Running procedure " << proc << endl;
+			for (uint j = 0; j < proc.data.size(); j ++) {
+				//cerr << "  Running line #" << j << ": " << proc.data[j] << endl;
+				run_script(proc.data[j]);
+			}
+			return;
+		}
+	gi->debug_print("No procedure " + pname + " found.");
+}
+
+String geas_implementation::run_function(String pname, Common::Array<String> args) {
+	cerr << "run_function (w/ args) " << pname << " (" << args << ")\n";
+	/* Parameter is handled specially because it can't change the stack */
+	// SENSITIVE?
+	if (pname == "parameter") {
+		if (args.size() != 1) {
+			gi->debug_print("parameter called with " + string_int(args.size())
+			                + " args");
+			return "";
+		}
+		uint num = parse_int(args[0]);
+		if (0 < num && num <= function_args.size()) {
+			cerr << "   --> " << function_args[num - 1] << "\n";
+			return function_args[num - 1];
+		}
+		cerr << "   --> too many arguments\n";
+		return "";
+	}
+	Common::Array<String> backup = function_args;
+	function_args = args;
+	for (uint i = 0; i < args.size(); i ++)
+		set_svar("quest.function.parameter." + string_int(i + 1), args[i]);
+	String rv = run_function(pname);
+	function_args = backup;
+	return rv;
+}
+
+String geas_implementation::bad_arg_count(String fname) {
+	gi->debug_print("Called " + fname + " with " +
+	                string_int(function_args.size()) + " arguments.");
+	return "";
+}
+
+String geas_implementation::run_function(String pname) {
+	cerr << "geas_implementation::run_function (" << pname << ", " << function_args << ")\n";
+	//pname = lcase (pname);
+	// SENSITIVE?
+	if (pname == "getobjectname") {
+		if (function_args.size() == 0)
+			return bad_arg_count(pname);
+		//return get_obj_name (function_args);
+		Common::Array<String> where;
+		for (uint i = 1; i < function_args.size(); i ++)
+			where.push_back(function_args[i]);
+		if (where.size() == 0) {
+			where.push_back(state.location);
+			where.push_back("inventory");
+		}
+		bool is_internal = false;
+		return get_obj_name(function_args[0], where, is_internal);
+	}
+	// SENSITIVE?
+	else if (pname == "loadmethod") {
+		/* TODO TODO */
+		return "normal";
+		// "loaded" on restore from qsg
+	}
+	// SENSITIVE?
+	else if (pname == "locationof") {
+		if (function_args.size() != 1)
+			return bad_arg_count(pname);
+
+		return get_obj_parent(function_args[0]);
+	}
+	// SENSITIVE?
+	else if (pname == "objectproperty") {
+		if (function_args.size() != 2)
+			return bad_arg_count(pname);
+
+		String rv;
+		get_obj_property(function_args[0], function_args[1], rv);
+		return rv;
+	}
+	// SENSITIVE?
+	else if (pname == "timerstate") {
+		if (function_args.size() != 1)
+			return bad_arg_count(pname);
+
+		//String timername = lcase (function_args[0]);
+		String timername = function_args[0];
+		for (uint i = 0; i < state.timers.size(); i ++)
+			if (state.timers[i].name == timername)
+				return state.timers[i].is_running ? "1" : "0";
+		return "!";
+	}
+	// SENSITIVE?
+	else if (pname == "displayname") {
+		if (function_args.size() != 1)
+			return bad_arg_count(pname);
+
+		return displayed_name(function_args[0]);
+	}
+	// SENSITIVE?
+	else if (pname == "capfirst") {
+		if (function_args.size() != 1)
+			return bad_arg_count(pname);
+
+		return pcase(function_args[0]);
+	}
+	// SENSITIVE?
+	else if (pname == "instr") {
+		/* TODO What if it's not present? */
+		if (function_args.size() != 2 && function_args.size() != 3)
+			return bad_arg_count(pname);
+
+		int rv;
+		if (function_args.size() == 2)
+			rv = function_args[0].find(function_args[1]);
+		else
+			rv = function_args[1].find(function_args[2],
+			                           parse_int(function_args[0]));
+
+		if (rv == -1)
+			return string_int(rv); // TODO What goes here?
+		else
+			return string_int(rv);
+	}
+	// SENSITIVE?
+	else if (pname == "lcase") {
+		if (function_args.size() != 1)
+			return bad_arg_count(pname);
+
+		String rv = function_args[0];
+		for (uint i = 0; i < rv.size(); i ++)
+			rv[i] = tolower(rv[i]);
+		return rv;
+	}
+	// SENSITIVE?
+	else if (pname == "left") {
+		if (function_args.size() != 2)
+			return bad_arg_count(pname);
+
+		uint i = parse_int(function_args[1]);
+		if (i > function_args[0].length())
+			return function_args[0];
+		else
+			return function_args[0].substr(0, i);
+	}
+	// SENSITIVE?
+	else if (pname == "lengthof") {
+		if (function_args.size() != 1)
+			return bad_arg_count(pname);
+
+		return string_int(function_args[0].length());
+	}
+	// SENSITIVE?
+	else if (pname == "mid") {
+		if (function_args.size() != 3)
+			return bad_arg_count(pname);
+
+		uint start = parse_int(function_args[1]),
+		     len = parse_int(function_args[2]);
+		if (start > function_args[0].length())
+			return "";
+		if (start + len > function_args[0].length())
+			return function_args[0].substr(start);
+		return function_args[0].substr(start, len);
+	}
+	// SENSITIVE?
+	else if (pname == "right") {
+		if (function_args.size() != 2)
+			return bad_arg_count(pname);
+
+		uint size = parse_int(function_args[1]);
+		if (size > function_args[0].length())
+			return function_args[0];
+		return function_args[0].substr(function_args[0].length() - size);
+	} else if (pname == "ubound") {
+		if (function_args.size() != 1)
+			return bad_arg_count(pname);
+
+		/* TODO TODO */
+		return "";
+	}
+	// SENSITIVE?
+	else if (pname == "ucase") {
+		if (function_args.size() != 1)
+			return bad_arg_count(pname);
+
+		String rv = function_args[0];
+		for (uint i = 0; i < rv.length(); i ++)
+			rv[i] = toupper(rv[i]);
+		return rv;
+	}
+	// SENSITIVE?
+	else if (pname == "rand") {
+		if (function_args.size() != 2)
+			return bad_arg_count(pname);
+		uint lower = parse_int(function_args[0]),
+		     upper = parse_int(function_args[1]);
+
+		// TODO: change this to use the high order bits of the random # instead
+		return string_int(lower + (g_vm->getRandomNumber(0x7fffff) % (upper + 1 - lower)));
+	}
+	// SENSITIVE?
+	else if (pname == "speechenabled") {
+		if (function_args.size() != 0)
+			return bad_arg_count(pname);
+
+		return "0";
+		/* TODO: return 1 if speech is enabled */
+	}
+	// SENSITIVE?
+	else if (pname == "symbol") {
+		if (function_args.size() != 1)
+			return bad_arg_count(pname);
+
+		// SENSITIVE?
+		if (function_args[0] == "gt")
+			return ">";
+		// SENSITIVE?
+		else if (function_args[0] == "lt")
+			return "<";
+		gi->debug_print("Bad symbol argument: " + function_args[0]);
+		return "";
+	}
+	// SENSITIVE?
+	else if (pname == "numberparameters")
+		return string_int(function_args.size());
+	// SENSITIVE?
+	else if (pname == "thisobject")
+		return this_object;
+
+	/* disconnectedby, id, name, removeformatting */
+
+	String rv = "";
+
+	for (uint i = 0; i < gf.size("function"); i ++)
+		if (ci_equal(gf.block("function", i).name, pname)) {
+			const GeasBlock &proc = gf.block("function", i);
+			cerr << "Running function " << proc << endl;
+			for (uint j = 0; j < proc.data.size(); j ++) {
+				cerr << "  Running line #" << j << ": " << proc.data[j] << endl;
+				run_script(proc.data[j], rv);
+			}
+			return rv;
+		}
+	gi->debug_print("No function " + pname + " found.");
+	return "";
+}
+
+
+
+v2string geas_implementation::get_inventory() {
+	return get_room_contents("inventory");
+}
+
+v2string geas_implementation::get_room_contents() {
+	return get_room_contents(state.location);
+}
+
+v2string geas_implementation::get_room_contents(String room) {
+	v2string rv;
+	String objname;
+	for (uint i = 0; i < state.objs.size(); i ++)
+		if (state.objs[i].parent == room) {
+			objname = state.objs[i].name;
+			if (!has_obj_property(objname, "invisible") &&
+			        !has_obj_property(objname, "hidden")) {
+				vstring tmp;
+
+				String print_name, temp_str;
+				if (!get_obj_property(objname, "alias", print_name))
+					print_name = objname;
+				/*
+				if (get_obj_property (objname, "prefix", temp_str))
+				  print_name = temp_str + " " + print_name;
+				if (get_obj_property (objname, "suffix", temp_str))
+				  print_name = print_name + " " + temp_str;
+				*/
+				tmp.push_back(print_name);
+
+				String otype;
+				if (!get_obj_property(objname, "displaytype", otype))
+					otype = "object";
+				tmp.push_back(otype);
+				rv.push_back(tmp);
+			}
+		}
+	return rv;
+}
+
+vstring geas_implementation::get_status_vars() {
+	vstring rv;
+
+	String tok, line;
+	uint c1, c2;
+
+	for (uint i = 0; i < gf.size("variable"); i ++) {
+		const GeasBlock &gb = gf.block("variable", i);
+
+		bool nozero = false;
+		String disp;
+		bool is_numeric = true;
+
+		cerr << "g_s_v: " << gb << endl;
+
+		for (uint j = 0; j < gb.data.size(); j ++) {
+			line = gb.data[j];
+			cerr << "  g_s_v:  " << line << endl;
+			tok = first_token(line, c1, c2);
+			// SENSITIVE?
+			if (tok == "display") {
+				tok = next_token(line, c1, c2);
+
+				// SENSITIVE?
+				if (tok == "nozero") {
+					nozero = true;
+					tok = next_token(line, c1, c2);
+				}
+				if (!is_param(tok))
+					gi->debug_print("Expected param after display: " + line);
+				else
+					disp = tok;
+			}
+			// SENSITIVE?
+			else if (tok == "type") {
+				tok = next_token(line, c1, c2);
+				// SENSITIVE?
+				if (tok == "String")
+					is_numeric = false;
+			}
+		}
+
+		cerr << "  g_s_v, block 2, tok == '" << tok << "'" << endl;
+		if (!(is_numeric && nozero && get_ivar(gb.name) == 0) && disp != "") {
+			disp = param_contents(disp);
+			String outval = "";
+			for (uint j = 0; j < disp.length(); j ++)
+				if (disp[j] == '!') {
+					if (is_numeric)
+						outval = outval + string_int(get_ivar(gb.name));
+					//outval = outval + string_int (get_ivar (gb.lname));
+					else
+						outval = outval + get_svar(gb.name);
+					//outval = outval + get_svar (gb.lname);
+				} else if (disp[j] == '*') {
+					uint k;
+					for (k = j + 1; k < disp.length() && disp[k] != '*'; k ++)
+						;
+					//if (!is_numeric || get_ivar (gb.lname) != 1)
+					if (!is_numeric || get_ivar(gb.name) != 1)
+						outval = outval + disp.substr(j + 1, k - j - 1);
+					j = k;
+				} else
+					outval = outval + disp[j];
+			rv.push_back(eval_string(outval));
+		}
+	}
+	return rv;
+}
+
+Common::Array<bool> geas_implementation::get_valid_exits() {
+	Common::Array<bool> rv;
+	cerr << "Getting valid exits\n";
+	rv.push_back(exit_dest(state.location, "northwest") != "");
+	rv.push_back(exit_dest(state.location, "north") != "");
+	rv.push_back(exit_dest(state.location, "northeast") != "");
+	rv.push_back(exit_dest(state.location, "west") != "");
+	rv.push_back(exit_dest(state.location, "out") != "");
+	rv.push_back(exit_dest(state.location, "east") != "");
+	rv.push_back(exit_dest(state.location, "southwest") != "");
+	rv.push_back(exit_dest(state.location, "south") != "");
+	rv.push_back(exit_dest(state.location, "southeast") != "");
+	rv.push_back(exit_dest(state.location, "up") != "");
+	rv.push_back(exit_dest(state.location, "down") != "");
+	cerr << "Done getting valid exits\n";
+
+	return rv;
+}
+
+void geas_implementation::print_eval_p(String s) {
+	print_formatted(pcase(eval_string(s)));
+}
+
+void geas_implementation::print_eval(String s) {
+	print_formatted(eval_string(s));
+}
+
+String geas_implementation::eval_string(String s) {
+	String rv;
+	uint i, j;
+	bool do_print = (s.find('$') != -1);
+	if (do_print) cerr << "eval_string (" << s << ")\n";
+	for (i = 0; i < s.length(); i ++) {
+		//if (do_print) cerr << "e_s: i == " << i << ", s[i] == '" << s[i] << "'\n";
+		if (i + 1 < s.length() && s[i] == '#' && s[i + 1] == '@') {
+			for (j = i + 1; j < s.length() && s[j] != '#'; j ++)
+				;
+			if (j == s.length()) {
+				gi->debug_print("eval_string: Unmatched hash in " + s);
+				break;
+			}
+			//cerr << "dereferencing " + s.substr (i+2, j-i-2) << endl;
+			rv = rv + displayed_name(get_svar(s.substr(i + 2, j - i - 2)));
+			i = j;
+		} else if (s[i] == '#') {
+			for (j = i + 1; j < s.length() && s[j] != '#'; j ++)
+				;
+			if (j == s.length()) {
+				gi->debug_print("eval_string: Unmatched hash in " + s);
+				break;
+			}
+			uint k;
+			for (k = i + 1; k < j && s[k] != ':'; k ++)
+				;
+			if (k == j && j == i + 1)
+				rv += "#";
+			else if (k == j)
+				rv += get_svar(s.substr(i + 1, j - i - 1));
+			else {
+				String propname = s.substr(k + 1, j - k - 1);
+				if (s[i + 1] == '(') {
+					if (s[k - 1] != ')') {
+						gi->debug_print("e_s: Missing paren in '" +
+						                s.substr(i, j - i) + "' of '" + s + "'");
+						break;
+					}
+					String objvar = s.substr(i + 2, k - i - 3);
+					String objname = get_svar(objvar);
+					/*
+					cerr << "e_s: Getting prop [(" << objvar << ")] --> ["
+					     << objname
+					     << "]:[" << propname << "] for " << s << endl;
+					*/
+					String tmp;
+					if (get_obj_property(objname, propname, tmp))
+						rv += tmp;
+					else
+						gi->debug_print("e_s: Evaluating nonexistent object prop "
+						                "{" + objname + "}:{" + propname + "}");
+				} else {
+					String objname = s.substr(i + 1, k - i - 1);
+					/*
+					cerr << "e_s: Getting prop [" << objname << "]:["
+					     << propname << "] for " << s << endl;
+					*/
+					String tmp;
+					if (get_obj_property(objname, propname, tmp))
+						rv += tmp;
+					else
+						gi->debug_print("e_s: Evaluating nonexistent var " + objname);
+				}
+			}
+			i = j;
+		} else if (s[i] == '%') {
+			for (j = i + 1; j < s.length() && s[j] != '%'; j ++)
+				;
+			if (j == s.length()) {
+				gi->debug_print("e_s: Unmatched %s in " + s);
+				break;
+			}
+			//cerr << "e_s: Getting ivar [" << s.substr (i+1, j-i-1) << "] for " << s << endl;
+			if (j == i + 1)
+				rv += "%";
+			else
+				rv += string_int(get_ivar(s.substr(i + 1, j - i - 1)));
+			i = j;
+		} else if (s[i] == '$') {
+			j = s.find('$', i + 1);
+			/*
+			for (j = i + 1; j < s.length() && s[j] != '$'; j ++)
+			  {
+			    cerr << "  In searching for partner, j == " << j
+			   << ", s[j] == '" << s[j] << "', (s[j] == '$') == "
+			   << ((s[j] == '$') ? "true" : "false") << "\n";
+			  }
+			*/
+			//if (j == rv.size())
+			if (j == -1) {
+				gi->debug_print("Unmatched $s in " + s);
+				return rv + s.substr(i);
+			}
+			String tmp1 = s.substr(i + 1, j - i - 1);
+			cerr << "e_s: first substr was '" << tmp1 << "'\n";
+			String tmp = eval_string(tmp1);
+			//String tmp = eval_string (s.substr (i + 1, j - i - 2));
+			//cerr << "Taking substring of '" + s + "': '" + tmp + "'\n";
+			cerr << "e_s: eval substr " + s + "': '" + tmp + "'\n";
+
+			String func_eval;
+
+			int paren_open, paren_close;
+			if ((paren_open = tmp.find('(')) == -1)
+				func_eval = run_function(tmp);
+			else {
+				paren_close = tmp.find(')', paren_open);
+				if (paren_close == -1)
+					gi->debug_print("No matching right paren in " + tmp);
+				else {
+					String f_name = tmp.substr(0, paren_open);
+					String f_args = tmp.substr(paren_open + 1,
+					                           paren_close - paren_open - 1);
+					func_eval = run_function(f_name, split_f_args(f_args));
+				}
+			}
+			rv = rv + func_eval;
+			i = j;
+		} else
+			rv += s[i];
+	}
+
+
+	//cerr << "eval_string (" << s << ") -> <" << rv << ">\n";
+	return rv;
+}
+
+void geas_implementation::tick_timers() {
+	if (!state.running)
+		return;
+	//cerr << "tick_timers()\n";
+	for (uint i = 0; i < state.timers.size(); i ++) {
+		TimerRecord &tr = state.timers[i];
+		//cerr << "  Examining " << tr << "\n";
+		if (tr.is_running) {
+			//cerr << "    Advancing " << tr.name << ": " << tr.timeleft
+			//     << " / " << tr.interval << "\n";
+			if (tr.timeleft != 0)
+				tr.timeleft --;
+			else {
+				tr.is_running = false;
+				tr.timeleft = tr.interval;
+				const GeasBlock *gb = gf.find_by_name("timer", tr.name);
+				if (gb != NULL) {
+					//cout << "Running it!\n";
+					String tok, line;
+					uint c1, c2;
+					for (uint j = 0; j < gb->data.size(); j ++) {
+						line = gb->data[j];
+						tok = first_token(line, c1, c2);
+						// SENSITIVE?
+						if (tok == "action") {
+							run_script(line.substr(c2));
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+/***********************************
+ *                                 *
+ *                                 *
+ *                                 *
+ * GeasInterface related functions *
+ *                                 *
+ *                                 *
+ *                                 *
+ ***********************************/
+
+
+GeasResult GeasInterface::print_formatted(String s, bool with_newline) {
+	unsigned int i, j;
+
+	//cerr << "print_formatted (" << s << ", " << with_newline << ")" << endl;
+
+	for (i = 0; i < s.length(); i ++) {
+		//std::cerr << "i == " << i << std::endl;
+		if (s[i] == '|') {
+			// changed indicated whether cur_style has been changed
+			// and update_style should be called at the end.
+			// it is true unless cleared (by |n or |w).
+			bool changed = true;
+			j = i;
+			i ++;
+			if (i == s.length())
+				continue;
+
+			// Are the | codes case-sensitive?
+			switch (s[i]) {
+			case 'u':
+				cur_style.is_underlined = true;
+				break;
+			case 'i':
+				cur_style.is_italic     = true;
+				break;
+			case 'b':
+				cur_style.is_bold       = true;
+				break;
+			case 'c':
+				i ++;
+
+				if (i == s.length()) {
+					clear_screen();
+					break;
+				}
+
+				switch (s[i]) {
+				case 'y':
+					cur_style.color = "#ffff00";
+					break;
+				case 'g':
+					cur_style.color = "#00ff00";
+					break;
+				case 'l':
+					cur_style.color = "#0000ff";
+					break;
+				case 'r':
+					cur_style.color = "#ff0000";
+					break;
+				case 'b':
+					cur_style.color = "";
+					break;
+
+				default:
+					clear_screen();
+					--i;
+				}
+				break;
+
+			case 's': {
+				i ++;
+				if (i == s.length() || !(s[i] >= '0' && s[i] <= '9'))
+					continue;
+				i ++;
+				if (i == s.length() || !(s[i] >= '0' && s[i] <= '9'))
+					continue;
+
+				int newsize = parse_int(s.substr(j, i - j));
+				if (newsize > 0)
+					cur_style.size = newsize;
+				else
+					cur_style.size = default_size;
+			}
+			break;
+
+			case 'j':
+				i ++;
+
+				if (i == s.length() ||
+				        !(s[i] == 'l' || s[i] == 'c' || s[i] == 'r'))
+					continue;
+				if (s[i] == 'l') cur_style.justify = JUSTIFY_LEFT;
+				else if (s[i] == 'r') cur_style.justify = JUSTIFY_RIGHT;
+				else if (s[i] == 'c') cur_style.justify = JUSTIFY_CENTER;
+				break;
+
+			case 'n':
+				print_newline();
+				changed = false;
+				break;
+
+			case 'w':
+				wait_keypress("");
+				changed = false;
+				break;
+
+			case 'x':
+				i ++;
+
+				if (s[i] == 'b')
+					cur_style.is_bold = false;
+				else if (s[i] == 'u')
+					cur_style.is_underlined = false;
+				else if (s[i] == 'i')
+					cur_style.is_italic = false;
+				else if (s[i] == 'n' && i + 1 == s.length())
+					changed = with_newline = false;
+				break;
+
+			default:
+				cerr << "p_f: Fallthrough " << s[i] << endl;
+				changed = false;
+			}
+			if (changed)
+				update_style();
+		} else {
+			for (j = i; i != s.length() && s[i] != '|'; i ++)
+				;
+			print_normal(s.substr(j, i - j));
+			if (s[i] == '|')
+				-- i;
+		}
+	}
+	if (with_newline)
+		print_newline();
+	return r_success;
+}
+
+void GeasInterface::set_default_font_size(String size) {
+	default_size = parse_int(size);
+}
+
+void GeasInterface::set_default_font(String font) {
+	default_font = font;
+}
+
+bool GeasInterface::choose_yes_no(String question) {
+	Common::Array<String> v;
+	v.push_back("Yes");
+	v.push_back("No");
+	return (make_choice(question, v) == 0);
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/geas_runner.h b/engines/glk/quest/geas_runner.h
new file mode 100644
index 0000000000..bc6d858d5b
--- /dev/null
+++ b/engines/glk/quest/geas_runner.h
@@ -0,0 +1,220 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_GEAS_RUNNER
+#define GLK_QUEST_GEAS_RUNNER
+
+#include "glk/quest/string.h"
+#include "common/array.h"
+#include "common/stream.h"
+
+namespace Glk {
+namespace Quest {
+
+typedef Common::Array<String> vstring;
+typedef Common::Array<vstring> v2string;
+
+enum geas_justification { JUSTIFY_LEFT, JUSTIFY_RIGHT, JUSTIFY_CENTER };
+
+struct GeasFontStyle {
+	bool is_underlined, is_italic, is_bold;
+	String color, font;
+	int size;
+	geas_justification justify;
+
+	GeasFontStyle() : is_underlined(false), is_italic(false), is_bold(false),
+		color(""), font(""), size(10), justify(JUSTIFY_LEFT) {}
+};
+
+class GeasFontStyleCompare {
+public:
+	int operator()(const GeasFontStyle &a, const GeasFontStyle &b) {
+		if (a.size           !=  b.size)           return a.size < b.size;
+		if (a.is_underlined  !=  b.is_underlined)  return a.is_underlined;
+		if (a.is_bold        !=  b.is_bold)        return a.is_bold;
+		if (a.is_italic      !=  b.is_italic)      return a.is_italic;
+		if (a.color          !=  b.color)          return a.color < b.color;
+		if (a.justify        !=  b.justify)        return a.justify < b.justify;
+		return 0;
+	}
+};
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const GeasFontStyle &gfs);
+
+enum GeasResult {
+	r_success,
+	r_failure,
+	r_not_supported
+};
+
+/*  Callback object used to pass information from GeasCore
+ *  to the interface objects
+ */
+class GeasInterface {
+private:
+	GeasFontStyle cur_style;
+	String default_font;
+	int default_size;
+	//string fgcolor, bgcolor;
+
+public:
+	/* Takes 1 argument, a string with Quest markup
+	 * Will output it to the user interface
+	 * If the with_newline flag is set, it will print a newline afterwords
+	 *     unless the string ends in "|xn"
+	 */
+	GeasResult print_formatted(String s, bool with_newline = true);
+
+	/* Takes one argument; that string is printed without interpretation
+	 * Must be implemented
+	 * Called by print_formatted and by Geas directly.
+	 */
+	virtual GeasResult print_normal(const String &s) = 0;
+
+	virtual GeasResult print_newline() = 0;
+
+protected:
+
+	void update_style() {
+		set_style(cur_style);
+	}
+
+	/* Changes style of output text.
+	 * Need not be implemented
+	 * Only called by update_style()
+	 */
+	virtual GeasResult set_style(const GeasFontStyle &) {
+		return r_not_supported;
+	}
+
+public:
+	virtual String absolute_name(String rel_name, String parent) const = 0;
+	virtual String get_file(const String &filename) const = 0;
+	virtual void debug_print(const String &s) {
+		warning("%s", s.c_str());
+	}
+	virtual GeasResult wait_keypress(String) {
+		return r_not_supported;
+	}
+	virtual GeasResult pause(int msec) {
+		return r_not_supported;
+	}
+	virtual GeasResult clear_screen() {
+		return r_not_supported;
+	}
+
+	//virtual GeasResult set_foreground (string) { return r_not_supported; }
+	//virtual GeasResult set_background (string) { return r_not_supported; }
+	virtual void set_foreground(String) = 0;
+	virtual void set_background(String) = 0;
+	void set_default_font_size(String s);
+	void set_default_font(String s);
+
+	/* Unsure what arguments this will take.
+	 * May also add animated, persistent, close image
+	 */
+	virtual GeasResult show_image(String filename, String resolution,
+	                              String caption, ...) {
+		return r_not_supported;
+	}
+
+	/* Again, unsure what arguments to give
+	 * May add sound type
+	 * If sync is true, do not return until file ends
+	 * If filename is "", stop playing sounds.
+	 */
+	virtual GeasResult play_sound(String filename, bool looped, bool sync) {
+		return r_not_supported;
+	}
+
+	/* Asks the user to type a free format string
+	 */
+	virtual String get_string() = 0;
+
+	/* Presents a list with header 'info', and prompts the user to
+	 * choose one item from 'choices'.
+	 * returns the index chosen.
+	 */
+	virtual uint make_choice(String info, Common::Array<String> choices) = 0;
+
+	/* Asks the user a yes/no question
+	 * (If not overridden, this has an implementation that uses make_choice()
+	 */
+	virtual bool choose_yes_no(String question);
+
+	/* args holds arguments sent to program.
+	 * if active is true, geas should retain focus
+	 * returns -   0 if disallowed
+	 *         -   1 if succeeded
+	 *         -   2 if file not found
+	 *         -   3 if it couldn't find a program to run it
+	 *         -   4 if it ran out of memory
+	 */
+	virtual int shell(Common::Array<String> args, bool active) {
+		return 0;
+	}
+
+	/* say the argument using text-to-speech
+	 */
+	virtual GeasResult speak(String) {
+		return r_not_supported;
+	}
+
+	virtual ~GeasInterface() {}
+
+	/* This is a notification that some object has changed, and
+	 * the interpreter may want to update the inventory or room object
+	 * listings.
+	 */
+	virtual void update_sidebars() { }
+};
+
+
+/* Callback for passing information from the UI to the execution core
+ */
+class GeasRunner {
+protected:
+	GeasInterface *gi;
+
+public:
+	GeasRunner(GeasInterface *_gi) : gi(_gi) {}
+
+	virtual bool is_running() const = 0;
+	virtual String get_banner() = 0;
+	virtual void run_command(String) = 0;
+
+	virtual v2string get_inventory() = 0;
+	virtual v2string get_room_contents() = 0;
+	virtual vstring  get_status_vars() = 0;
+	virtual Common::Array<bool> get_valid_exits() = 0;
+
+	virtual void tick_timers() = 0;
+
+	virtual ~GeasRunner() {  }
+	virtual void set_game(const String &fname) = 0;
+	static GeasRunner *get_runner(GeasInterface *gi);
+};
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/geas_state.cpp b/engines/glk/quest/geas_state.cpp
new file mode 100644
index 0000000000..985b4e935e
--- /dev/null
+++ b/engines/glk/quest/geas_state.cpp
@@ -0,0 +1,356 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/geas_state.h"
+#include "glk/quest/geas_runner.h"
+#include "glk/quest/geas_util.h"
+#include "glk/quest/read_file.h"
+#include "glk/quest/streams.h"
+
+namespace Glk {
+namespace Quest {
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const StringMap &m) {
+	for (StringMap::iterator i = m.begin(); i != m.end(); ++i)
+		o << (*i)._key << " -> " << (*i)._value << "\n";
+
+	return o;
+}
+
+class GeasOutputStream {
+	Common::WriteStream *_ws;
+public:
+	GeasOutputStream &put(const String &s) {
+		_ws->writeString(s);
+		_ws->writeByte(0);
+		return *this;
+	}
+	GeasOutputStream &put(char ch) {
+		_ws->writeByte(ch);
+		return *this;
+	}
+	GeasOutputStream &put(int i) {
+		Common::String s = Common::String::format("%d", i);
+		_ws->writeString(s);
+		_ws->writeByte(0);
+		return *this;
+	}
+	GeasOutputStream &put(uint i) {
+		Common::String s = Common::String::format("%u", i);
+		_ws->writeString(s);
+		_ws->writeByte(0);
+		return *this;
+	}
+	GeasOutputStream &put(unsigned long i) {
+		Common::String s = Common::String::format("%lu", i);
+		_ws->writeString(s);
+		_ws->writeByte(0);
+		return *this;
+	}
+
+	void write_out(const String &gameName, const String &saveName) {
+#ifdef TODO
+		ofstream ofs;
+		ofs.open(savename.c_str());
+		if (!ofs.is_open())
+			throw String("Unable to open \"" + savename + "\"");
+		ofs << "QUEST300" << char(0) << gamename << char(0);
+		String tmp = o.str();
+		for (uint i = 0; i < tmp.size(); i ++)
+			ofs << char (255 - tmp[i]);
+		cerr << "Done writing save game\n";
+#else
+		error("TODO");
+#endif
+	}
+};
+
+template <class T> void write_to(GeasOutputStream &gos, const Common::Array<T> &v) {
+	gos.put(v.size());
+	for (uint i = 0; i < v.size(); i ++)
+		write_to(gos, v[i]);
+}
+
+void write_to(GeasOutputStream &gos, const PropertyRecord &pr) {
+	gos.put(pr.name).put(pr.data);
+}
+
+void write_to(GeasOutputStream &gos, const ObjectRecord &pr) {
+	gos.put(pr.name).put(char(pr.hidden ? 0 : 1))
+	.put(char(pr.invisible ? 0 : 1)).put(pr.parent);
+}
+
+void write_to(GeasOutputStream &gos, const ExitRecord &er) {
+	gos.put(er.src).put(er.dest);
+}
+
+void write_to(GeasOutputStream &gos, const TimerRecord &tr) {
+	gos.put(tr.name).put(tr.is_running ? 0 : 1).put(tr.interval)
+	.put(tr.timeleft);
+}
+
+
+void write_to(GeasOutputStream &gos, const SVarRecord &svr) {
+	gos.put(svr.name);
+	gos.put(svr.max());
+	for (uint i = 0; i < svr.size(); i ++)
+		gos.put(svr.get(i));
+}
+
+void write_to(GeasOutputStream &gos, const IVarRecord &ivr) {
+	gos.put(ivr.name);
+	gos.put(ivr.max());
+	for (uint i = 0; i < ivr.size(); i ++)
+		gos.put(ivr.get(i));
+}
+
+void write_to(GeasOutputStream &gos, const GeasState &gs) {
+	gos.put(gs.location);
+	write_to(gos, gs.props);
+	write_to(gos, gs.objs);
+	write_to(gos, gs.exits);
+	write_to(gos, gs.timers);
+	write_to(gos, gs.svars);
+	write_to(gos, gs.ivars);
+}
+
+void save_game_to(String gamename, String savename, const GeasState &gs) {
+	GeasOutputStream gos;
+	write_to(gos, gs);
+	gos.write_out(gamename, savename);
+}
+
+GeasState::GeasState(GeasInterface &gi, const GeasFile &gf) {
+	running = false;
+
+	cerr << "GeasState::GeasState()" << endl;
+	for (uint i = 0; i < gf.size("game"); i ++) {
+		//const GeasBlock &go = gf.game[i];
+		//register_block ("game", "game");
+		ObjectRecord data;
+		data.name = "game";
+		data.parent = "";
+		data.hidden = false;
+		data.invisible = true;
+		objs.push_back(data);
+	}
+
+	cerr << "GeasState::GeasState() done setting game" << endl;
+	for (uint i = 0; i < gf.size("room"); i ++) {
+		const GeasBlock &go = gf.block("room", i);
+		ObjectRecord data;
+		//data.name = go.lname;
+		data.name = go.name;
+		data.parent = "";
+		data.hidden = data.invisible = true;
+		//register_block (data.name, "room");
+		objs.push_back(data);
+	}
+
+	cerr << "GeasState::GeasState() done setting rooms" << endl;
+	for (uint i = 0; i < gf.size("object"); i++) {
+		const GeasBlock &go = gf.block("object", i);
+		ObjectRecord data;
+		//data.name = go.lname;
+		data.name = go.name;
+		if (go.parent == "")
+			data.parent = "";
+		else
+			//data.parent = lcase (param_contents (go.parent));
+			data.parent = param_contents(go.parent);
+		//register_block (data.name, "object");
+		data.hidden = data.invisible = false;
+		objs.push_back(data);
+	}
+
+	cerr << "GeasState::GeasState() done setting objects" << endl;
+	for (uint i = 0; i < gf.size("timer"); i ++) {
+		const GeasBlock &go = gf.block("timer", i);
+		//cerr << "GS::GS: Handling timer " << go << "\n";
+		TimerRecord tr;
+		String interval = "", status = "";
+		for (uint j = 0; j < go.data.size(); j ++) {
+			String line = go.data[j];
+			uint c1, c2;
+			String tok = first_token(line, c1, c2);
+			if (tok == "interval") {
+				tok = next_token(line, c1, c2);
+				if (!is_param(tok))
+					gi.debug_print(nonparam("interval", line));
+				else
+					interval = param_contents(tok);
+			} else if (tok == "enabled" || tok == "disabled") {
+				if (status != "")
+					gi.debug_print("Repeated status for timer");
+				else
+					status = tok;
+			} else if (tok == "action") {
+			} else {
+				gi.debug_print("Bad timer line " + line);
+			}
+		}
+		//tr.name = go.lname;
+		tr.name = go.name;
+		tr.is_running = (status == "enabled");
+		tr.interval = tr.timeleft = parse_int(interval);
+		//register_block (tr.name, "timer");
+		timers.push_back(tr);
+	}
+
+	cerr << "GeasState::GeasState() done with timers" << endl;
+	for (uint i = 0; i < gf.size("variable"); i ++) {
+		const GeasBlock &go(gf.block("variable", i));
+		cerr << "GS::GS: Handling variable #" << i << ": " << go << endl;
+		String vartype;
+		String value;
+		for (uint j = 0; j < go.data.size(); j ++) {
+			String line = go.data[j];
+			cerr << "   Line #" << j << " of var: \"" << line << "\"" << endl;
+			uint c1, c2;
+			String tok = first_token(line, c1, c2);
+			if (tok == "type") {
+				tok = next_token(line, c1, c2);
+				if (tok == "")
+					gi.debug_print(String("Missing variable type in ")
+					               + string_geas_block(go));
+				else if (vartype != "")
+					gi.debug_print(String("Redefining var. type in ")
+					               + string_geas_block(go));
+				else if (tok == "numeric" || tok == "String")
+					vartype = tok;
+				else
+					gi.debug_print(String("Bad var. type ") + line);
+			} else if (tok == "value") {
+				tok = next_token(line, c1, c2);
+				if (!is_param(tok))
+					gi.debug_print(String("Expected parameter in " + line));
+				else
+					value = param_contents(tok);
+			} else if (tok == "display" || tok == "onchange") {
+			} else {
+				gi.debug_print(String("Bad var. line: ") + line);
+			}
+		}
+		if (vartype == "" || vartype == "numeric") {
+			IVarRecord ivr;
+			//ivr.name = go.lname;
+			ivr.name = go.name;
+			ivr.set(0, parse_int(value));
+			ivars.push_back(ivr);
+			//register_block (ivr.name, "numeric");
+		} else {
+			SVarRecord svr;
+			//svr.name = go.lname;
+			svr.name = go.name;
+			svr.set(0, value);
+			svars.push_back(svr);
+			//register_block (svr.name, "String");
+		}
+	}
+	//cerr << obj_types << endl;
+	cerr << "GeasState::GeasState() done with variables" << endl;
+}
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const PropertyRecord &pr) {
+	o << pr.name << ", data == " << pr.data;
+	return o;
+}
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const ObjectRecord &objr) {
+	o << objr.name << ", parent == " << objr.parent;
+	if (objr.hidden)
+		o << ", hidden";
+	if (objr.invisible)
+		o << ", invisible";
+	return o;
+}
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const ExitRecord er) {
+	return o << er.src << ": " << er.dest;
+}
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const TimerRecord &tr) {
+	return o << tr.name << ": " << (tr.is_running ? "" : "not ") << "running ("
+	       << tr.timeleft << " // " << tr.interval << ")";
+}
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const SVarRecord &sr) {
+	o << sr.name << ": ";
+	if (sr.size() == 0)
+		o << "(empty)";
+	else if (sr.size() <= 1)
+		o << "<" << sr.get(0) << ">";
+	else
+		for (uint i = 0; i < sr.size(); i ++) {
+			o << i << ": <" << sr.get(i) << ">";
+			if (i + 1 < sr.size())
+				o << ", ";
+		}
+	return o;
+}
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const IVarRecord &ir) {
+	o << ir.name << ": ";
+	if (ir.size() == 0)
+		o << "(empty)";
+	else if (ir.size() <= 1)
+		o << ir.get(0);
+	else
+		for (uint i = 0; i < ir.size(); i ++) {
+			o << i << ": " << ir.get(i);
+			if (i + 1 < ir.size())
+				o << ", ";
+		}
+	return o;
+}
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const GeasState &gs) {
+	o << "location == " << gs.location << "\nprops: \n";
+
+	for (uint i = 0; i < gs.props.size(); i ++)
+		o << "    " << i << ": " << gs.props[i] << "\n";
+
+	o << "objs:\n";
+	for (uint i = 0; i < gs.objs.size(); i ++)
+		o << "    " << i << ": " << gs.objs[i] << "\n";
+
+	o << "exits:\n";
+	for (uint i = 0; i < gs.exits.size(); i ++)
+		o << "    " << i << ": " << gs.exits[i] << "\n";
+
+	o << "timers:\n";
+	for (uint i = 0; i < gs.timers.size(); i ++)
+		o << "    " << i << ": " << gs.timers[i] << "\n";
+
+	o << "String variables:\n";
+	for (uint i = 0; i < gs.svars.size(); i ++)
+		o << "    " << i << ": " << gs.svars[i] << "\n";
+
+	o << "integer variables:\n";
+	for (uint i = 0; i < gs.svars.size(); i ++)
+		o << "    " << i << ": " << gs.svars[i] << "\n";
+
+	return o;
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/geas_state.h b/engines/glk/quest/geas_state.h
new file mode 100644
index 0000000000..70365f1fd8
--- /dev/null
+++ b/engines/glk/quest/geas_state.h
@@ -0,0 +1,171 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_GEAS_STATE
+#define GLK_QUEST_GEAS_STATE
+
+#include "glk/quest/string.h"
+#include "common/array.h"
+#include "common/stream.h"
+
+namespace Glk {
+namespace Quest {
+
+struct PropertyRecord {
+	String name, data;
+	PropertyRecord(String in_name, String in_data) : name(in_name), data(in_data) {}
+};
+
+struct ObjectRecord {
+	String name, parent;
+	bool hidden, invisible;
+
+	//ObjectRecord (String in_name, String in_parent) : name (in_name), parent (in_parent), hidden (false), concealed (false) {}
+
+};
+
+struct ExitRecord {
+	String src, dest;
+	ExitRecord(String in_src, String in_dest) : src(in_src), dest(in_dest) {}
+};
+
+struct TimerRecord {
+	String name;
+	bool is_running;
+	uint interval, timeleft;
+};
+
+struct SVarRecord {
+private:
+	Common::Array<String> data;
+public:
+	String name;
+
+	SVarRecord() {}
+	SVarRecord(String in_name) : name(in_name) {
+		set(0, "");
+	}
+	uint size() const {
+		return data.size();
+	}
+	uint max() const {
+		return size() - 1;
+	}
+	void set(uint i, String val) {
+		if (i >= size()) data.resize(i + 1);
+		data[i] = val;
+	}
+	String get(uint i) const {
+		if (i < size()) return data[i];
+		return "!";
+	}
+	void set(String val) {
+		data[0] = val;
+	}
+	String get() const {
+		return data[0];
+	}
+};
+
+struct IVarRecord {
+private:
+	Common::Array<int> data;
+public:
+	String name;
+
+	IVarRecord() {}
+	IVarRecord(String in_name) : name(in_name) {
+		set(0, 0);
+	}
+	uint size() const {
+		return data.size();
+	}
+	uint max() const {
+		return size() - 1;
+	}
+	void set(uint i, int val) {
+		if (i >= size()) data.resize(i + 1);
+		data[i] = val;
+	}
+	int get(uint i) const {
+		if (i < size()) return data[i];
+		else return -32767;
+	}
+	void set(int val) {
+		data[0] = val;
+	}
+	int get() const {
+		return data[0];
+	}
+};
+
+struct GeasFile;
+class GeasInterface;
+
+struct GeasState {
+	//private:
+	//std::auto_ptr<GeasFile> gf;
+
+public:
+	bool running;
+	String location;
+	Common::Array<PropertyRecord> props;
+	Common::Array<ObjectRecord> objs;
+	Common::Array<ExitRecord> exits;
+	Common::Array<TimerRecord> timers;
+	Common::Array<SVarRecord> svars;
+	Common::Array<IVarRecord> ivars;
+	//std::map <String, String> obj_types;
+
+	//void register_block (String blockname, String blocktype);
+
+	GeasState() {}
+	//GeasState (GeasRunner &, const GeasFile &);
+	GeasState(GeasInterface &, const GeasFile &);
+	/*
+	bool has_svar (string s) { for (uint i = 0; i < svars.size(); i ++) if (svars[i].name == s) return true; }
+	uint find_svar (string s) { for (uint i = 0; i < svars.size(); i ++) if (svars[i].name == s) return i; svars.push_back (SVarRecord (s)); return svars.size() - 1;}
+	string get_svar (string s, uint index) { if (!has_svar(s)) return "!"; return svars[find_svar(s)].get(index); }
+	string get_svar (string s) { return get_svar (s, 0); }
+
+	bool has_ivar (string s) { for (uint i = 0; i < ivars.size(); i ++) if (ivars[i].name == s) return true; }
+	uint find_ivar (string s) { for (uint i = 0; i < ivars.size(); i ++) if (ivars[i].name == s) return i; ivars.push_back (IVarRecord (s)); return ivars.size() - 1;}
+	int get_ivar (string s, uint index) { if (!has_ivar(s)) return -32767; return ivars[find_ivar(s)].get(index); }
+	int get_ivar (string s) { return get_ivar (s, 0); }
+	*/
+};
+
+void save_game_to(String gamename, String savename, const GeasState &gs);
+
+Common::WriteStream &operator<< (Common::WriteStream &o, const StringMap &m);
+Common::WriteStream &operator<< (Common::WriteStream &o, const PropertyRecord &pr);
+Common::WriteStream &operator<< (Common::WriteStream &o, const ObjectRecord &objr);
+Common::WriteStream &operator<< (Common::WriteStream &o, const ExitRecord er);
+Common::WriteStream &operator<< (Common::WriteStream &o, const TimerRecord &tr);
+Common::WriteStream &operator<< (Common::WriteStream &o, const SVarRecord &sr);
+Common::WriteStream &operator<< (Common::WriteStream &o, const IVarRecord &ir);
+Common::WriteStream &operator<< (Common::WriteStream &o, const GeasState &gs);
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/geas_util.cpp b/engines/glk/quest/geas_util.cpp
new file mode 100644
index 0000000000..bc5eaac177
--- /dev/null
+++ b/engines/glk/quest/geas_util.cpp
@@ -0,0 +1,245 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/geas_util.h"
+#include "glk/quest/geas_file.h"
+#include "glk/quest/streams.h"
+#include "glk/quest/string.h"
+
+namespace Glk {
+namespace Quest {
+
+int eval_int(String s) {
+	cerr << "eval_int (" << s << ")" << endl;
+
+	uint index = 0, index2;
+	String tmp;
+	while (index < s.length() && Common::isSpace(s[index])) {
+		cerr << "  index == " << index << endl;
+		index ++;
+	}
+	if (index == s.length() || !Common::isDigit(s[index])) {
+		cerr << "Failed to match, returning 0" << endl;
+		return 0;
+	}
+	for (index2 = index; index2 < s.length() && Common::isDigit(s[index2]); index2 ++) {
+		cerr << "  index2 == " << index2 << endl;
+	}
+	//;
+	tmp = s.substr(index, index2 - index);
+	cerr << "tmp == < " << tmp << ">" << endl;
+
+	//cerr << "index == " << index << ", index2 == " << index2
+	//     << ", tmp == " << tmp << endl;
+
+	int arg1 = atoi(tmp.c_str());
+	cerr << "arg1 == " << arg1 << endl;
+	index = index2;
+	while (index < s.length() && Common::isSpace(s[index]))
+		++ index;
+	if (index == s.length())
+		return arg1;
+
+	//cerr << "index == " << index << ", s.length() == " << s.length() << endl;
+
+	char symbol = s[index];
+
+	//cerr << "symbol == " << symbol << "; find --> "
+	//     << String("+-*/").find (symbol) << endl;
+
+	if (String("+-*/").find(symbol) == String::npos)
+		return arg1;
+
+	++ index;
+	while (index < s.length() && Common::isSpace(s[index]))
+		++ index;
+	if (index == s.length() || ! Common::isDigit(s[index])) {
+		if (symbol == '*')
+			return 0;
+		return arg1;
+	}
+	index2 = index + 1;
+	while (index2 < s.length() && Common::isDigit(s[index2]))
+		++ index2;
+	tmp = s.substr(index, index2 - index);
+	int arg2 = atoi(tmp.c_str());
+
+	switch (symbol) {
+	case '+':
+		return arg1 + arg2;
+	case '-':
+		return arg1 - arg2;
+	case '*':
+		return arg1 * arg2;
+	case '/':
+		return arg1 / arg2;
+		// TODO: division should use accountant's round
+	}
+	return 0;
+}
+
+String trim_braces(String s) {
+	if (s.length() > 1 && s[0] == '[' && s[s.length() - 1] == ']')
+		return s.substr(1, s.length() - 2);
+	else
+		return s;
+}
+
+bool is_param(String s) {
+	return s.length() > 1 && s[0] == '<' && s[s.length() - 1] == '>';
+}
+
+String param_contents(String s) {
+	//cerr << "param_contents (" << s << ")" << endl;
+	assert(is_param(s));
+	return s.substr(1, s.length() - 2);
+}
+
+String nonparam(String type, String var) {
+	return "Non-parameter for " + type + " in \"" + var + "\"";
+}
+
+//ostream &operator << (ostream &o, const GeasBlock &gb) { return o; }
+//String trim (String s, trim_modes) { return s; }
+
+String string_geas_block(const GeasBlock &gb) {
+	ostringstream oss;
+	oss << gb;  // temporary removed TODO
+	return oss.str();
+}
+
+
+bool starts_with(String a, String b) {
+	return (a.length() >= b.length()) && (a.substr(0, b.length()) == b);
+}
+bool ends_with(String a, String b) {
+	return (a.length() >= b.length()) &&
+	       (a.substr(a.length() - b.length(), b.length()) == b);
+}
+
+bool starts_with_i(String a, String b) {
+	return (a.length() >= b.length()) && ci_equal(a.substr(0, b.length()), b);
+	//  return starts_with (lcase(a), lcase(b));
+}
+bool ends_with_i(String a, String b) {
+	return (a.length() >= b.length()) &&
+	       ci_equal(a.substr(a.length() - b.length(), b.length()), b);
+	//return ends_with (lcase(a), lcase(b));
+}
+
+String pcase(String s) {
+	if (s.length() == 0)
+		return s;
+	if (Common::isLower(s[0]))
+		s[0] = toupper(s[0]);
+	return s;
+}
+
+String ucase(String s) {
+	for (uint i = 0; i < s.length(); i ++)
+		s[i] = toupper(s[i]);
+	return s;
+}
+
+// There's a good chance s is already all-lowercase, in which case
+// the test will avoid making a copy
+String lcase(String s) {
+	for (uint i = 0; i < s.length(); i ++)
+		if (Common::isUpper(s[i]))
+			s[i] = tolower(s[i]);
+	return s;
+}
+
+Common::Array<String> split_param(String s) {
+	Common::Array<String> rv;
+	uint c1 = 0, c2;
+
+	for (;;) {
+		c2 = s.find(';', c1);
+		if (c2 == -1) {
+			rv.push_back(s.substr(c1).trim());
+			return rv;
+		}
+		rv.push_back(s.substr(c1, c2 - c1).trim());
+		c1 = c2 + 1;
+	}
+}
+
+Common::Array<String> split_f_args(String s) {
+	Common::Array<String> rv = split_param(s);
+	for (uint i = 0; i < rv.size(); i ++) {
+		String tmp = rv[i];
+		if (tmp[0] == '_')
+			rv[i][0] = ' ';
+		if (tmp[tmp.length() - 1] == '_')
+			rv[i][tmp.length() - 1] = ' ';
+	}
+	return rv;
+}
+
+void show_split(String s) {
+	Common::Array<String> tmp = split_param(s);
+	cerr << "Splitting <" << s << ">: ";
+	for (uint i = 0; i < tmp.size(); i ++)
+		cerr << "<" << tmp[i] << ">, ";
+	cerr << "\n";
+}
+
+Logger::Nullstreambuf Logger::cnull;
+
+Logger::Logger() : logfilestr_(NULL) { //, cerrbuf_(NULL) {
+/*
+	cerr.flush();
+
+	const char *const logfile = getenv("GEAS_LOGFILE");
+	if (logfile) {
+		ofstream *filestr = new ofstream(logfile);
+		if (filestr->fail())
+			delete filestr;
+		else {
+			logfilestr_ = filestr;
+			cerrbuf_ = cerr.rdbuf(filestr->rdbuf());
+		}
+	}
+
+	if (!cerrbuf_)
+		cerrbuf_ = cerr.rdbuf(&cnull);
+		*/
+}
+
+Logger::~Logger() {
+	/*
+	cerr.flush();
+
+	cerr.rdbuf(cerrbuf_);
+	cerrbuf_ = NULL;
+
+	if (logfilestr_) {
+		logfilestr_->close();
+		delete logfilestr_;
+		logfilestr_ = NULL;
+	}
+	*/
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/geas_util.h b/engines/glk/quest/geas_util.h
new file mode 100644
index 0000000000..2cedadde02
--- /dev/null
+++ b/engines/glk/quest/geas_util.h
@@ -0,0 +1,97 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_GEAS_UTIL
+#define GLK_QUEST_GEAS_UTIL
+
+#include "glk/quest/read_file.h"
+#include "common/stream.h"
+
+namespace Glk {
+namespace Quest {
+
+typedef Common::Array<String> vstring;
+
+inline int parse_int(const String &s) {
+	return atoi(s.c_str());
+}
+
+vstring split_param(String s);
+vstring split_f_args(String s);
+
+bool is_param(String s);
+String param_contents(String s);
+
+String nonparam(String, String);
+
+String string_geas_block(const GeasBlock &);
+
+bool starts_with(String, String);
+bool ends_with(String, String);
+
+String string_int(int i);
+
+String trim_braces(String s);
+
+int eval_int(String s);
+
+String pcase(String s);
+String ucase(String s);
+String lcase(String s);
+
+
+template<class T> Common::WriteStream &operator<<(Common::WriteStream &o, Common::Array<T> v) {
+	o << "{ '";
+	for (uint i = 0; i < v.size(); i ++) {
+		o << v[i];
+		if (i + 1 < v.size())
+			o << "', '";
+	}
+	o << "' }";
+	return o;
+}
+
+template <class KEYTYPE, class VALTYPE>
+bool has(Common::HashMap<KEYTYPE, VALTYPE, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> m, KEYTYPE key) {
+	return m.contains(key);
+};
+
+class Logger {
+public:
+	Logger();
+	~Logger();
+
+private:
+	class Nullstreambuf : public Common::WriteStream {
+		virtual uint32 write(const void *dataPtr, uint32 dataSize) { return dataSize; }
+		virtual int32 pos() const { return 0; }
+	};
+
+	Common::WriteStream *logfilestr_;
+//	std::streambuf *cerrbuf_;
+	static Nullstreambuf cnull;
+};
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/limit_stack.h b/engines/glk/quest/limit_stack.h
new file mode 100644
index 0000000000..75cad4401d
--- /dev/null
+++ b/engines/glk/quest/limit_stack.h
@@ -0,0 +1,103 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_LIMIT_STACK
+#define GLK_QUEST_LIMIT_STACK
+
+namespace Glk {
+namespace Quest {
+
+template <class T> class LimitStack {
+	uint stack_size, cur_ptr, end_ptr;
+	Common::Array<T> data;
+	//bool last_push;
+
+
+	uint dofwd(uint i) const {
+		i ++;
+		return i == stack_size ? 0 : i;
+	}
+	uint dobwd(uint i) const {
+		return (i == 0 ? stack_size : i) - 1;
+	}
+	void fwd(uint &i) const {
+		i = dofwd(i);
+	}
+	void bwd(uint &i) const {
+		i = dobwd(i);
+	}
+
+	/*
+	void fwd (uint &i) { i ++; if (i == stack_size) i = 0; }
+	void bwd (uint &i) { i = (i == 0 ? stack_size : i) - 1; }
+	uint dofwd (uint i) { uint rv = i; fwd(rv); return rv; }
+	uint dobwd (uint i) { uint rv = i; bwd(rv); return rv; }
+	*/
+
+public:
+	LimitStack(uint size) : stack_size(size), cur_ptr(0), end_ptr(size - 1), data(Common::Array<T> (size)) { }
+
+	void push(T &item) {
+		if (cur_ptr == end_ptr)
+			fwd(end_ptr);
+		data[cur_ptr] = item;
+		fwd(cur_ptr);
+	}
+
+	T &pop() {
+		assert(!is_empty());
+		bwd(cur_ptr);
+		return data[cur_ptr];
+	}
+
+	bool is_empty() {
+		return dobwd(cur_ptr) == end_ptr;
+	}
+
+	uint size() {
+		if (cur_ptr > end_ptr)
+			return cur_ptr - end_ptr - 1;
+		else
+			return (cur_ptr + stack_size) - end_ptr - 1;
+	}
+
+	void dump(Common::WriteStream &o) {
+		o << size() << ": < ";
+		for (uint i = dobwd(cur_ptr); i != end_ptr; bwd(i))
+			o << data[i] << " ";
+		o << ">";
+	}
+
+	T &peek() {
+		return data[dobwd(cur_ptr)];
+	}
+};
+
+template<class T> Common::WriteStream &operator<< (Common::WriteStream &o, LimitStack<T> st) {
+	st.dump(o);
+	return o;
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/quest.cpp b/engines/glk/quest/quest.cpp
new file mode 100644
index 0000000000..93de43f6d7
--- /dev/null
+++ b/engines/glk/quest/quest.cpp
@@ -0,0 +1,149 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/quest.h"
+#include "glk/quest/geas_glk.h"
+#include "glk/quest/geas_glk.h"
+#include "glk/quest/streams.h"
+#include "common/config-manager.h"
+#include "common/translation.h"
+
+namespace Glk {
+namespace Quest {
+
+Quest *g_vm;
+
+void Quest::runGame() {
+	// Check for savegame
+	_saveSlot = ConfMan.hasKey("save_slot") ? ConfMan.getInt("save_slot") : -1;
+
+	if (!initialize()) {
+		GUIErrorMessage(_("Could not start Quest game"));
+		return;
+	}
+
+	playGame();
+
+	deinitialize();
+}
+
+void Quest::playGame() {
+	char cur_buf[1024];
+	char buf[200];
+
+	GeasRunner *gr = GeasRunner::get_runner(new GeasGlkInterface());
+	gr->set_game(String(getFilename().c_str()));
+	banner = gr->get_banner();
+	draw_banner();
+
+	while (gr->is_running()) {
+		if (inputwin != mainglkwin)
+			glk_window_clear(inputwin);
+		else
+			glk_put_cstring("\n");
+
+		sprintf(cur_buf, "> ");
+		glk_put_string_stream(inputwinstream, cur_buf);
+
+		glk_request_line_event(inputwin, buf, (sizeof buf) - 1, 0);
+
+		event_t ev;
+		ev.type = evtype_None;
+
+		while (ev.type != evtype_LineInput) {
+			glk_select(&ev);
+
+			switch (ev.type) {
+			case evtype_LineInput:
+				if (ev.window == inputwin) {
+					String cmd = String(buf, ev.val1);
+					if (inputwin == mainglkwin)
+						ignore_lines = 2;
+					gr->run_command(cmd);
+				}
+				break;
+
+			case evtype_Timer:
+				gr->tick_timers();
+				break;
+
+			case evtype_Arrange:
+			case evtype_Redraw:
+				draw_banner();
+				break;
+			}
+		}
+	}
+}
+
+bool Quest::initialize() {
+	glk_stylehint_set(wintype_TextBuffer, style_User2, stylehint_ReverseColor, 1);
+
+	// Open the main window
+	mainglkwin = glk_window_open(0, 0, 0, wintype_TextBuffer, 1);
+	if (!mainglkwin)
+		return false;
+	glk_set_window(mainglkwin);
+
+	glk_stylehint_set(wintype_TextGrid, style_User1, stylehint_ReverseColor, 1);
+	bannerwin = glk_window_open(mainglkwin,
+		winmethod_Above | winmethod_Fixed,
+		1, wintype_TextGrid, 0);
+
+	if (use_inputwindow)
+		inputwin = glk_window_open(mainglkwin,
+			winmethod_Below | winmethod_Fixed,
+			1, wintype_TextBuffer, 0);
+	else
+		inputwin = NULL;
+
+	if (!inputwin)
+		inputwin = mainglkwin;
+
+	inputwinstream = glk_window_get_stream(inputwin);
+
+	if (!glk_gestalt(gestalt_Timer, 0)) {
+		const char *err = "\nNote -- The underlying Glk library does not support"
+			" timers.  If this game tries to use timers, then some"
+			" functionality may not work correctly.\n\n";
+		glk_put_string(err);
+	}
+
+	glk_request_timer_events(1000);
+	ignore_lines = 0;
+
+	return true;
+}
+
+void Quest::deinitialize() {
+}
+
+Common::Error Quest::readSaveData(Common::SeekableReadStream *rs) {
+	return Common::kNoError;
+}
+
+Common::Error Quest::writeGameData(Common::WriteStream *ws) {
+	return Common::kNoError;
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/quest.h b/engines/glk/quest/quest.h
new file mode 100644
index 0000000000..69aa2db094
--- /dev/null
+++ b/engines/glk/quest/quest.h
@@ -0,0 +1,92 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_QUEST
+#define GLK_QUEST_QUEST
+
+#include "glk/glk_api.h"
+#include "glk/quest/string.h"
+
+namespace Glk {
+namespace Quest {
+
+/**
+ * Quest game interpreter
+ */
+class Quest : public GlkAPI {
+private:
+	int _saveSlot;
+public:
+	String banner;
+private:
+	/**
+	 * Engine initialization
+	 */
+	bool initialize();
+
+	/**
+	 * Engine cleanup
+	 */
+	void deinitialize();
+
+	/**
+	 * Inner gameplay method
+	 */
+	void playGame();
+public:
+	/**
+	 * Constructor
+	 */
+	Quest(OSystem *syst, const GlkGameDescription &gameDesc) : GlkAPI(syst, gameDesc), _saveSlot(-1) {
+		g_vm = this;
+	}
+
+	/**
+	 * Run the game
+	 */
+	virtual void runGame() override;
+
+	/**
+	 * Returns the running interpreter type
+	 */
+	virtual InterpreterType getInterpreterType() const override {
+		return INTERPRETER_QUEST;
+	}
+
+	/**
+	 * Load a savegame from the passed Quetzal file chunk stream
+	 */
+	virtual Common::Error readSaveData(Common::SeekableReadStream *rs) override;
+
+	/**
+	 * Save the game. The passed write stream represents access to the UMem chunk
+	 * in the Quetzal save file that will be created
+	 */
+	virtual Common::Error writeGameData(Common::WriteStream *ws) override;
+};
+
+extern Quest *g_vm;
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/read_file.cpp b/engines/glk/quest/read_file.cpp
new file mode 100644
index 0000000000..c749bb2718
--- /dev/null
+++ b/engines/glk/quest/read_file.cpp
@@ -0,0 +1,1043 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/read_file.h"
+#include "glk/quest/geas_util.h"
+#include "glk/quest/reserved_words.h"
+#include "glk/quest/geas_runner.h"
+#include "glk/quest/streams.h"
+#include "common/util.h"
+
+namespace Glk {
+namespace Quest {
+
+String next_token(String full, uint &tok_start, uint &tok_end, bool cvt_paren) {
+	tok_start = tok_end;
+	while (tok_start < full.size() && Common::isSpace(full[tok_start]))
+		++ tok_start;
+	if (tok_start >= full.size()) {
+		tok_start = tok_end = full.size();
+		//tok_start = tok_end = String::npos;
+		return "";
+	}
+	tok_end = tok_start + 1;
+	if (full[tok_start] == '{' || full[tok_start] == '}')
+		/* brace is a token by itself */;
+	else if (full[tok_start] == '<') {
+		while (tok_end < full.size() && full [tok_end] != '>')
+			++ tok_end;
+		if (full[tok_end] == '>')
+			++ tok_end;
+	} else if (cvt_paren && full[tok_start] == '(') {
+		uint depth = 1;
+		/*
+		while (tok_end < full.size() && full [tok_end] != ')')
+		++ tok_end;
+		     if (full[tok_end] == ')')
+		++ tok_end;
+		     */
+		do {
+			if (full[tok_end] == '(')
+				++ depth;
+			else if (full[tok_end] == ')')
+				-- depth;
+			++ tok_end;
+		} while (tok_end < full.size() && depth > 0);
+	} else
+		while (tok_end < full.size() && !Common::isSpace(full[tok_end]))
+			++ tok_end;
+	return full.substr(tok_start, tok_end - tok_start);
+}
+
+String first_token(String s, uint &t_start, uint &t_end) {
+	t_end = 0;
+	return next_token(s, t_start, t_end);
+}
+
+String nth_token(String s, int n) {
+	uint x1, x2 = 0;
+	String rv;
+	do
+		rv = next_token(s, x1, x2);
+	while (-- n > 0);
+	return rv;
+}
+
+String get_token(String s, bool cvt_paren) {
+	uint x1, x2 = 0;
+	return next_token(s, x1, x2, cvt_paren);
+}
+
+bool find_token(String s, String tok, int &tok_start, int &tok_end, bool cvt_paren) {
+	uint copy_start, copy_end;
+	copy_end = tok_end;
+
+	do {
+		String tmp = next_token(s, copy_start, copy_end, cvt_paren);
+		if (tmp == tok) {
+			tok_start = copy_start;
+			tok_end = copy_end;
+			return true;
+		}
+	} while (copy_end < s.size());
+
+	return false;
+}
+
+bool is_define(String s) {
+	return get_token(s) == "define";
+}
+
+bool is_define(String s, String t) {
+	uint t1, t2 = 0;
+	return next_token(s, t1, t2) == "define" &&
+	       next_token(s, t1, t2) == t;
+}
+
+bool is_start_textmode(String s) {
+	uint start_char, end_char = 0;
+	if (next_token(s, start_char, end_char) != "define") return false;
+	String tmp = next_token(s, start_char, end_char);
+	// SENSITIVE?
+	return tmp == "text" || tmp == "synonyms";
+}
+
+bool is_end_define(String s) {
+	uint start_char, end_char = 0;
+	// SENSITIVE?
+	return (next_token(s, start_char, end_char) == "end" &&
+	        next_token(s, start_char, end_char) == "define");
+}
+
+
+extern Common::Array<String> split_lines(String data);
+
+reserved_words dir_tag_property("north", "south", "east", "west", "northwest", "northeast", "southeast", "southwest", "up", "down", "out", (char *) NULL);
+
+void GeasFile::read_into(const Common::Array<String> &in_data,
+                         String in_parent, uint cur_line, bool recurse,
+                         const reserved_words &props,
+                         const reserved_words &actions) {
+	//cerr << "r_i: Reading in from" << cur_line << ": " << in_data[cur_line] << endl;
+	//output.push_back (GeasBlock());
+	//GeasBlock &out_block = output[output.size() - 1];
+	int blocknum = blocks.size();
+	blocks.push_back(GeasBlock());
+	GeasBlock &out_block = blocks[blocknum];
+
+	Common::Array<String> &out_data = out_block.data;
+	out_block.parent = in_parent;
+	uint t1, t2;
+	String line = in_data[cur_line];
+	// SENSITIVE?
+	assert(first_token(line, t1, t2) == "define");
+	String blocktype = out_block.blocktype = next_token(line, t1, t2);  // "object", or the like
+	//cerr << "r_i: Pushing back block of type " << blocktype << "\n";
+	type_indecies[blocktype].push_back(blocknum);
+	String name = next_token(line, t1, t2);  // "<itemname>", or the like
+
+	// SENSITIVE?
+	if (blocktype == "game") {
+		out_block.name = "game";
+		out_data.push_back("game name " + name);
+	} else if (is_param(name))
+		out_block.name = param_contents(name);
+	else if (name != "")
+		error("Expected parameter; %s found instead.", name.c_str());
+	//out_block.lname = lcase (out_block.nname);
+
+	// apparently not all block types are unique ... TODO which?
+	// SENSITIVE?
+	if (blocktype == "room" || blocktype == "object" || blocktype == "game")
+		register_block(out_block.name, blocktype);
+	//register_block (out_block.lname, blocktype);
+
+	// SENSITIVE?
+	if (blocktype == "room" && find_by_name("type", "defaultroom"))
+		out_data.push_back("type <defaultroom>");
+	// SENSITIVE?
+	if (blocktype == "object" && find_by_name("type", "default"))
+		out_data.push_back("type <default>");
+
+	cur_line ++;
+	uint depth = 1;
+	while (cur_line < in_data.size() && depth > 0) {
+		line = in_data[cur_line];
+		if (recurse && is_define(line))
+			++ depth;
+		else if (is_end_define(in_data[cur_line]))
+			-- depth;
+		else if (depth == 1) {
+			//cerr << "r_i: Processing line #" << cur_line << ": " << line << endl;
+			//String dup_data = "";
+			String tok = first_token(line, t1, t2);
+			String rest = next_token(line, t1, t2);
+
+			//cerr << "r_i: tok == '" << tok << "', props[tok] == " << props[tok]
+			//     << ", actions[tok] == " << actions[tok] << "\n";
+
+			if (props[tok] && dir_tag_property[tok])
+				out_data.push_back(line);
+
+			if (props[tok] && rest == "") {
+				//cerr << "r_i: Handling as props <tok>\n";
+				line = "properties <" + tok + ">";
+			} else if (props[tok] && is_param(rest)) {
+				//cerr << "r_i: Handling as props <tok = ...>\n";
+				line = "properties <" + tok + "=" + param_contents(rest) + ">";
+			} else if (actions[tok] &&
+			           (tok == "use" || tok == "give" || !is_param(rest))) {
+				//cerr << "r_i: Handling as action '" << tok << "'\n";
+				// SENSITIVE?
+				if (tok == "use") {
+					//cerr << "r_i: ********** Use line: <" + line + "> ---> ";
+					String lhs = "action <use ";
+					// SENSITIVE?
+					if (rest == "on") {
+						rest = next_token(line, t1, t2);
+						String rhs = line.substr(t2);
+						// SENSITIVE?
+						if (rest == "anything")
+							line = lhs + "on anything> " + rhs;
+						// SENSITIVE?
+						else if (is_param(rest))
+							line = lhs + "on " + param_contents(rest) + "> " + rhs;
+						else {
+							//cerr << "r_i: Error handling '" << line << "'" << endl;
+							line = "ERROR: " + line;
+						}
+					}
+					// SENSITIVE?
+					else if (rest == "anything")
+						line = lhs + "anything> " + line.substr(t2);
+					else if (is_param(rest))
+						line = lhs + param_contents(rest) + "> " + line.substr(t2);
+					else
+						line = "action <use> " + line.substr(t1);
+					//cerr << "r_i: <" << line << ">\n";
+				}
+				// SENSITIVE?
+				else if (tok == "give") {
+					String lhs = "action <give ";
+					// SENSITIVE?
+					if (rest == "to") {
+						rest = next_token(line, t1, t2);
+						String rhs = line.substr(t2);
+						// SENSITIVE?
+						if (rest == "anything")
+							line = lhs + "to anything> " + rhs;
+						else if (is_param(rest))
+							line = lhs + "to " + param_contents(rest) + "> " + rhs;
+						else {
+							cerr << "Error handling '" << line << "'" << endl;
+							line = "ERROR: " + line;
+						}
+					}
+					// SENSITIVE?
+					else if (rest == "anything")
+						line = lhs + "anything> " + line.substr(t2);
+					else if (is_param(rest))
+						line = lhs + param_contents(rest) + "> " + line.substr(t2);
+					else
+						line = "action <give> " + line.substr(t1);
+				} else
+					line = "action <" + tok + "> " + line.substr(t1);
+			}
+			//else
+			//  cerr << "Handling as ordinary line\n";
+
+			// recalculating tok because it might have changed
+			/* TODO: Make sure this only happens on object-type blocks */
+			tok = first_token(line, t1, t2);
+			// SENSITIVE?
+			if (tok == "properties") {
+				rest = next_token(line, t1, t2);
+				if (is_param(rest)) {
+					vstring items = split_param(param_contents(rest));
+					for (uint i = 0; i < items.size(); i ++)
+						out_data.push_back("properties <" +
+						                   static_eval(items[i]) + ">");
+				} else
+					out_data.push_back("ERROR " + line);
+			} else
+				out_data.push_back(line);
+
+			//if (dup_data != "")
+			//  out_data.push_back (dup_data);
+		}
+		cur_line ++;
+	}
+}
+
+GeasFile::GeasFile(const Common::Array<String> &v, GeasInterface *_gi) : gi(_gi) {
+	uint depth = 0;
+
+	String parentname, parenttype;
+
+	static String pass_names[] = {
+		"game", "type", "room", "variable", "object", "procedure",
+		"function", "selection", "synonyms", "text", "timer"
+	};
+
+	reserved_words recursive_passes("game", "room", (char *) NULL),
+	               object_passes("game", "room", "objects", (char *) NULL);
+
+
+	//Common::Array <GeasBlock> outv;
+	for (uint pass = 0; pass < sizeof(pass_names) / sizeof(*pass_names);
+	        pass ++) {
+		String this_pass = pass_names[pass];
+		bool recursive = recursive_passes[this_pass];
+		//bool is_object = object_passes[this_pass];
+
+		reserved_words actions((char *) NULL), props((char *) NULL);
+		// SENSITIVE?
+		if (this_pass == "room") {
+			props = reserved_words("look", "alias", "prefix", "indescription", "description", "north", "south", "east", "west", "northeast", "northwest", "southeast", "southwest", "out", "up", "down", (char *) NULL);
+			actions = reserved_words("description", "script", "north", "south", "east", "west", "northeast", "northwest", "southeast", "southwest", "out", "up", "down", (char *) NULL);
+		}
+		// SENSITIVE?
+		else if (this_pass == "object") {
+			props = reserved_words("look", "examine", "speak", "take", "alias", "prefix", "suffix", "detail", "displaytype", "gender", "article", "hidden", "invisible", (char *) NULL);
+			actions = reserved_words("look", "examine", "speak", "take", "gain", "lose", "use", "give", (char *) NULL);
+		}
+
+		depth = 0;
+		for (uint i = 0; i < v.size(); i ++)
+			if (is_define(v[i])) {
+				++ depth;
+				String blocktype = nth_token(v[i], 2);
+				if (depth == 1) {
+					parenttype = blocktype;
+					parentname = nth_token(v[i], 3);
+
+					// SENSITIVE?
+					if (blocktype == this_pass)
+						read_into(v, "", i, recursive, props, actions);
+				} else if (depth == 2 && blocktype == this_pass) {
+					// SENSITIVE?
+					if (this_pass == "object" && parenttype == "room")
+						read_into(v, parentname, i, false, props, actions);
+					// SENSITIVE?
+					else if (this_pass == "variable" && parenttype == "game")
+						read_into(v, "", i, false, props, actions);
+				}
+			} else if (is_end_define(v[i]))
+				-- depth;
+	}
+
+}
+
+bool decompile(String data, Common::Array<String> &rv);
+
+bool preprocess(Common::Array<String> v, String fname, Common::Array<String> &rv, GeasInterface *gi);
+
+GeasFile read_geas_file(GeasInterface *gi, const String &filename) {
+	//return GeasFile (split_lines(gi->get_file(s)), gi);
+	String file_contents = gi->get_file(filename);
+
+	if (file_contents == "")
+		return GeasFile();
+
+	Common::Array<String> data;
+	bool success;
+
+	cerr << "Header is '" << file_contents.substr(0, 7) << "'.\n";
+	if (file_contents.size() > 8 && file_contents.substr(0, 7) == "QCGF002") {
+		cerr << "Decompiling\n";
+		success = decompile(file_contents, data);
+	} else {
+		cerr << "Preprocessing\n";
+		success = preprocess(split_lines(file_contents), filename, data, gi);
+	}
+
+	cerr << "File load was " << (success ? "success" : "failure") << "\n";
+
+	if (success)
+		return GeasFile(data, gi);
+
+	gi->debug_print("Unable to read file " + filename);
+	return GeasFile();
+}
+
+Common::WriteStream &operator<<(Common::WriteStream &o, const GeasBlock &gb) {
+	//o << "Block " << gb.blocktype << " '" << gb.nname;
+	o << "Block " << gb.blocktype << " '" << gb.name;
+	if (gb.parent != "")
+		o << "' and parent '" << gb.parent;
+	o << "'\n";
+	for (uint i = 0; i < gb.data.size(); i ++)
+		o << "    " << gb.data[i] << "\n";
+	o << "\n";
+	return o;
+}
+
+void print_vblock(Common::WriteStream &o, String blockname, const Common::Array<GeasBlock> &blocks) {
+	o << blockname << ":\n";
+	for (uint i = 0; i < blocks.size(); i ++)
+		o << "  " << blocks[i] << "\n";
+	o << "\n";
+}
+
+Common::WriteStream &operator<<(Common::WriteStream &o, const GeasFile &gf) {
+	/*
+	o << "Geas File\nThing-type blocks:\n";
+	for (uint i = 0; i < gf.things.size(); i ++)
+	  o << gf.things[i];
+	o << "\nOther-type blocks:\n";
+	for (uint i = 0; i < gf.others.size(); i ++)
+	  o << gf.others[i];
+	*/
+	o << "Geas File\n";
+	for (StringArrayIntMap::const_iterator i = gf.type_indecies.begin(); i != gf.type_indecies.end(); i ++) {
+		o << "Blocks of type " << (*i)._key << "\n";
+		for (uint j = 0; j < (*i)._value.size(); j ++)
+			o << gf.blocks[(*i)._value[j]];
+		o << "\n";
+	}
+
+	/*
+	o << "Geas File\n";
+	print_vblock (o, "game",        gf.game);
+	print_vblock (o, "rooms",       gf.rooms);
+	print_vblock (o, "objects",     gf.objects);
+	print_vblock (o, "text blocks", gf.textblocks);
+	print_vblock (o, "functions",   gf.functions);
+	print_vblock (o, "procedures",  gf.procedures);
+	print_vblock (o, "types",       gf.types);
+	print_vblock (o, "synonyms",    gf.synonyms);
+	print_vblock (o, "timers",      gf.timers);
+	print_vblock (o, "variables",   gf.variables);
+	print_vblock (o, "choices",     gf.choices);
+	*/
+	o << endl;
+	return o;
+}
+
+
+
+
+
+String compilation_tokens[256] = {
+	"", "game", "procedure", "room", "object", "character", "text", "selection",
+	"define", "end", "", "asl-version", "game", "version", "author", "copyright",
+	"info", "start", "possitems", "startitems", "prefix", "look", "out", "gender",
+	"speak", "take", "alias", "place", "east", "north", "west", "south", "give",
+	"hideobject", "hidechar", "showobject", "showchar", "collectable",
+	"collecatbles", "command", "use", "hidden", "script", "font", "default",
+	"fontname", "fontsize", "startscript", "nointro", "indescription",
+	"description", "function", "setvar", "for", "error", "synonyms", "beforeturn",
+	"afterturn", "invisible", "nodebug", "suffix", "startin", "northeast",
+	"northwest", "southeast", "southwest", "items", "examine", "detail", "drop",
+	"everywhere", "nowhere", "on", "anything", "article", "gain", "properties",
+	"type", "action", "displaytype", "override", "enabled", "disabled",
+	"variable", "value", "display", "nozero", "onchange", "timer", "alt", "lib",
+	"up", "down", "gametype", "singleplayer", "multiplayer", "", "", "", "", "",
+	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+	"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
+	"", "", "", "", "", "", "", "", "", "", "", "do", "if", "got", "then", "else",
+	"has", "say", "playwav", "lose", "msg", "not", "playerlose", "playerwin",
+	"ask", "goto", "set", "show", "choice", "choose", "is", "setstring",
+	"displaytext", "exec", "pause", "clear", "debug", "enter", "movechar",
+	"moveobject", "revealchar", "revealobject", "concealchar", "concealobject",
+	"mailto", "and", "or", "outputoff", "outputon", "here", "playmidi", "drop",
+	"helpmsg", "helpdisplaytext", "helpclear", "helpclose", "hide", "show",
+	"move", "conceal", "reveal", "numeric", "String", "collectable", "property",
+	"create", "exit", "doaction", "close", "each", "in", "repeat", "while",
+	"until", "timeron", "timeroff", "stop", "panes", "on", "off", "return",
+	"playmod", "modvolume", "clone", "shellexe", "background", "foreground",
+	"wait", "picture", "nospeak", "animate", "persist", "inc", "dec", "flag",
+	"dontprocess", "destroy", "beforesave", "onload", "", "", "", "", "", "",
+	"", "", "", "", "", "", "", "", "", "", "", ""
+};
+
+
+bool decompile(String s, Common::Array<String> &rv) {
+	String cur_line, tok;
+	uint expect_text = 0, obfus = 0;
+	unsigned char ch;
+
+	for (uint i = 8; i < s.size(); i ++) {
+		ch = s[i];
+		if (obfus == 1 && ch == 0) {
+			cur_line += "> ";
+			obfus = 0;
+		} else if (obfus == 1)
+			cur_line += char (255 - ch);
+		else if (obfus == 2 && ch == 254) {
+			obfus = 0;
+			cur_line += " ";
+		} else if (obfus == 2)
+			cur_line += ch;
+		else if (expect_text == 2) {
+			if (ch == 253) {
+				expect_text = 0;
+				rv.push_back(cur_line);
+				cur_line = "";
+			} else if (ch == 0) {
+				rv.push_back(cur_line);
+				cur_line = "";
+			} else
+				cur_line += char (255 - ch);
+		} else if (obfus == 0 && ch == 10) {
+			cur_line += "<";
+			obfus = 1;
+		} else if (obfus == 0 && ch == 254)
+			obfus = 2;
+		else if (ch == 255) {
+			if (expect_text == 1)
+				expect_text = 2;
+			rv.push_back(cur_line);
+			cur_line = "";
+		} else {
+			tok = compilation_tokens[ch];
+			if ((tok == "text" || tok == "synonyms" || tok == "type") &&
+			        cur_line == "define ")
+				expect_text = 1;
+			cur_line += tok + " ";
+		}
+	}
+	rv.push_back(cur_line);
+
+	for (uint i = 0; i < rv.size(); i ++)
+		cerr << "rv[" << i << "]: " << rv[i] << "\n";
+
+	return true;
+}
+
+
+
+
+
+
+
+
+Common::Array<String> tokenize(String s) {
+	uint tok_start, tok_end;
+	String tok;
+	Common::Array<String> rv;
+	tok_end = 0;
+	while (tok_end + 1 <= s.size())
+		rv.push_back(next_token(s, tok_start, tok_end));
+	return rv;
+}
+
+String string_int(int i) {
+	ostringstream o;
+	o << i;
+	return o.str();
+}
+
+void report_error(String s) {
+	//cerr << s << endl;
+	cerr << s << endl;
+	throw s;
+}
+
+Common::Array<String> split_lines(String data) {
+	Common::Array <String> rv;
+	String tmp;
+	uint i = 0;
+	while (i < data.size()) {
+		//cerr << "data[" << i << "] == " << int(data[i]) << '\n';
+
+		if (data[i] == '\n' || data[i] == '\r') {
+			/*
+			if (data[i] == '\n' && i < data.size() && data[i+1] == '\r')
+			  ++ i;
+			*/
+			if (tmp.size() > 0 && tmp[tmp.size() - 1] == '_') {
+				//cerr << "Line with trailing underscores: " << tmp << '\n';
+				tmp.erase(tmp.size() - 1);
+				if (tmp[tmp.size() - 1] == '_')
+					tmp.erase(tmp.size() - 1);
+				if (i < data.size() && data[i] == '\r' && data[i + 1] == '\n')
+					++ i;
+				++ i;
+				//cerr << "   WSK: data[" << i<< "] == " << int(data[i]) << '\n';
+				while (i < data.size() && data[i] != '\r' &&
+				        data[i] != '\n' && Common::isSpace(data[i])) {
+					//cerr << "   WS: data[" << i<< "] = " << int(data[i]) << '\n';
+					++ i;
+				}
+				//cerr << "   WS: data[" << i<< "] == " << int(data[i]) << '\n';
+				-- i;
+			} else {
+				//cerr << "Pushing back {<{" << tmp << "}>}\n";
+				rv.push_back(tmp);
+				tmp = "";
+				if (i < data.size() && data[i] == '\r' && data[i + 1] == '\n')
+					++ i;
+			}
+		} else
+			tmp += data[i];
+		++ i;
+	}
+	if (tmp != "")
+		rv.push_back(tmp);
+	return rv;
+}
+
+void show_tokenize(String s) {
+	//cerr << "s_t: Tokenizing '" << s << "' --> " << tokenize(s) << endl;
+}
+
+void say_push(const Common::Array<String> &v) {
+	//cerr << "s_p: Pushing '" << v[v.size() - 1] << "'" << endl;
+}
+
+
+
+
+
+//enum trim_modes { TRIM_SPACES, TRIM_UNDERSCORE, TRIM_BRACE };
+
+//String trim (String s, trim_modes trim_mode = TRIM_SPACES)
+String trim(String s, trim_modes trim_mode) {
+	uint i, j;
+	/*
+	cerr << "Trimming (" << s << "): [";
+	for (i = 0; i < s.size(); i ++)
+	  cerr << int (s[i]) << "(" << s[i] << "), ";
+	cerr << "]\n";
+	*/
+	for (i = 0; i < s.size() && Common::isSpace(s[i]); i ++)
+		;
+	if (i == s.size()) return "";
+	if ((trim_mode == TRIM_UNDERSCORE   &&  s[i] == '_') ||
+	        (trim_mode == TRIM_BRACE        &&  s[i] == '['))
+		++ i;
+	if (i == s.size()) return "";
+	for (j = s.size() - 1; Common::isSpace(s[j]); j --)
+		;
+	if ((trim_mode == TRIM_UNDERSCORE && i < s.size() && s[j] == '_') ||
+	        (trim_mode == TRIM_BRACE && i < s.size()      && s[j] == ']'))
+		-- j;
+	return s.substr(i, j - i + 1);
+}
+
+/* bool is_balanced (String)
+ *
+ * Decides whether the String has balanced braces (and needn't be deinlined)
+ * - Track the nesting depth, starting at first lbrace to end of line
+ * - If it is ever at depth 0 before the end, it's balanced
+ * - Otherwise, it's unbalanced
+ */
+bool is_balanced(String str) {
+	uint index = str.find('{');
+	if (index == -1)
+		return true;
+	int depth;
+	for (depth = 1, index ++;  depth > 0 && index < str.size();  index ++)
+		if (str[index] == '{')
+			++ depth;
+		else if (str[index] == '}')
+			-- depth;
+	return depth == 0;
+}
+
+int count_depth(String str, int count) {
+	//cerr << "count_depth (" << str << ", " << count << ")" << endl;
+	uint index = 0;
+	if (count == 0)
+		index = str.find('{');
+	while (index < str.size()) {
+		if (str[index] == '{')
+			++ count;
+		else if (str[index] == '}')
+			-- count;
+		//cerr << "    After char #" << index << ", count is " << count << endl;
+		++ index;
+	}
+	//cerr << "returning " << count << endl;
+	return count;
+}
+
+void handle_includes(const Common::Array<String> &in_data, String filename, Common::Array<String> &out_data, GeasInterface *gi) {
+	String line, tok;
+	uint tok_start, tok_end;
+	for (uint ln = 0; ln < in_data.size(); ln ++) {
+		line = in_data[ln];
+		tok = first_token(line, tok_start, tok_end);
+		if (tok == "!include") {
+			tok = next_token(line, tok_start, tok_end);
+			if (!is_param(tok)) {
+				gi->debug_print("Expected parameter after !include");
+				continue;
+			}
+			//handle_includes (split_lines (gi->get_file (param_contents (tok))), out_data, gi);
+			String newname = gi->absolute_name(param_contents(tok), filename);
+			handle_includes(split_lines(gi->get_file(newname)), newname, out_data, gi);
+		} else if (tok == "!QDK") {
+			while (ln < in_data.size() &&
+			        first_token(in_data[ln], tok_start, tok_end) != "!end")
+				++ ln;
+		} else
+			out_data.push_back(line);
+	}
+}
+
+bool preprocess(Common::Array<String> v, String fname, Common::Array<String> &rv,
+                GeasInterface *gi) {
+	//cerr << "Before preprocessing:\n" << v << "\n\n" << endl;
+	/*
+	  cerr << "Before preprocessing:\n";
+	for (uint i = 0; i < v.size(); i ++)
+	  cerr << i << ": " << v[i] << "\n";
+	cerr << "\n\n";
+	*/
+
+	// TODO: Is it "!=" or "<>" or both, and if both, which has priority?
+	static String comps[][2] = {
+		{ "<>", "!=;" },  { "!=", "!=;" },  { "<=", "lt=;" },  { ">=", "gt=;" },
+		{ "<",  "lt;" },  { ">",  "gt;" },  { "=",  "" }
+	};
+
+	uint tok_start, tok_end;
+	String tok;
+
+	// preprocessing step 0:
+	// Loop through the lines.  Replace !include with appropriate text
+
+	Common::Array<String> v2;
+	handle_includes(v, fname, v2, gi);
+	v.clear();
+
+	StringArrayStringMap addtos;
+	for (uint line = 0; line < v2.size(); line ++) {
+		//cerr << "Line #" << line << ", looking for addtos: " << v2[line] << endl;
+		tok = first_token(v2[line], tok_start, tok_end);
+		if (tok == "!addto") {
+			tok = next_token(v2[line], tok_start, tok_end);
+			if (!(tok == "game" || tok == "synonyms" || tok == "type")) {
+				gi->debug_print("Error: Had addto for '" + tok + "'.");
+				continue;
+			}
+			if (tok == "type") {
+				String tmp = next_token(v2[line], tok_start, tok_end);
+				if (!(tmp == "<default>" || tmp == "<defaultroom>")) {
+					gi->debug_print("Error: Bad addto '" + v2[line] + "'\n");
+					continue;
+				}
+				tok = tok + " " + tmp;
+			}
+			++ line; // skip !addto
+			while (line < v2.size() &&
+			        first_token(v2[line], tok_start, tok_end) != "!end")
+				addtos[tok].push_back(v2[line ++]);
+		}
+	}
+	for (uint line = 0; line < v2.size(); line ++) {
+		tok = first_token(v2[line], tok_start, tok_end);
+		if (tok == "!addto") {
+			while (line < v2.size() &&
+			        first_token(v2[line], tok_start, tok_end) != "!end")
+				line ++;
+		} else {
+			v.push_back(v2[line]);
+			if (tok == "define") {
+				// TODO: What if there's a !addto for a block other than
+				// game, synonyms, default, defaultroom?
+				//
+				// Also, do the !addto'ed lines go at the front or end?
+				tok = next_token(v2[line], tok_start, tok_end);
+				if (tok == "type")
+					tok = tok + " " + next_token(v2[line], tok_start, tok_end);
+
+				if (addtos.find(tok) != addtos.end()) {
+					Common::Array<String> &lines = addtos[tok];
+					for (uint line2 = 0; line2 < lines.size(); line2 ++)
+						v.push_back(lines[line2]);
+					addtos.erase(tok);
+				}
+			}
+		}
+	}
+	//cerr << "Done looking for addtos" << endl;
+	v2.clear();
+
+	for (StringArrayStringMap::iterator i = addtos.begin(); i != addtos.end(); i ++) {
+		v.push_back("define " + i->_key);
+		for (uint j = 0; j < i->_value.size(); j ++)
+			v.push_back(i->_value[j]);
+		v.push_back("end define");
+	}
+	/*
+	if (addtos.find("<default>") != addtos.end())
+	  {
+	    Common::Array<String> &lines = addtos ["<default>"];
+	    v.push_back ("define type <default>");
+	    for (uint i = 0; i < lines.size(); i ++)
+	v.push_back (lines[i]);
+	    v.push_back ("end define");
+	  }
+
+	if (addtos.find("<defaultroom>") != addtos.end())
+	  {
+	    Common::Array<String> &lines = addtos ["<defaultroom>"];
+	    v.push_back ("define type <defaultroom>");
+	    for (uint i = 0; i < lines.size(); i ++)
+	v.push_back (lines[i]);
+	    v.push_back ("end define");
+	  }
+	*/
+	/*
+	cerr << "Done special-pushing <default> and <defaultroom>\n";
+	cerr << "After includes & addtos:\n";
+	for (uint i = 0; i < v.size(); i ++)
+	  cerr << i << ": " << v[i] << "\n";
+	cerr << "\n\n";
+	*/
+
+	// Preprocessing step 1:
+	// Loop through the lines.  Look for "if/and/or (.. <.. )" or the like
+	// If there is such a pair, convert the second to "if/and/or is <..;lt;..>"
+
+	for (uint line = 0; line < v.size(); line ++) {
+		tok_end = 0;
+		while (tok_end < v[line].size()) {
+			tok = next_token(v[line], tok_start, tok_end, false);
+			if (tok == "if" || tok == "repeat" || tok == "until" ||
+			        tok == "and" || tok == "or") {
+				tok = next_token(v[line], tok_start, tok_end, true);
+				//cerr << "Checking for comparison {" << tok << "}\n";
+				if (tok.size() > 2 && tok[0] == '(' &&
+				        tok [tok.size() - 1] == ')') {
+					//cerr << "   IT IS!\n";
+					tok = tok.substr(1, tok.size() - 2);
+					String str = v[line];
+					int cmp_start;
+					for (uint cmp = 0; cmp < ARRAYSIZE(comps); cmp ++)
+						if ((cmp_start = tok.find(comps[cmp][0])) != -1) {
+							uint cmp_end = cmp_start + comps[cmp][0].size();
+							//cerr << "Changed str from {" << str << "} to {";
+							str = str.substr(0, tok_start) +
+							      "is <" + trim(tok.substr(0, cmp_start)) + ";" +
+							      comps[cmp][1] +
+							      trim(tok.substr(cmp_end)) + ">" +
+							      str.substr(tok_end);
+							//cerr << str << "}\n";
+							cmp = ARRAYSIZE(comps);
+							v[line] = str;
+							tok_end = tok_start; // old value of tok_end invalid
+						}
+				}
+			}
+		}
+	}
+	//cerr << "Done with pass 1!" << endl;
+
+	// Pass 2:  Extract comments from non-text blocks
+	bool in_text_block = false;
+	for (uint line = 0; line < v.size(); line ++) {
+		//cerr << "Checking line '" << v[line] << "' for comments\n";
+		if (!in_text_block && is_start_textmode(v[line]))
+			in_text_block = true;
+		else if (in_text_block && is_end_define(v[line]))
+			in_text_block = false;
+		else if (!in_text_block) {
+			//cerr << "  checking...\n";
+			uint start_ch = 0, end_ch = 0;
+			while (start_ch < v[line].size())
+				if (next_token(v[line], start_ch, end_ch)[0] == '\'') {
+					v[line] = v[line].substr(0, start_ch);
+					//cerr << "  abbreviating to '" << v[line] << "'\n";
+					break;
+				}
+		}
+	}
+	//cerr << "Done with pass 2!" << endl;
+
+	/* There should be a pass 2.5: check that lbraces count equals
+	 * rbrace count, but I'm skipping that
+	 */
+
+	// Pass 3: Deinline braces
+	in_text_block = false;
+	int int_proc_count = 0;
+	for (uint line = 0; line < v.size(); line ++) {
+		//cerr << "Pass 3, line #" << line << endl;
+		String str = v[line];
+		if (!in_text_block && is_start_textmode(str))
+			in_text_block = true;
+		else if (in_text_block && is_end_define(str))
+			in_text_block = false;
+		else if (!is_balanced(str)) {
+			//cerr << "...Special line!" << endl;
+			uint init_size = v.size();
+			v.push_back("define procedure <!intproc" +
+			            string_int(++int_proc_count) + ">");
+			//cerr << "Pushing back on v: '" << v[v.size()-1] << "'" << endl;
+
+
+			uint tmp_index = str.find('{');
+			v2.push_back(trim(str.substr(0, tmp_index)) +
+			             " do <!intproc" + string_int(int_proc_count) + "> ");
+			//cerr << "Done with '" << v2[v2.size()-1] << "'" << endl;
+
+			{
+				/*
+				String tmp_str = trim (str.substr (tmp_index + 1));
+				if (tmp_str != "")
+				  {
+				v.push_back (tmp_str);
+				cerr << "Pushing back on v: '" << v[v.size()-1] << "'" << endl;
+				  }
+				*/
+				v.push_back(str.substr(tmp_index + 1));
+				//cerr << "Pushing back on v: '" << v[v.size()-1] << "'" << endl;
+			}
+
+			int count = count_depth(str, 0);
+			while (++ line < init_size && count != 0) {
+				str = v[line];
+				count = count_depth(str, count);
+				if (count != 0) {
+					/*
+					str = trim(str);
+					if (str != "")
+					  {
+					    v.push_back (str);
+					    cerr << "Pushing back on v: '" << str << "'" << endl;
+					  }
+					*/
+					v.push_back(str);
+					//cerr << "Pushing back on v: '" << str << "'" << endl;
+				}
+			}
+			if (count != 0) {
+				report_error("Braces Unbalanced");
+				return false;
+			}
+			tmp_index = str.rfind('}');
+			{
+				/*
+				String tmp2 = trim (str.substr (0, tmp_index));
+				if (tmp2 != "")
+				  v.push_back (tmp2);
+				*/
+				v.push_back(str.substr(0, tmp_index));
+				//cerr << "Pushing back on v: '" << v[v.size()-1] << "'" << endl;
+			}
+
+			v.push_back("end define");
+			//cerr << "Pushing back on v: '" << v[v.size()-1] << "'" << endl;
+			//cerr << "Done with special line" << endl;
+			line --;
+			continue;
+			// The continue is to avoid the v2.push_back(...);
+			// this block pushes stuff onto v2 on its own.
+		}
+		//cerr << "Done with '" << str << "'" << endl;
+		v2.push_back(str);
+	}
+	//cerr << "Done with pass 3!" << endl;
+
+	/* Pass 4:  trim lines, drop blank lines, combine elses */
+
+	in_text_block = false;
+	int_proc_count = 0;
+	for (uint line = 0; line < v2.size(); line ++) {
+		String str = v2[line];
+		//cerr << "Pass 4, line #" << line << ", " << in_text_block << ": '" << str << "'\n";
+		if (!in_text_block && is_start_textmode(str))
+			in_text_block = true;
+		else if (in_text_block && is_end_define(str))
+			in_text_block = false;
+		else if (rv.size() > 0 && !in_text_block && get_token(str) == "else") {
+			rv[rv.size() - 1] = rv[rv.size() - 1] + " " + trim(str);
+			//cerr << "  Replacing else: " << rv[rv.size() - 1] << "\n";
+			continue;
+		}
+		if (!in_text_block)
+			str = trim(str);
+		if (in_text_block || str != "")
+			rv.push_back(str);
+		//if (rv.size() > 0)
+		//  cerr << "  Result: " << rv[rv.size() - 1] << "\n";
+	}
+
+	/*
+	cerr << "At end of procedure, v == " << v << "\n";
+	cerr << "and v2 == " << v2 << "\n";
+	cerr << "and rv == " << rv << "\n";
+	*/
+	//rv = v2;
+
+	/*
+	cerr << "After all preprocessing\n";
+	for (uint i = 0; i < rv.size(); i ++)
+	  cerr << i << ": " << rv[i] << "\n";
+	cerr << "\n\n";
+	*/
+
+	return true;
+	//return v2;
+}
+
+
+void show_find(String s, char ch) {
+	cerr << "Finding '" << ch << "' in '" << s << "': " << s.find(ch) + 1 << endl;
+}
+
+void show_trim(String s) {
+	cerr << "Trimming '" << s << "': spaces (" << trim(s)
+	     << "), underscores (" << trim(s, TRIM_UNDERSCORE)
+	     << "), braces (" << trim(s, TRIM_BRACE) << ").\n";
+
+	//cerr << "Trimming '" << s << "': '" << trim (s) << "'\n";
+}
+
+template<class T> Common::Array<T> &operator<< (Common::Array<T> &v, T val) {
+	v.push_back(val);
+	return v;
+}
+
+template<class T> class makevector {
+	Common::Array<T> dat;
+public:
+	makevector<T> &operator<<(T it) {
+		dat.push_back(it);
+		return *this;
+	}
+	operator Common::Array<T>() {
+		return dat;
+	}
+};
+
+Common::Array <String> split(String s, char ch) {
+	uint i = 0, j;
+	Common::Array<String> rv;
+	do {
+		//cerr << "split (" << s << "): i == " << i << ", j == " << j << endl;
+		j = s.find(ch, i);
+		if (i != j)
+			rv.push_back(s.substr(i, j - i));
+		i = j + 1;
+	} while (j < s.size());
+
+	//cerr << rv << endl;
+	return rv;
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/read_file.h b/engines/glk/quest/read_file.h
new file mode 100644
index 0000000000..062234d586
--- /dev/null
+++ b/engines/glk/quest/read_file.h
@@ -0,0 +1,49 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_READ_FILE
+#define GLK_QUEST_READ_FILE
+
+#include "glk/quest/geas_file.h"
+#include "glk/quest/string.h"
+#include "common/array.h"
+
+namespace Glk {
+namespace Quest {
+
+extern Common::Array<String> tokenize(String s);
+extern String next_token(String full, uint &tok_start, uint &tok_end, bool cvt_paren = false);
+extern String first_token(String s, uint &t_start, uint &t_end);
+extern String nth_token(String s, int n);
+extern String get_token(String s, bool cvt_paren = false);
+extern bool find_token(String s, String tok, int &tok_start, int &tok_end, bool cvt_paren = false);
+extern GeasFile read_geas_file(GeasInterface *gi, const String &filename);
+
+enum trim_modes { TRIM_SPACES, TRIM_UNDERSCORE, TRIM_BRACE };
+extern String trim(String, trim_modes mode = TRIM_SPACES);
+
+//Common::WriteStream &operator<< (Common::WriteStream &o, const Common::Array<String> &v);
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/reserved_words.h b/engines/glk/quest/reserved_words.h
new file mode 100644
index 0000000000..5d736078b7
--- /dev/null
+++ b/engines/glk/quest/reserved_words.h
@@ -0,0 +1,84 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_RESERVED_WORDS
+#define GLK_QUEST_RESERVED_WORDS
+
+#include "glk/quest/string.h"
+#include "common/hashmap.h"
+#include "common/stream.h"
+
+namespace Glk {
+namespace Quest {
+
+class reserved_words {
+private:
+	StringBoolMap _data;
+
+public:
+	/**
+	 * Constructor
+	 */
+	reserved_words(const char *c, ...) {
+		va_list ap;
+		va_start(ap, c);
+
+		while (c != nullptr) {
+			_data[String(c)] = true;
+			c = va_arg(ap, const char *);
+		}
+	}
+
+	/**
+	 * Returns true if the passed string is a reserved word
+	 */
+	bool operator[](const String &s) const {
+		return has(s);
+	}
+
+	/**
+	 * Returns true if the passed string is a reserved word
+	 */
+	bool has(const String &s) const {
+		return _data.contains(s) && (*this)[s];
+	}
+
+	/**
+	 * Dumps the list of reserved words to the passed output stream
+	 */
+	void dump(Common::WriteStream &o) const {
+		o.writeString("RW {");
+
+		for (StringBoolMap::iterator i = _data.begin(); i != _data.end(); ++i) {
+			if (i != _data.begin())
+				o.writeString(", ");
+			o.writeString((*i)._key);
+		}
+
+		o.writeString("}");
+	}
+};
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/streams.cpp b/engines/glk/quest/streams.cpp
new file mode 100644
index 0000000000..37ea04298a
--- /dev/null
+++ b/engines/glk/quest/streams.cpp
@@ -0,0 +1,78 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/streams.h"
+#include "common/debug.h"
+#include "common/str.h"
+
+namespace Glk {
+namespace Quest {
+
+ConsoleStream *g_cerr;
+const char endl = '\n';
+
+void Streams::initialize() {
+	g_cerr = new ConsoleStream();
+}
+
+void Streams::deinitialize() {
+	delete g_cerr;
+}
+
+uint32 ConsoleStream::write(const void *dataPtr, uint32 dataSize) {
+	Common::String s((const char *)dataPtr, (const char *)dataPtr + dataSize);
+	debug("%s", s.c_str());
+	return dataSize;
+}
+
+/*--------------------------------------------------------------------------*/
+
+String ostringstream::str() {
+	return String((const char *)getData(), (const char *)getData() + size());
+}
+
+/*--------------------------------------------------------------------------*/
+
+Common::WriteStream &operator<<(Common::WriteStream &ws, const String &s) {
+	ws.writeString(s);
+	return ws;
+}
+
+Common::WriteStream &operator<<(Common::WriteStream &ws, char c) {
+	ws.writeByte(c);
+	return ws;
+}
+
+Common::WriteStream &operator<<(Common::WriteStream &ws, int i) {
+	Common::String s = Common::String::format("%d", i);
+	ws.writeString(s);
+	return ws;
+}
+
+Common::WriteStream &operator<<(Common::WriteStream &ws, uint i) {
+	Common::String s = Common::String::format("%u", i);
+	ws.writeString(s);
+	return ws;
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/streams.h b/engines/glk/quest/streams.h
new file mode 100644
index 0000000000..3a8d2a4a60
--- /dev/null
+++ b/engines/glk/quest/streams.h
@@ -0,0 +1,85 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_STREAMS
+#define GLK_QUEST_STREAMS
+
+#include "glk/quest/string.h"
+#include "common/memstream.h"
+#include "common/stream.h"
+
+namespace Glk {
+namespace Quest {
+
+/**
+ * Write stream wrapper around ScummVM debug calls. Can only handle text being written
+ */
+class ConsoleStream : public Common::WriteStream {
+public:
+	virtual uint32 write(const void *dataPtr, uint32 dataSize) override;
+	virtual int32 pos() const override { return 0; }
+};
+
+class ostringstream : public Common::MemoryWriteStreamDynamic {
+public:
+	ostringstream() : Common::MemoryWriteStreamDynamic(DisposeAfterUse::YES) {}
+
+	String str();
+};
+class StringStream : public ostringstream {
+public:
+	StringStream &operator>>(String &rhs) {
+		rhs = str();
+		return *this;
+	}
+};
+
+/**
+ * Simple wrapper for managing streams initialization
+ */
+class Streams {
+public:
+	/**
+	 * Initialization
+	 */
+	static void initialize();
+
+	/**
+	 * Deinitialization
+	 */
+	static void deinitialize();
+};
+
+extern ConsoleStream *g_cerr;
+extern const char endl;
+
+#define cerr (*g_cerr)
+
+Common::WriteStream &operator<<(Common::WriteStream &, const String &);
+Common::WriteStream &operator<<(Common::WriteStream &, char);
+Common::WriteStream &operator<<(Common::WriteStream &, int);
+Common::WriteStream &operator<<(Common::WriteStream &, uint);
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/string.cpp b/engines/glk/quest/string.cpp
new file mode 100644
index 0000000000..d6a17847c6
--- /dev/null
+++ b/engines/glk/quest/string.cpp
@@ -0,0 +1,99 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "glk/quest/string.h"
+
+namespace Glk {
+namespace Quest {
+
+CI_EQUAL   ci_equal_obj;
+CI_LESS    ci_less_obj;
+CI_LESS_EQ ci_less_eq_obj;
+
+String operator+(const String &x, const String &y) {
+	String temp(x);
+	temp += y;
+	return temp;
+}
+
+String operator+(const char *x, const String &y) {
+	String temp(x);
+	temp += y;
+	return temp;
+}
+
+String operator+(const String &x, const char *y) {
+	String temp(x);
+	temp += y;
+	return temp;
+}
+
+String operator+(char x, const String &y) {
+	String temp(x);
+	temp += y;
+	return temp;
+}
+
+String operator+(const String &x, char y) {
+	String temp(x);
+	temp += y;
+	return temp;
+}
+
+/*--------------------------------------------------------------------------*/
+
+// Code for testing case insensitively by John Harrison
+
+bool c_equal_i(char ch1, char ch2) {
+	return tolower((unsigned char)ch1) == tolower((unsigned char)ch2);
+}
+
+size_t ci_find(const String &str1, const String &str2) {
+	const char *pos = strstr(str1.c_str(), str2.c_str());
+	return !pos ? String::npos : pos - str1.c_str();
+}
+
+static int my_stricmp(const String &s1, const String &s2) {
+	return s1.compareToIgnoreCase(s2);
+}
+
+bool ci_equal(const String &str1, const String &str2) {
+	return my_stricmp(str1, str2) == 0;
+}
+bool ci_less_eq(const String &str1, const String &str2) {
+	return my_stricmp(str1, str2) <= 0;
+}
+bool ci_less(const String &str1, const String &str2) {
+	return my_stricmp(str1, str2) < 0;
+}
+bool ci_notequal(const String &str1, const String &str2) {
+	return !ci_equal(str1, str2);
+}
+bool ci_gt_eq(const String &str1, const String &str2) {
+	return my_stricmp(str1, str2) >= 0;
+}
+bool ci_gt(const String &str1, const String &str2) {
+	return my_stricmp(str1, str2) > 0;
+}
+
+} // End of namespace Quest
+} // End of namespace Glk
diff --git a/engines/glk/quest/string.h b/engines/glk/quest/string.h
new file mode 100644
index 0000000000..43f6ab602b
--- /dev/null
+++ b/engines/glk/quest/string.h
@@ -0,0 +1,134 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef GLK_QUEST_STRING
+#define GLK_QUEST_STRING
+
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+#include "common/str.h"
+
+namespace Glk {
+namespace Quest {
+
+class String;
+
+typedef Common::HashMap<String, String, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> StringMap;
+typedef Common::HashMap<String, bool, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> StringBoolMap;
+typedef Common::HashMap<String, Common::Array<int>, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> StringArrayIntMap;
+typedef Common::HashMap<String, Common::Array<String>, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> StringArrayStringMap;
+
+class String : public Common::String {
+public:
+	String() : Common::String() {}
+	String(const char *str) : Common::String(str) {}
+	String(const char *str, uint32 len) : Common::String(str, len) {}
+	String(const char *beginP, const char *endP) : Common::String(beginP, endP) {}
+	String(const String &str) : Common::String(str) {}
+	explicit String(char c) : Common::String(c) {}
+
+	char &operator[](int idx) {
+		assert(_str && idx >= 0 && idx < (int)_size);
+		return _str[idx];
+	}
+
+	inline uint length() const {
+		return size();
+	}
+
+	String substr(size_t pos, size_t len) const {
+		return String(c_str() + pos, c_str() + pos + len);
+	}
+	String substr(size_t pos) const {
+		return String(c_str() + pos);
+	}
+
+	int find(char c, int pos = 0) const {
+		const char *p = strchr(c_str() + pos, c);
+		return p ? p - c_str() : -1;
+	}
+
+	int find(const Common::String &s, int pos = 0) const {
+		const char *p = strstr(c_str() + pos, s.c_str());
+		return p ? p - c_str() : -1;
+	}
+
+	int rfind(char c) const {
+		const char *p = strrchr(c_str(), c);
+		return p ? p - c_str() : -1;
+	}
+
+	String trim() const {
+		String result = *this;
+		static_cast<Common::String>(result).trim();
+		return result;
+	}
+};
+
+// Append two strings to form a new (temp) string
+String operator+(const String &x, const String &y);
+
+String operator+(const char *x, const String &y);
+String operator+(const String &x, const char *y);
+
+String operator+(const String &x, char y);
+String operator+(char x, const String &y);
+
+
+bool c_equal_i(char ch1, char ch2);
+size_t ci_find(const String &str1, const String &str2);
+bool   ci_equal(const String &str1, const String &str2);
+bool   ci_less_eq(const String &str1, const String &str2);
+bool   ci_less(const String &str1, const String &str2);
+bool   ci_notequal(const String &str1, const String &str2);
+bool   ci_gt_eq(const String &str1, const String &str2);
+bool   ci_gt(const String &str1, const String &str2);
+
+class CI_EQUAL {
+public:
+	bool operator()(const String &str1, const String &str2) {
+		return ci_equal(str1, str2);
+	}
+};
+
+class CI_LESS_EQ {
+public:
+	bool operator()(const String &str1, const String &str2) {
+		return ci_less_eq(str1, str2);
+	}
+};
+
+class CI_LESS {
+public:
+	bool operator()(const String &str1, const String &str2) {
+		return ci_less(str1, str2);
+	}
+};
+
+extern CI_EQUAL   ci_equal_obj;
+extern CI_LESS    ci_less_obj;
+extern CI_LESS_EQ ci_less_eq_obj;
+
+} // End of namespace Quest
+} // End of namespace Glk
+
+#endif
diff --git a/engines/glk/quest/uncas.pl b/engines/glk/quest/uncas.pl
new file mode 100644
index 0000000000..4e5dc8ee92
--- /dev/null
+++ b/engines/glk/quest/uncas.pl
@@ -0,0 +1,471 @@
+#!/usr/bin/perl
+
+###############################################################################
+#                                                                             #
+#  Copyright (C) 2006 by Mark J. Tilford                                      #
+#                                                                             #
+#  This file is part of Geas.                                                 #
+#                                                                             #
+#  Geas is free software; you can redistribute it and/or modify               #
+#  it under the terms of the GNU General Public License as published by       #
+#  the Free Software Foundation; either version 2 of the License, or          #
+#  (at your option) any later version.                                        #
+#                                                                             #
+#  Geas is distributed in the hope that it will be useful,                    #
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of             #
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              #
+#  GNU General Public License for more details.                               #
+#                                                                             #
+#  You should have received a copy of the GNU General Public License          #
+#  along with Geas; if not, write to the Free Software                        #
+#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA #
+#                                                                             #
+###############################################################################
+
+use strict;
+
+sub mtext {
+	my $str = shift;
+	my $rv = chr(254);
+	foreach (split //, $str) {
+	$rv . = chr(255 - ord $_);
+}
+return $rv . chr(0);
+}
+
+
+sub obfus {
+	my $str = shift;
+	my $rv = chr(10);
+	foreach (split //, $str) {
+	$rv . = chr(255 - ord $_);
+}
+return $rv . chr(0);
+}
+
+my $is_raw = 0;
+
+my @hash_data =
+    ([1, 'game'], [2, 'procedure'], [3, 'room'], [4, 'object'],
+     [5, 'character'], [6, 'text'], [7, 'selection'], [8, 'define'],
+     [9, 'end'], [11, 'asl-version'], [12, 'game'], [13, 'version'],
+     [14, 'author'], [15, 'copyright'], [16, 'info'], [17, 'start'],
+     [18, 'possitems'], [19, 'startitems'], [20, 'prefix'], [21, 'look'],
+     [22, 'out'], [23, 'gender'], [24, 'speak'], [25, 'take'], [26, 'alias'],
+     [27, 'place'], [28, 'east'], [29, 'north'], [30, 'west'], [31, 'south'],
+     [32, 'give'], [33, 'hideobject'], [34, 'hidechar'], [35, 'showobject'],
+     [36, 'showchar'], [37, 'collectable'], [38, 'collecatbles'],
+     [39, 'command'], [40, 'use'], [41, 'hidden'], [42, 'script'],
+     [43, 'font'], [44, 'default'], [45, 'fontname'], [46, 'fontsize'],
+     [47, 'startscript'], [48, 'nointro'], [49, 'indescription'],
+     [50, 'description'], [51, 'function'], [52, 'setvar'], [53, 'for'],
+     [54, 'error'], [55, 'synonyms'], [56, 'beforeturn'], [57, 'afterturn'],
+     [58, 'invisible'], [59, 'nodebug'], [60, 'suffix'], [61, 'startin'],
+     [62, 'northeast'], [63, 'northwest'], [64, 'southeast'],
+     [65, 'southwest'], [66, 'items'], [67, 'examine'], [68, 'detail'],
+     [69, 'drop'], [70, 'everywhere'], [71, 'nowhere'], [72, 'on'],
+     [73, 'anything'], [74, 'article'], [75, 'gain'], [76, 'properties'],
+     [77, 'type'], [78, 'action'], [79, 'displaytype'], [80, 'override'],
+     [81, 'enabled'], [82, 'disabled'], [83, 'variable'], [84, 'value'],
+     [85, 'display'], [86, 'nozero'], [87, 'onchange'], [88, 'timer'],
+     [89, 'alt'], [90, 'lib'], [91, 'up'], [92, 'down'], [93, 'gametype'],
+     [94, 'singleplayer'], [95, 'multiplayer'], [150, 'do'], [151, 'if'],
+     [152, 'got'], [153, 'then'], [154, 'else'], [155, 'has'], [156, 'say'],
+     [157, 'playwav'], [158, 'lose'], [159, 'msg'], [160, 'not'],
+     [161, 'playerlose'], [162, 'playerwin'], [163, 'ask'], [164, 'goto'],
+     [165, 'set'], [166, 'show'], [167, 'choice'], [168, 'choose'],
+     [169, 'is'], [170, 'setstring'], [171, 'displaytext'], [172, 'exec'],
+     [173, 'pause'], [174, 'clear'], [175, 'debug'], [176, 'enter'],
+     [177, 'movechar'], [178, 'moveobject'], [179, 'revealchar'],
+     [180, 'revealobject'], [181, 'concealchar'], [182, 'concealobject'],
+     [183, 'mailto'], [184, 'and'], [185, 'or'], [186, 'outputoff'],
+     [187, 'outputon'], [188, 'here'], [189, 'playmidi'], [190, 'drop'],
+     [191, 'helpmsg'], [192, 'helpdisplaytext'], [193, 'helpclear'],
+     [194, 'helpclose'], [195, 'hide'], [196, 'show'], [197, 'move'],
+     [198, 'conceal'], [199, 'reveal'], [200, 'numeric'], [201, 'string'],
+     [202, 'collectable'], [203, 'property'], [204, 'create'], [205, 'exit'],
+     [206, 'doaction'], [207, 'close'], [208, 'each'], [209, 'in'],
+     [210, 'repeat'], [211, 'while'], [212, 'until'], [213, 'timeron'],
+     [214, 'timeroff'], [215, 'stop'], [216, 'panes'], [217, 'on'],
+     [218, 'off'], [219, 'return'], [220, 'playmod'], [221, 'modvolume'],
+     [222, 'clone'], [223, 'shellexe'], [224, 'background'],
+     [225, 'foreground'], [226, 'wait'], [227, 'picture'], [228, 'nospeak'],
+     [229, 'animate'], [230, 'persist'], [231, 'inc'], [232, 'dec'],
+     [233, 'flag'], [234, 'dontprocess'], [235, 'destroy'],
+     [236, 'beforesave'], [237, 'onload']);
+
+my % tokens = ();
+my % rtokens = ();
+foreach (@hash_data) {
+	if ($_->[0] >= 0 && $_->[0] < 256) {
+		if ($_->[1] eq '') {
+			$_->[1] = "[?" . $_->[0] . "?]";
+		}
+		$rtokens{chr($_->[0])} = $_->[1];
+		$tokens{$_->[1]} = chr($_->[0]);
+	}
+}
+
+#print "{";
+#for (my $i = 0; $i < 256; $i ++) {
+#    print "\"", $rtokens{chr($i)}, "\", ";
+#}
+#print "}\n";
+#die;
+
+
+my % text_block_starters = map { $_ => 1 } qw / text synonyms type /;
+
+sub uncompile_fil {
+	my $IFH;
+	open($IFH, "<", $_[0]);
+	binmode $IFH;
+	$ / = undef;
+	my $dat = < $IFH >;
+#print "uncompile_fil : ";
+#print "\$IFH == '$IFH',";
+#print "\$dat == '$dat'\n";
+	my @dat = split //, $dat;
+
+
+	my $OFH;
+	if (@_ == 1) {
+		push @_, "&STDOUT";
+	}
+	open $OFH, ">$_[1]" or die "Can't open '$_[1]' for output: $!";
+
+	my @output = ();
+	my $curline = "";
+
+
+	my $obfus = 0;
+	my $expect_text == 0;
+	my($ch, $chn, $tok);
+	for (my $n = 8; $n < @dat; $n ++) {
+		$ch = $dat[$n];
+		$chn = ord $ch;
+		$tok = $rtokens{$ch};
+		if ($obfus == 1 && $chn == 0) {
+#print $OFH "> ";
+			$curline . = "> ";
+			$obfus = 0;
+		}
+		elsif($obfus == 1) {
+#print $OFH chr (255 - $chn);
+			$curline . = chr(255 - $chn);
+		}
+		elsif($obfus == 2 && $chn == 254) {
+			$obfus = 0;
+#print $OFH " ";
+			$curline . = " ";
+		}
+		elsif($obfus == 2) {
+#print $OFH chr ($chn);
+			$curline . = chr($chn);
+		}
+		elsif($expect_text == 2) {
+			if ($chn == 253) {
+				$expect_text = 0;
+##print $OFH "\n";
+				push @output, $curline;
+				$curline = "";
+			}
+			elsif($chn == 0) {
+#print $OFH "\n";
+				push @output, $curline;
+				$curline = "";
+			}
+			else {
+#print $OFH chr (255 - $chn);
+				$curline . = chr(255 - $chn);
+			}
+		}
+		elsif($obfus == 0 && $chn == 10) {
+#print $OFH "<";
+			$curline . = "<";
+			$obfus = 1;
+		}
+		elsif($obfus == 0 && $chn == 254) {
+			$obfus = 2;
+		}
+		elsif($chn == 255) {
+			if ($expect_text == 1) {
+				$expect_text = 2;
+			}
+#print $OFH "\n";
+			push @output, $curline;
+			$curline = "";
+		}
+		else {
+			if (($tok eq 'text' || $tok eq 'synonyms' || $tok eq 'type') &&
+			        $dat[$n - 1] eq chr(8)) {
+				$expect_text = 1;
+			}
+#print $OFH "$tok ";
+			$curline . = "$tok ";
+		}
+	}
+	push @output, $curline;
+	$curline = "";
+
+	if (!$is_raw) {
+		@output = pretty_print(reinline(@output));
+	}
+
+	foreach (@output) {
+		print $OFH $_, "\r\n";
+	}
+}
+
+sub list_grab_file {
+	my $IFH;
+	open($IFH, "<:crlf", $_[0]);
+	my @rv = < $IFH >;
+	chomp @rv;
+	return @rv;
+}
+
+
+sub compile_fil {
+	my @dat = list_grab_file($ARGV[0]);
+	my $OFH;
+	open $OFH, ">$ARGV[1]";
+
+	print $OFH "QCGF200".chr(0);
+
+# Mode 0 == normal, mode 1 == block text
+	my $mode = 0;
+	for (my $n = 0; $n < @dat; $n ++) {
+		my $l = $dat[$n];
+		while (substr($l, length($l) - 1, 1) eq '_' && $n < @dat) {
+			$n ++;
+			$l = substr($l, 0, length($l) - 1) . $dat[$n];
+		}
+		if ($l = ~ / ^ !include *<([\S] *)> /) {
+			@dat = (@dat[0..$n], list_grab_file($1), @dat[$n + 1..$#dat]);
+		}
+		elsif($l = ~ / ^ !addto.* /) {
+# TODO
+		}
+		else {
+			my $i = 0;
+			my $max = length $l;
+			my @l = split //, $l;
+
+			if ($mode == 1) {
+				if ($l = ~ / ^\s * end\s * define\s*$ /) {
+					print $OFH chr(253);
+					$mode = 0;
+# FALL THROUGH
+				} else {
+#print $OFH chr(0);
+					foreach (split //, $l) {
+					         print $OFH chr(255 - ord $_);
+				}
+			next;
+		}
+	}
+	if ($l = ~ / ^\s*$ /) {
+			next;
+		}
+		if ($l = ~ / ^\s * define\s * (text | synonyms | type) /) {
+#[\s$]
+			$mode = 1;
+		}
+		while ($i < $max) {
+			while ($i <= $max && $l[$i] = ~ / \s /) {
+				++ $i;
+			}
+			if ($i == $max) {
+				next;
+			}
+
+			my $j = $i + 1;
+			if ($l[$i] eq '<') {
+				while ($j < $max && $l[$j] ne '>') {
+					++ $j;
+				}
+				if ($l[$j] eq '>') {
+					print $OFH obfus(substr($l, $i + 1, $j - $i - 1));
+					$i = $j + 1;
+					next;
+				}
+				$j = $i + 1;
+				while ($j < $max && $l[$j] ne ' ') {
+					++ $j;
+				}
+				print $OFH chr(254). substr($l, $i + 1, $j - $i - 1). chr(0);
+				$i = $j + 1;
+				next;
+			}
+			while ($j < $max && $l[$j] ne ' ') {
+				++ $j;
+			}
+			my $str = substr($l, $i, $j - $i);
+			if (defined $tokens{$str}) {
+				print $OFH $tokens{$str};
+			}
+			else {
+				print $OFH chr(254). $str. chr(254);
+			}
+			$i = $j + 1;
+		}
+	}
+	print $OFH chr(255);
+}
+}
+
+sub is_define_t {
+	my($line, $type) = (@_);
+	return ($line = ~ / ^ *define[\s] + $type + /);
+}
+sub is_define {
+	my($line) = (@_);
+	return ($line = ~ / ^ *define[\s] + [^\s] /);
+}
+sub is_end_define { return (shift = ~ / ^ *end + define *$ /); }
+
+sub trim {
+	my $tmp = trim1($_[0]);
+#print "trimming ($_[0]) -> ($tmp)\n";
+	return $tmp;
+}
+
+sub trim1 {
+	if ($_[0] = ~ / ^[\s] * (.* ?)[\s]*$ /) {
+		return $1;
+	}
+	print "* * * Huh on trimming '$_[0]' * * *\n";
+}
+
+sub reinline {
+	my % reinlined = ();
+	my @head_prog = ();
+	my @rest_prog = ();
+	while (@_) {
+		push @rest_prog, (pop @_);
+	}
+
+	while (@rest_prog) {
+		my $line = pop @rest_prog;
+#print "processing $line\n";
+		if ($line = ~ / ^ (.* |)do ( < !intproc[0 - 9] * >) * (.*)$ /) {
+#print "  reinlining...\n";
+				my($prefix, $func_name, $suffix) = ($1, $2, $3);
+				$prefix = trim($prefix);
+				$suffix = trim($suffix);
+				$reinlined{$func_name} = 1;
+				for (my $line_num = 0; $line_num < @rest_prog; $line_num ++) {
+					if ($rest_prog[$line_num] = ~ / ^ *define + procedure + $func_name *$ /) {
+						my $end_line = $line_num;
+						while (!is_end_define($rest_prog[$end_line])) {
+#print "   checking $rest_prog[$end_line]\n";
+							-- $end_line;
+						}
+						++ $end_line;
+#print "    backpushing } ".$suffix."\n";
+#push @rest_prog, trim ("} " . $suffix);
+						if ($suffix ne '') {
+							push @rest_prog, $suffix;
+						}
+						push @rest_prog, "}";
+						while ($end_line < $line_num) {
+							push @rest_prog, $rest_prog[$end_line];
+#print "    backpushing $rest_prog[$end_line]\n";
+							$end_line ++;
+						}
+#print "    backpushing $prefix {\n";
+						push @rest_prog, trim($prefix." {");
+						$line_num = scalar @rest_prog;
+					}
+				}
+			}
+		else {
+			push @head_prog, $line;
+		}
+	}
+	my @rv = ();
+	for (my $n = 0; $n < @head_prog; $n ++) {
+		if ($head_prog[$n] = ~ / ^define procedure(<.*>) *$ / &&
+		                     $reinlined{$1}) {
+			while (!is_end_define($head_prog[$n])) {
+				++ $n;
+			}
+		}
+		else {
+			push @rv, $head_prog[$n];
+		}
+	}
+#for (my $n = 0; $n < @rv; $n ++) {
+#   print "$n: $rv[$n]\n";
+#}
+	return @rv;
+}
+
+sub pretty_print {
+	my $indent = 0;
+	my $not_in_text_mode = 1;
+
+	my @rv = ();
+
+	for (my $n = 0; $n < @_; $n ++) {
+		my $line = $_[$n];
+		if (is_end_define($line)) {
+			-- $indent;
+			$not_in_text_mode = 1;
+		}
+		/ { /; if ($line = ~ / ^} /) {
+			-- $indent;
+		}
+###if (is_define ($line) && ($n == 0 || !is_define ($_[$n-1]))) { print "\n"; }
+		if (is_define($line) && ($n == 0 || !is_define($_[$n - 1]))) {
+			push @rv, "";
+		}
+###if ($in_text_mode == 0) { print "    "x$indent; }
+		push @rv, ("    "x($indent*$not_in_text_mode)).trim($line);
+###print $line, "  line $n, indent $indent, text $in_text_mode\n";
+###print $line, "\n";
+		if (is_end_define($line) && $n < @_ && !is_end_define($_[$n + 1])
+		        && !is_define($_[$n + 1])) {
+###print "\n";
+			push @rv, "";
+		}
+		if (is_define($line)) {
+			++ $indent;
+		}
+		if ($line = ~ / {$ /) {
+		++ $indent;
+	} /
+	   } /;
+	if ($line = ~ / ^ *define + text /) {
+			$not_in_text_mode = 0;
+		}
+	}
+	return @rv;
+}
+
+
+sub error_msg {
+	die "Usage: 'perl uncas.pl file.asl file2.cas' to compile to file\n".
+	"       'perl uncas.pl file.cas'           to decompile to console\n".
+	"       'perl uncas.pl file.cas file2.asl' to decompile to file\n";
+}
+
+if ($ARGV[0] eq '-raw') {
+	$is_raw = 1;
+	shift @ARGV;
+}
+
+if ($ARGV[0] = ~ / \.asl$ /) {
+	if (@ARGV != 2) {
+		error_msg();
+	}
+	compile_fil(@ARGV);
+}
+elsif($ARGV[0] = ~ / \.cas$ /) {
+#print "compile_fil (", join (", ", @ARGV), ")\n";
+	if (@ARGV != 1 && @ARGV != 2) {
+		error_msg();
+	}
+	uncompile_fil(@ARGV);
+}
diff --git a/engines/glk/quetzal.cpp b/engines/glk/quetzal.cpp
index e60460209a..0a2bc448ac 100644
--- a/engines/glk/quetzal.cpp
+++ b/engines/glk/quetzal.cpp
@@ -44,6 +44,7 @@ const uint32 INTERPRETER_IDS[INTERPRETER_TADS3 + 1] = {
 	MKTAG('J', 'A', 'C', 'L'),
 	MKTAG('L', 'V', 'L', '9'),
 	MKTAG('M', 'A', 'G', 'N'),
+	MKTAG('Q', 'E', 'S', 'T'),
 	MKTAG('S', 'C', 'A', 'R'),
 	MKTAG('S', 'C', 'O', 'T'),
 	MKTAG('T', 'A', 'D', '2'),