GLK: AGT: Added subengine files

1 files changed, 6099 insertions, 0 deletions

diff --git a/engines/glk/agt/os_glk.cpp b/engines/glk/agt/os_glk.cpp
new file mode 100644
index 0000000000..1d9abd6838
--- /dev/null
+++ b/engines/glk/agt/os_glk.cpp
@@ -0,0 +1,6099 @@
+/* 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/agt/agility.h"
+#include "glk/agt/interp.h"
+#include "glk/agt/agt.h"
+
+namespace Glk {
+namespace AGT {
+
+/*
+ * Glk interface for AGiliTy 1.1.1.1
+ * -------------------------------
+ *
+ * This module contains the the Glk porting layer for AGiliTy.  It
+ * defines the Glk arguments list structure, the entry points for the
+ * Glk library framework to use, and all platform-abstracted I/O to
+ * link to Glk's I/O.
+ *
+ * The following items are omitted from this Glk port:
+ *
+ *  o Calls to g_vm->glk_tick().  The Glk documentation states that the
+ *    interpreter should call g_vm->glk_tick() every opcode or so.  This is
+ *    intrusive to code (it goes outside of this module), and since
+ *    most Glk libraries do precisely nothing in g_vm->glk_tick(), there is
+ *    little motivation to add it.
+ *
+ *  o Glk tries to assert control over _all_ file I/O.  It's just too
+ *    disruptive to add it to existing code, so for now, the AGiliTy
+ *    interpreter is still dependent on stdio and the like.
+ */
+
+/*
+ * True and false definitions -- usually defined in glkstart.h, but we need
+ * them early, so we'll define them here too.  We also need NULL, but that's
+ * normally from stdio.h or one of it's cousins.
+ */
+#ifndef FALSE
+# define FALSE 0
+#endif
+#ifndef TRUE
+# define TRUE (!FALSE)
+#endif
+
+
+/*---------------------------------------------------------------------*/
+/*  Module variables, miscellaneous externals not in header files      */
+/*---------------------------------------------------------------------*/
+
+/* Glk AGiliTy port version number. */
+static const glui32 GAGT_PORT_VERSION = 0x00010701;
+
+/*
+ * We use two Glk windows; one is two lines at the top of the display area
+ * for status, and the other is the remainder of the display area, used for,
+ * well, everything else.  Where a particular Glk implementation won't do
+ * more than one window, the status window remains NULL.
+ */
+static winid_t gagt_main_window = NULL,
+               gagt_status_window = NULL;
+
+/*
+ * Transcript stream and input log.  These are NULL if there is no current
+ * collection of these strings.
+ */
+static strid_t gagt_transcript_stream = NULL,
+               gagt_inputlog_stream = NULL;
+
+/* Input read log stream, for reading back an input log. */
+static strid_t gagt_readlog_stream = NULL;
+
+/* Options that may be turned off or set by command line flags. */
+enum FontMode {
+	FONT_AUTOMATIC, FONT_FIXED_WIDTH, FONT_PROPORTIONAL, FONT_DEBUG
+};
+static FontMode gagt_font_mode = FONT_AUTOMATIC;
+
+enum DelayMode {
+	DELAY_FULL, DELAY_SHORT, DELAY_OFF
+};
+static DelayMode gagt_delay_mode = DELAY_SHORT;
+static int gagt_replacement_enabled = TRUE,
+           gagt_extended_status_enabled = TRUE,
+           gagt_abbreviations_enabled = TRUE,
+           gagt_commands_enabled = TRUE;
+
+/* Forward declaration of event wait functions. */
+static void gagt_event_wait(glui32 wait_type, event_t *event);
+static void gagt_event_wait_2(glui32 wait_type_1,
+                              glui32 wait_type_2,
+                              event_t *event);
+
+/*
+ * Forward declaration of the g_vm->glk_exit() wrapper.  Normal functions in this
+ * module should not to call g_vm->glk_exit() directly; they should always call it
+ * through the wrapper instead.
+ */
+static void gagt_exit();
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port utility functions                                         */
+/*---------------------------------------------------------------------*/
+
+/*
+ * gagt_fatal()
+ *
+ * Fatal error handler.  The function returns, expecting the caller to
+ * abort() or otherwise handle the error.
+ */
+static void gagt_fatal(const char *string) {
+	/*
+	 * If the failure happens too early for us to have a window, print
+	 * the message to stderr.
+	 */
+	if (!gagt_main_window)
+		error("INTERNAL ERROR: %s", string);
+
+	/* Cancel all possible pending window input events. */
+	g_vm->glk_cancel_line_event(gagt_main_window, NULL);
+	g_vm->glk_cancel_char_event(gagt_main_window);
+
+	/* Print a message indicating the error. */
+	g_vm->glk_set_window(gagt_main_window);
+	g_vm->glk_set_style(style_Normal);
+	g_vm->glk_put_string("\n\nINTERNAL ERROR: ");
+	g_vm->glk_put_string(string);
+
+	g_vm->glk_put_string("\n\nPlease record the details of this error, try to"
+	                     " note down everything you did to cause it, and email"
+	                     " this information to simon_baldwin@yahoo.com.\n\n");
+}
+
+
+/*
+ * gagt_malloc()
+ * gagt_realloc()
+ *
+ * Non-failing malloc and realloc; call gagt_fatal() and exit if memory
+ * allocation fails.
+ */
+static void *gagt_malloc(size_t size) {
+	void *pointer;
+
+	pointer = malloc(size);
+	if (!pointer) {
+		gagt_fatal("GLK: Out of system memory");
+		gagt_exit();
+	}
+
+	return pointer;
+}
+
+static void *gagt_realloc(void *ptr, size_t size) {
+	void *pointer;
+
+	pointer = realloc(ptr, size);
+	if (!pointer) {
+		gagt_fatal("GLK: Out of system memory");
+		gagt_exit();
+	}
+
+	return pointer;
+}
+
+
+/*
+ * gagt_strncasecmp()
+ * gagt_strcasecmp()
+ *
+ * Strncasecmp and strcasecmp are not ANSI functions, so here are local
+ * definitions to do the same jobs.
+ */
+static int gagt_strncasecmp(const char *s1, const char *s2, size_t n) {
+	size_t index;
+
+	for (index = 0; index < n; index++) {
+		int diff;
+
+		diff = g_vm->glk_char_to_lower(s1[index]) - g_vm->glk_char_to_lower(s2[index]);
+		if (diff < 0 || diff > 0)
+			return diff < 0 ? -1 : 1;
+	}
+
+	return 0;
+}
+
+static int gagt_strcasecmp(const char *s1, const char *s2) {
+	size_t s1len, s2len;
+	int result;
+
+	s1len = strlen(s1);
+	s2len = strlen(s2);
+
+	result = gagt_strncasecmp(s1, s2, s1len < s2len ? s1len : s2len);
+	if (result < 0 || result > 0)
+		return result;
+	else
+		return s1len < s2len ? -1 : s1len > s2len ? 1 : 0;
+}
+
+
+/*
+ * gagt_debug()
+ *
+ * Handler for module debug output.  If no debug, it ignores the call,
+ * otherwise it prints a debug message, prefixed by the function name.
+ */
+static void gagt_debug(const char *function, const char *format, ...) {
+	if (DEBUG_OUT) {
+		Common::WriteStream *ws = dynamic_cast<Common::WriteStream *>(debugfile);
+		assert(ws);
+
+		ws->writeString(Common::String::format("%s (", function));
+		if (format && strlen(format) > 0) {
+			va_list va;
+
+			va_start(va, format);
+			Common::String data = Common::String::vformat(format, va);
+			ws->writeString(data);
+			va_end(va);
+		}
+
+		ws->writeString(")\n");
+	}
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Functions not ported - functionally unchanged from os_none.c       */
+/*---------------------------------------------------------------------*/
+
+/*
+ * agt_tone()
+ *
+ * Produce a hz-Hertz sound for ms milliseconds.
+ */
+void agt_tone(int hz, int ms) {
+	gagt_debug("agt_tone", "hz=%d, ms=%d", hz, ms);
+}
+
+
+/*
+ * agt_rand()
+ *
+ * Return random number from a to b inclusive.  The random number generator
+ * is seeded on the first call, to a reproducible sequence if stable_random,
+ * otherwise using time().
+ */
+int agt_rand(int a, int b) {
+	int result;
+
+	result = a + g_vm->getRandomNumber(0x7fffffff) % (b - a + 1);
+	gagt_debug("agt_rand", "a=%d, b=%d -> %d", a, b, result);
+	return result;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Workrounds for bugs in core AGiliTy.                               */
+/*---------------------------------------------------------------------*/
+
+/*
+ * gagt_workround_menus()
+ *
+ * Somewhere in AGiliTy's menu handling stuff is a condition that sets up
+ * an eventual NULL dereference in rstrncpy(), called from num_name_func().
+ * For some reason, perhaps memory overruns, perhaps something else, it
+ * happens after a few turns have been made through agt_menu().  Replacing
+ * agt_menu() won't avoid it.
+ *
+ * However, the menu stuff isn't too useful, or attractive, in a game, so one
+ * solution is to simply disable it.  While not possible to do this directly,
+ * there is a sneaky way, using our carnal knowledge of core AGiliTy.  In
+ * runverb.c, there is code to prevent menu mode from being turned on where
+ * verbmenu is NULL.  Verbmenu is set up in agil.c on loading the game, but,
+ * crucially, is set up before agil.c calls start_interface().  So... here
+ * we can free it, set it to NULL, set menu_mode to 0 (it probably is already)
+ * and AGiliTy behaves as if the game prevents menu mode.
+ */
+static void gagt_workround_menus() {
+	free(verbmenu);
+	verbmenu = NULL;
+
+	menu_mode = 0;
+}
+
+
+/*
+ * gagt_workround_fileexist()
+ *
+ * This function verifies that the game file can be opened, in effect second-
+ * guessing run_game().
+ *
+ * AGiliTy's fileexist() has in it either a bug, or a misfeature.  It always
+ * passes a nofix value of 1 into try_open_file(), which defeats the code to
+ * retry with both upper and lower cased filenames.  So here we have to go
+ * round the houses, with readopen()/readclose().
+ */
+static int gagt_workround_fileexist(fc_type fc, filetype ft) {
+	genfile file;
+	const char *errstr;
+
+	errstr = NULL;
+	file = readopen(fc, ft, &errstr);
+
+	if (file) {
+		readclose(file);
+		return TRUE;
+	}
+	return FALSE;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  I/O interface start and stop functions.                            */
+/*---------------------------------------------------------------------*/
+
+/* AGiliTy font_status values that indicate what font may be used. */
+enum {
+	GAGT_FIXED_REQUIRED = 1, GAGT_PROPORTIONAL_OKAY = 2
+};
+
+
+/*
+ * start_interface()
+ * close_interface()
+ *
+ * Startup and shutdown callout points.  The start function for Glk looks
+ * at the value of font_status that the game sets, to see if it has a strong
+ * view of the font to use.  If it does, then we'll reflect that in the
+ * module's font contol, perhaps overriding any command line options that the
+ * user has passed in.
+ */
+void start_interface(fc_type fc) {
+	switch (font_status) {
+	case GAGT_FIXED_REQUIRED:
+		gagt_font_mode = FONT_FIXED_WIDTH;
+		break;
+
+	case GAGT_PROPORTIONAL_OKAY:
+		gagt_font_mode = FONT_PROPORTIONAL;
+		break;
+
+	default:
+		break;
+	}
+
+	gagt_workround_menus();
+
+	gagt_debug("start_interface", "fc=%p", fc);
+}
+
+void close_interface() {
+	if (filevalid(scriptfile, fSCR))
+		close_pfile(scriptfile, 0);
+
+	gagt_debug("close_interface", "");
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Code page 437 to ISO 8859 Latin-1 translations                     */
+/*---------------------------------------------------------------------*/
+
+/*
+ * AGiliTy uses IBM code page 437 characters, and Glk works in ISO 8859
+ * Latin-1.  There's some good news, in that a number of the characters,
+ * especially international ones, in these two sets are the same.  The bad
+ * news is that, for codes above 127 (that is, beyond 7-bit ASCII), or for
+ * codes below 32, they live in different places.  So, here is a table of
+ * conversions for codes not equivalent to 7-bit ASCII, and a pair of
+ * conversion routines.
+ *
+ * Note that some code page 437 characters don't have ISO 8859 Latin-1
+ * equivalents.  Predominantly, these are the box-drawing characters, which
+ * is a pity, because these are the ones that are used the most.  Anyway,
+ * in these cases, the table substitutes an approximated base ASCII char-
+ * acter in its place.
+ *
+ * The first entry of table comments below is the character's UNICODE value,
+ * just in case it's useful at some future date.
+ */
+typedef const struct {
+	const unsigned char cp437;      /* Code page 437 character. */
+	const unsigned char iso8859_1;  /* ISO 8859 Latin-1 character. */
+} gagt_char_t;
+typedef gagt_char_t *gagt_charref_t;
+
+static gagt_char_t GAGT_CHAR_TABLE[] = {
+	/*
+	 * Low characters -- those below 0x20.   These are the really odd code
+	 * page 437 characters, rarely used by AGT games.  Low characters are
+	 * omitted from the reverse lookup, and participate only in the forwards
+	 * lookup from code page 437 to ISO 8859 Latin-1.
+	 */
+	{0x01,  '@'},     /* 263a White smiling face */
+	{0x02,  '@'},     /* 263b Black smiling face */
+	{0x03,  '?'},     /* 2665 Black heart suit */
+	{0x04,  '?'},     /* 2666 Black diamond suit */
+	{0x05,  '?'},     /* 2663 Black club suit */
+	{0x06,  '?'},     /* 2660 Black spade suit */
+	{0x07, 0xb7},     /* 2022 Bullet */
+	{0x08, 0xb7},     /* 25d8 Inverse bullet */
+	{0x09, 0xb7},     /* 25e6 White bullet */
+	{0x0a, 0xb7},     /* 25d9 Inverse white circle */
+	{0x0b,  '?'},     /* 2642 Male sign */
+	{0x0c,  '?'},     /* 2640 Female sign */
+	{0x0d,  '?'},     /* 266a Eighth note */
+	{0x0e,  '?'},     /* 266b Beamed eighth notes */
+	{0x0f, 0xa4},     /* 263c White sun with rays */
+	{0x10,  '>'},     /* 25b6 Black right-pointing triangle */
+	{0x11,  '<'},     /* 25c0 Black left-pointing triangle */
+	{0x12, 0xa6},     /* 2195 Up down arrow */
+	{0x13,  '!'},     /* 203c Double exclamation mark */
+	{0x14, 0xb6},     /* 00b6 Pilcrow sign */
+	{0x15, 0xa7},     /* 00a7 Section sign */
+	{0x16,  '#'},     /* 25ac Black rectangle */
+	{0x17, 0xa6},     /* 21a8 Up down arrow with base */
+	{0x18,  '^'},     /* 2191 Upwards arrow */
+	{0x19,  'v'},     /* 2193 Downwards arrow */
+	{0x1a,  '>'},     /* 2192 Rightwards arrow */
+	{0x1b,  '<'},     /* 2190 Leftwards arrow */
+	{0x1c,  '?'},     /* 2310 Reversed not sign */
+	{0x1d,  '-'},     /* 2194 Left right arrow */
+	{0x1e,  '^'},     /* 25b2 Black up-pointing triangle */
+	{0x1f,  'v'},     /* 25bc Black down-pointing triangle */
+
+	/*
+	 * High characters -- those above 0x7f.  These are more often used by AGT
+	 * games, particularly for box drawing.
+	 */
+	{0x80, 0xc7},     /* 00c7 Latin capital letter c with cedilla */
+	{0x81, 0xfc},     /* 00fc Latin small letter u with diaeresis */
+	{0x82, 0xe9},     /* 00e9 Latin small letter e with acute */
+	{0x83, 0xe2},     /* 00e2 Latin small letter a with circumflex */
+	{0x84, 0xe4},     /* 00e4 Latin small letter a with diaeresis */
+	{0x85, 0xe0},     /* 00e0 Latin small letter a with grave */
+	{0x86, 0xe5},     /* 00e5 Latin small letter a with ring above */
+	{0x87, 0xe7},     /* 00e7 Latin small letter c with cedilla */
+	{0x88, 0xea},     /* 00ea Latin small letter e with circumflex */
+	{0x89, 0xeb},     /* 00eb Latin small letter e with diaeresis */
+	{0x8a, 0xe8},     /* 00e8 Latin small letter e with grave */
+	{0x8b, 0xef},     /* 00ef Latin small letter i with diaeresis */
+	{0x8c, 0xee},     /* 00ee Latin small letter i with circumflex */
+	{0x8d, 0xec},     /* 00ec Latin small letter i with grave */
+	{0x8e, 0xc4},     /* 00c4 Latin capital letter a with diaeresis */
+	{0x8f, 0xc5},     /* 00c5 Latin capital letter a with ring above */
+	{0x90, 0xc9},     /* 00c9 Latin capital letter e with acute */
+	{0x91, 0xe6},     /* 00e6 Latin small ligature ae */
+	{0x92, 0xc6},     /* 00c6 Latin capital ligature ae */
+	{0x93, 0xf4},     /* 00f4 Latin small letter o with circumflex */
+	{0x94, 0xf6},     /* 00f6 Latin small letter o with diaeresis */
+	{0x95, 0xf2},     /* 00f2 Latin small letter o with grave */
+	{0x96, 0xfb},     /* 00fb Latin small letter u with circumflex */
+	{0x97, 0xf9},     /* 00f9 Latin small letter u with grave */
+	{0x98, 0xff},     /* 00ff Latin small letter y with diaeresis */
+	{0x99, 0xd6},     /* 00d6 Latin capital letter o with diaeresis */
+	{0x9a, 0xdc},     /* 00dc Latin capital letter u with diaeresis */
+	{0x9b, 0xa2},     /* 00a2 Cent sign */
+	{0x9c, 0xa3},     /* 00a3 Pound sign */
+	{0x9d, 0xa5},     /* 00a5 Yen sign */
+	{0x9e,  'p'},     /* 20a7 Peseta sign */
+	{0x9f,  'f'},     /* 0192 Latin small letter f with hook */
+	{0xa0, 0xe1},     /* 00e1 Latin small letter a with acute */
+	{0xa1, 0xed},     /* 00ed Latin small letter i with acute */
+	{0xa2, 0xf3},     /* 00f3 Latin small letter o with acute */
+	{0xa3, 0xfa},     /* 00fa Latin small letter u with acute */
+	{0xa4, 0xf1},     /* 00f1 Latin small letter n with tilde */
+	{0xa5, 0xd1},     /* 00d1 Latin capital letter n with tilde */
+	{0xa6, 0xaa},     /* 00aa Feminine ordinal indicator */
+	{0xa7, 0xba},     /* 00ba Masculine ordinal indicator */
+	{0xa8, 0xbf},     /* 00bf Inverted question mark */
+	{0xa9,  '.'},     /* 2310 Reversed not sign */
+	{0xaa, 0xac},     /* 00ac Not sign */
+	{0xab, 0xbd},     /* 00bd Vulgar fraction one half */
+	{0xac, 0xbc},     /* 00bc Vulgar fraction one quarter */
+	{0xad, 0xa1},     /* 00a1 Inverted exclamation mark */
+	{0xae, 0xab},     /* 00ab Left-pointing double angle quotation mark */
+	{0xaf, 0xbb},     /* 00bb Right-pointing double angle quotation mark */
+	{0xb0,  '#'},     /* 2591 Light shade */
+	{0xb1,  '#'},     /* 2592 Medium shade */
+	{0xb2,  '#'},     /* 2593 Dark shade */
+	{0xb3,  '|'},     /* 2502 Box light vertical */
+	{0xb4,  '+'},     /* 2524 Box light vertical and left */
+	{0xb5,  '+'},     /* 2561 Box vertical single and left double */
+	{0xb6,  '|'},     /* 2562 Box vertical double and left single */
+	{0xb7,  '+'},     /* 2556 Box down double and left single */
+	{0xb8,  '+'},     /* 2555 Box down single and left double */
+	{0xb9,  '+'},     /* 2563 Box double vertical and left */
+	{0xba,  '|'},     /* 2551 Box double vertical */
+	{0xbb, '\\'},     /* 2557 Box double down and left */
+	{0xbc,  '/'},     /* 255d Box double up and left */
+	{0xbd,  '+'},     /* 255c Box up double and left single */
+	{0xbe,  '+'},     /* 255b Box up single and left double */
+	{0xbf, '\\'},     /* 2510 Box light down and left */
+	{0xc0, '\\'},     /* 2514 Box light up and right */
+	{0xc1,  '+'},     /* 2534 Box light up and horizontal */
+	{0xc2,  '+'},     /* 252c Box light down and horizontal */
+	{0xc3,  '+'},     /* 251c Box light vertical and right */
+	{0xc4,  '-'},     /* 2500 Box light horizontal */
+	{0xc5,  '+'},     /* 253c Box light vertical and horizontal */
+	{0xc6,  '|'},     /* 255e Box vertical single and right double */
+	{0xc7,  '|'},     /* 255f Box vertical double and right single */
+	{0xc8, '\\'},     /* 255a Box double up and right */
+	{0xc9,  '/'},     /* 2554 Box double down and right */
+	{0xca,  '+'},     /* 2569 Box double up and horizontal */
+	{0xcb,  '+'},     /* 2566 Box double down and horizontal */
+	{0xcc,  '+'},     /* 2560 Box double vertical and right */
+	{0xcd,  '='},     /* 2550 Box double horizontal */
+	{0xce,  '+'},     /* 256c Box double vertical and horizontal */
+	{0xcf,  '='},     /* 2567 Box up single and horizontal double */
+	{0xd0,  '+'},     /* 2568 Box up double and horizontal single */
+	{0xd1,  '='},     /* 2564 Box down single and horizontal double */
+	{0xd2,  '+'},     /* 2565 Box down double and horizontal single */
+	{0xd3,  '+'},     /* 2559 Box up double and right single */
+	{0xd4,  '+'},     /* 2558 Box up single and right double */
+	{0xd5,  '+'},     /* 2552 Box down single and right double */
+	{0xd6,  '+'},     /* 2553 Box down double and right single */
+	{0xd7,  '+'},     /* 256b Box vertical double and horizontal single */
+	{0xd8,  '+'},     /* 256a Box vertical single and horizontal double */
+	{0xd9,  '/'},     /* 2518 Box light up and left */
+	{0xda,  '/'},     /* 250c Box light down and right */
+	{0xdb,  '@'},     /* 2588 Full block */
+	{0xdc,  '@'},     /* 2584 Lower half block */
+	{0xdd,  '@'},     /* 258c Left half block */
+	{0xde,  '@'},     /* 2590 Right half block */
+	{0xdf,  '@'},     /* 2580 Upper half block */
+	{0xe0,  'a'},     /* 03b1 Greek small letter alpha */
+	{0xe1, 0xdf},     /* 00df Latin small letter sharp s */
+	{0xe2,  'G'},     /* 0393 Greek capital letter gamma */
+	{0xe3,  'p'},     /* 03c0 Greek small letter pi */
+	{0xe4,  'S'},     /* 03a3 Greek capital letter sigma */
+	{0xe5,  's'},     /* 03c3 Greek small letter sigma */
+	{0xe6, 0xb5},     /* 00b5 Micro sign */
+	{0xe7,  't'},     /* 03c4 Greek small letter tau */
+	{0xe8,  'F'},     /* 03a6 Greek capital letter phi */
+	{0xe9,  'T'},     /* 0398 Greek capital letter theta */
+	{0xea,  'O'},     /* 03a9 Greek capital letter omega */
+	{0xeb,  'd'},     /* 03b4 Greek small letter delta */
+	{0xec,  '.'},     /* 221e Infinity */
+	{0xed,  'f'},     /* 03c6 Greek small letter phi */
+	{0xee,  'e'},     /* 03b5 Greek small letter epsilon */
+	{0xef,  '^'},     /* 2229 Intersection */
+	{0xf0,  '='},     /* 2261 Identical to */
+	{0xf1, 0xb1},     /* 00b1 Plus-minus sign */
+	{0xf2,  '>'},     /* 2265 Greater-than or equal to */
+	{0xf3,  '<'},     /* 2264 Less-than or equal to */
+	{0xf4,  'f'},     /* 2320 Top half integral */
+	{0xf5,  'j'},     /* 2321 Bottom half integral */
+	{0xf6, 0xf7},     /* 00f7 Division sign */
+	{0xf7,  '='},     /* 2248 Almost equal to */
+	{0xf8, 0xb0},     /* 00b0 Degree sign */
+	{0xf9, 0xb7},     /* 2219 Bullet operator */
+	{0xfa, 0xb7},     /* 00b7 Middle dot */
+	{0xfb,  '/'},     /* 221a Square root */
+	{0xfc,  'n'},     /* 207f Superscript latin small letter n */
+	{0xfd, 0xb2},     /* 00b2 Superscript two */
+	{0xfe,  '#'},     /* 25a0 Black square */
+	{0xff, 0xa0},     /* 00a0 No-break space */
+	{0, 0}            /* 0000 [END OF TABLE] */
+};
+
+
+/*
+ * gagt_cp_to_iso()
+ *
+ * Convert a string from code page 437 into ISO 8859 Latin-1.  The input and
+ * output buffers may be one and the same.
+ */
+static void gagt_cp_to_iso(const unsigned char *from_string, unsigned char *to_string) {
+	static int is_initialized = FALSE;
+	static unsigned char table[BYTE_MAX_VAL + 1];
+
+	int index;
+	unsigned char cp437, iso8859_1;
+	assert(from_string && to_string);
+
+	if (!is_initialized) {
+		gagt_charref_t entry;
+
+		/*
+		 * Create a lookup entry for each code in the main table.  Fill in gaps
+		 * for 7-bit characters with their ASCII equivalent values.  Any
+		 * remaining codes not represented in the main table will map to zeroes
+		 * in the lookup table, as static variables are initialized to zero.
+		 */
+		for (entry = GAGT_CHAR_TABLE; entry->cp437; entry++) {
+			cp437 = entry->cp437;
+			iso8859_1 = entry->iso8859_1;
+
+//			assert(cp437 < 0x20 || (cp437 > INT8_MAX_VAL && cp437 <= BYTE_MAX_VAL));
+			table[cp437] = iso8859_1;
+		}
+		for (index = 0; index <= INT8_MAX_VAL; index++) {
+			if (table[index] == 0)
+				table[index] = index;
+		}
+
+		is_initialized = TRUE;
+	}
+
+	for (index = 0; from_string[index] != '\0'; index++) {
+		cp437 = from_string[index];
+		iso8859_1 = table[cp437];
+
+		to_string[index] = iso8859_1 ? iso8859_1 : cp437;
+	}
+
+	to_string[index] = '\0';
+}
+
+
+/*
+ * gagt_iso_to_cp()
+ *
+ * Convert a string from ISO 8859 Latin-1 to code page 437.  The input and
+ * output buffers may be one and the same.
+ */
+static void gagt_iso_to_cp(const unsigned char *from_string, unsigned char *to_string) {
+	static int is_initialized = FALSE;
+	static unsigned char table[BYTE_MAX_VAL + 1];
+
+	int index;
+	unsigned char iso8859_1, cp437;
+	assert(from_string && to_string);
+
+	if (!is_initialized) {
+		gagt_charref_t entry;
+
+		/*
+		 * Create a reverse lookup entry for each code in the main table,
+		 * overriding all of the low table entries (that is, anything under
+		 * 128) with their ASCII no matter what the table contained.
+		 *
+		 * Any codes not represented in the main table will map to zeroes in
+		 * the reverse lookup table, since static variables are initialized to
+		 * zero.  The first 128 characters are equivalent to ASCII.  Moreover,
+		 * some ISO 8859 Latin-1 entries are faked as base ASCII; where an
+		 * entry is already occupied, the main table entry is skipped, so the
+		 * match, which is n:1 in the reverse direction, works in first-found
+		 * mode.
+		 */
+		for (entry = GAGT_CHAR_TABLE; entry->iso8859_1; entry++) {
+			cp437 = entry->cp437;
+			iso8859_1 = entry->iso8859_1;
+
+			if (table[iso8859_1] == 0)
+				table[iso8859_1] = cp437;
+		}
+		for (index = 0; index <= INT8_MAX_VAL; index++)
+			table[index] = index;
+
+		is_initialized = TRUE;
+	}
+
+	for (index = 0; from_string[index] != '\0'; index++) {
+		iso8859_1 = from_string[index];
+		cp437 = table[iso8859_1];
+
+		to_string[index] = cp437 ? cp437 : iso8859_1;
+	}
+
+	to_string[index] = '\0';
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port status line functions                                     */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Buffered copy of the latest status line passed in by the interpreter.
+ * Buffering it means it's readily available to print for Glk libraries
+ * that don't support separate windows.  We also need a copy of the last
+ * status buffer printed for non-windowing Glk libraries, for comparison.
+ */
+static char *gagt_status_buffer = NULL,
+             *gagt_status_buffer_printed = NULL;
+
+/*
+ * Indication that we are in mid-delay.  The delay is silent, and can look
+ * kind of confusing, so to try to make it less so, we'll have the status
+ * window show something about it.
+ */
+static int gagt_inside_delay = FALSE;
+
+
+/*
+ * agt_statline()
+ *
+ * This function is called from our call to print_statline().  Here we'll
+ * convert the string and buffer in an allocated area for later use.
+ */
+void agt_statline(const char *cp_string) {
+	assert(cp_string);
+
+	free(gagt_status_buffer);
+	gagt_status_buffer = (char *)gagt_malloc(strlen(cp_string) + 1);
+	gagt_cp_to_iso((const unsigned char *)cp_string, (unsigned char *)gagt_status_buffer);
+
+	gagt_debug("agt_statline", "string='%s'", cp_string);
+}
+
+
+/*
+ * gagt_status_update_extended()
+ *
+ * Helper for gagt_status_update() and gagt_status_in_delay().  This function
+ * displays the second line of any extended status display, giving a list of
+ * exits from the compass rose, and if in an AGT delay, a waiting indicator.
+ */
+static void gagt_status_update_extended() {
+	uint width, height;
+	assert(gagt_status_window);
+
+	g_vm->glk_window_get_size(gagt_status_window, &width, &height);
+	if (height > 1) {
+		uint32 index;
+		int exit;
+
+		/* Clear the second status line only. */
+		g_vm->glk_window_move_cursor(gagt_status_window, 0, 1);
+		g_vm->glk_set_window(gagt_status_window);
+		g_vm->glk_set_style(style_User1);
+		for (index = 0; index < width; index++)
+			g_vm->glk_put_char(' ');
+
+		/*
+		 * Check bits in the compass rose, and print out exit names from
+		 * the exitname[] array.
+		 */
+		g_vm->glk_window_move_cursor(gagt_status_window, 0, 1);
+		g_vm->glk_put_string("  Exits: ");
+		for (exit = 0; exit < (int)sizeof(exitname) / (int)sizeof(exitname[0]); exit++) {
+			if (compass_rose & (1 << exit)) {
+				g_vm->glk_put_string(exitname[exit]);
+				g_vm->glk_put_char(' ');
+			}
+		}
+
+		/* If the delay flag is set, print a waiting indicator at the right. */
+		if (gagt_inside_delay) {
+			g_vm->glk_window_move_cursor(gagt_status_window,
+			                             width - strlen("Waiting... "), 1);
+			g_vm->glk_put_string("Waiting... ");
+		}
+
+		g_vm->glk_set_window(gagt_main_window);
+	}
+}
+
+
+/*
+ * gagt_status_update()
+ *
+ *
+ * This function calls print_statline() to prompt the interpreter into calling
+ * our agt_statline(), then if we have a status window, displays the status
+ * string, and calls gagt_status_update_extended() if necessary to handle the
+ * second status line.  If we don't see a call to our agt_statline, we output
+ * a default status string.
+ */
+static void gagt_status_update() {
+	uint width, height;
+	uint32 index;
+	assert(gagt_status_window);
+
+	g_vm->glk_window_get_size(gagt_status_window, &width, &height);
+	if (height > 0) {
+		g_vm->glk_window_clear(gagt_status_window);
+		g_vm->glk_window_move_cursor(gagt_status_window, 0, 0);
+		g_vm->glk_set_window(gagt_status_window);
+
+		g_vm->glk_set_style(style_User1);
+		for (index = 0; index < width; index++)
+			g_vm->glk_put_char(' ');
+		g_vm->glk_window_move_cursor(gagt_status_window, 0, 0);
+
+		/* Call print_statline() to refresh status line buffer contents. */
+		print_statline();
+
+		/* See if we have a buffered status line available. */
+		if (gagt_status_buffer) {
+			glui32 print_width;
+
+			/*
+			 * Print the basic buffered status string, truncating to the
+			 * current status window width if necessary, then try adding a
+			 * second line if extended status enabled.
+			 */
+			print_width = width < strlen(gagt_status_buffer)
+			              ? width : strlen(gagt_status_buffer);
+			g_vm->glk_put_buffer(gagt_status_buffer, print_width);
+
+			if (gagt_extended_status_enabled)
+				gagt_status_update_extended();
+		} else {
+			/*
+			 * We don't (yet) have a status line.  Perhaps we're at the
+			 * very start of a game.  Print a standard message.
+			 */
+			g_vm->glk_put_string("Glk AGiliTy version 1.1.1.1");
+		}
+
+		g_vm->glk_set_window(gagt_main_window);
+	}
+}
+
+
+/*
+ * gagt_status_print()
+ *
+ * Print the current contents of the completed status line buffer out in the
+ * main window, if it has changed since the last call.  This is for non-
+ * windowing Glk libraries.
+ *
+ * Like gagt_status_update(), this function calls print_statline() to prompt
+ * the interpreter into calling our agt_statline(), then if we have a new
+ * status line, it prints it.
+ */
+static void gagt_status_print() {
+	/* Call print_statline() to refresh status line buffer contents. */
+	print_statline();
+
+	/*
+	 * Do no more if there is no status line to print, or if the status
+	 * line hasn't changed since last printed.
+	 */
+	if (!gagt_status_buffer
+	        || (gagt_status_buffer_printed
+	            && strcmp(gagt_status_buffer, gagt_status_buffer_printed) == 0))
+		return;
+
+	/* Set fixed width font to try to preserve status line formatting. */
+	g_vm->glk_set_style(style_Preformatted);
+
+	/*
+	 * Bracket, and output the status line buffer.  We don't need to put any
+	 * spacing after the opening bracket or before the closing one, because
+	 * AGiliTy puts leading/trailing spaces on its status lines.
+	 */
+	g_vm->glk_put_string("[");
+	g_vm->glk_put_string(gagt_status_buffer);
+	g_vm->glk_put_string("]\n");
+
+	/* Save the details of the printed status buffer. */
+	free(gagt_status_buffer_printed);
+	gagt_status_buffer_printed = (char *)gagt_malloc(strlen(gagt_status_buffer) + 1);
+	strcpy(gagt_status_buffer_printed, gagt_status_buffer);
+}
+
+
+/*
+ * gagt_status_notify()
+ *
+ * Front end function for updating status.  Either updates the status window
+ * or prints the status line to the main window.
+ *
+ * Functions interested in updating the status line should call either this
+ * function, or gagt_status_redraw(), and not print_statline().
+ */
+static void gagt_status_notify() {
+	if (!BATCH_MODE) {
+		if (gagt_status_window)
+			gagt_status_update();
+		else
+			gagt_status_print();
+	}
+}
+
+
+/*
+ * gagt_status_redraw()
+ *
+ * Redraw the contents of any status window with the buffered status string.
+ * This function handles window sizing, and updates the interpreter with
+ * status_width, so may, and should, be called on resize and arrange events.
+ *
+ * Functions interested in updating the status line should call either this
+ * function, or gagt_status_notify(), and not print_statline().
+ */
+static void gagt_status_redraw() {
+	if (!BATCH_MODE) {
+		if (gagt_status_window) {
+			uint width, height;
+			winid_t parent;
+
+			/*
+			 * Measure the status window, and update the interpreter's
+			 * status_width variable.
+			 */
+			g_vm->glk_window_get_size(gagt_status_window, &width, &height);
+			status_width = width;
+
+			/*
+			 * Rearrange the status window, without changing its actual
+			 * arrangement in any way.  This is a hack to work round
+			 * incorrect window repainting in Xglk; it forces a complete
+			 * repaint of affected windows on Glk window resize and
+			 * arrange events, and works in part because Xglk doesn't
+			 * check for actual arrangement changes in any way before
+			 * invalidating its windows.  The hack should be harmless to
+			 * Glk libraries other than Xglk, moreover, we're careful to
+			 * activate it only on resize and arrange events.
+			 */
+			parent = g_vm->glk_window_get_parent(gagt_status_window);
+			g_vm->glk_window_set_arrangement(parent,
+			                                 winmethod_Above | winmethod_Fixed,
+			                                 height, NULL);
+
+			gagt_status_update();
+		}
+	}
+}
+
+
+/*
+ * gagt_status_in_delay()
+ *
+ * Tells status line functions whether the game is delaying, or not.  This
+ * function updates the extended status line, if present, automatically.
+ */
+static void gagt_status_in_delay(int inside_delay) {
+	if (!BATCH_MODE) {
+		/* Save the new delay status flag. */
+		gagt_inside_delay = inside_delay;
+
+		/*
+		 * Update just the second line of the status window display, if
+		 * extended status is being displayed.
+		 */
+		if (gagt_status_window && gagt_extended_status_enabled)
+			gagt_status_update_extended();
+	}
+}
+
+
+/*
+ * gagt_status_cleanup()
+ *
+ * Free memory resources allocated by status line functions.  Called on game
+ * end.
+ */
+static void gagt_status_cleanup() {
+	free(gagt_status_buffer);
+	gagt_status_buffer = NULL;
+
+	free(gagt_status_buffer_printed);
+	gagt_status_buffer_printed = NULL;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port color and text attribute handling                         */
+/*---------------------------------------------------------------------*/
+
+/*
+ * AGT color and character attribute definitions.  This is the range of
+ * values passed in to agt_textcolor().
+ */
+enum {
+	AGT_BLACK = 0,
+	AGT_BLUE = 1,
+	AGT_GREEN = 2,
+	AGT_CYAN = 3,
+	AGT_RED = 4,
+	AGT_MAGENTA = 5,
+	AGT_BROWN = 6,
+	AGT_NORMAL = 7,
+	AGT_BLINKING = 8,
+	AGT_WHITE = 9,
+	AGT_FIXED_FONT = 10,
+	AGT_VARIABLE_FONT = 11,
+	AGT_EMPHASIS = -1,
+	AGT_DE_EMPHASIS = -2
+};
+
+/*
+ * AGiliTy colors and text attributes seem a bit confused.  Let's see if we
+ * can sort them out.  Sadly, once we have, it's often not possible to
+ * render the full range in all Glk's anyway.  Nevertheless...
+ */
+struct gagt_attrset_t {
+	int color;     /* Text color. */
+	int blink;     /* Text blinking flag. */
+	int fixed;     /* Text fixed font flag. */
+	int emphasis;  /* Text emphasized flag. */
+};
+
+/*
+ * Attributes as currently set by AGiliTy.  The default values set up here
+ * correspond to AGT_NORMAL.
+ */
+static gagt_attrset_t gagt_current_attribute_set = { AGT_WHITE, FALSE,
+                                                     FALSE, FALSE
+                                                   };
+
+/*
+ * An extra flag to indicate if we have coerced fixed font override.  On
+ * some occasions, we need to ensure that we get fixed font no matter what
+ * the game says.
+ */
+static int gagt_coerced_fixed = FALSE;
+
+/*
+ * Bit masks for packing colors and attributes.  Normally, I don't like
+ * bit-twiddling all that much, but for packing all of the above into a
+ * single byte, that's what we need.  Stuff color into the low four bits,
+ * convenient since color is from 0 to 9, then use three bits for the other
+ * attributes.
+ */
+static const unsigned char GAGT_COLOR_MASK = 0x0f,
+                           GAGT_BLINK_MASK = 1 << 4,
+                           GAGT_FIXED_MASK = 1 << 5,
+                           GAGT_EMPHASIS_MASK = 1 << 6;
+
+/* Forward declaration of message function. */
+static void gagt_standout_string(const char *message);
+
+
+/*
+ * agt_textcolor()
+ *
+ * The AGiliTy porting guide defines the use of this function as:
+ *
+ *   Set text color to color #c, where the colors are as follows:
+ *    0=Black, 1=Blue,    2=Green, 3=Cyan,
+ *    4=Red,   5=Magenta, 6=Brown,
+ *    7=Normal("White"-- which may actually be some other color)
+ *       This should turn off blinking, bold, color, etc. and restore
+ *       the text mode to its default appearance.
+ *    8=Turn on blinking.
+ *    9= *Just* White (not neccessarily "normal" and no need to turn off
+ *        blinking)
+ *   10=Turn on fixed pitch font.
+ *   11=Turn off fixed pitch font
+ *   Also used to set other text attributes:
+ *     -1=emphasized text, used (e.g.) for room titles
+ *     -2=end emphasized text
+ *
+ * Here we try to make sense of all this.  Given an argument, we'll try to
+ * update our separated color and text attributes flags to reflect the
+ * expected text rendering.
+ */
+void agt_textcolor(int color) {
+	switch (color) {
+	case AGT_BLACK:
+	case AGT_BLUE:
+	case AGT_GREEN:
+	case AGT_CYAN:
+	case AGT_RED:
+	case AGT_MAGENTA:
+	case AGT_BROWN:
+	case AGT_WHITE:
+		gagt_current_attribute_set.color = color;
+		break;
+
+	case AGT_NORMAL:
+		gagt_current_attribute_set.color = AGT_WHITE;
+		gagt_current_attribute_set.blink = FALSE;
+		gagt_current_attribute_set.fixed = FALSE;
+		gagt_current_attribute_set.emphasis = FALSE;
+		break;
+
+	case AGT_BLINKING:
+		gagt_current_attribute_set.blink = TRUE;
+		break;
+
+	case AGT_FIXED_FONT:
+		gagt_current_attribute_set.fixed = TRUE;
+		break;
+
+	case AGT_VARIABLE_FONT:
+		gagt_current_attribute_set.fixed = FALSE;
+		break;
+
+	case AGT_EMPHASIS:
+		gagt_current_attribute_set.emphasis = TRUE;
+		break;
+
+	case AGT_DE_EMPHASIS:
+		gagt_current_attribute_set.emphasis = FALSE;
+		break;
+
+	default:
+		gagt_fatal("GLK: Unknown color encountered");
+		gagt_exit();
+	}
+
+	gagt_debug("agt_textcolor", "color=% d -> %d%s%s%s",
+	           color,
+	           gagt_current_attribute_set.color,
+	           gagt_current_attribute_set.blink ? " blink" : "",
+	           gagt_current_attribute_set.fixed ? " fixed" : "",
+	           gagt_current_attribute_set.emphasis ? " bold" : "");
+}
+
+
+/*
+ * gagt_coerce_fixed_font()
+ *
+ * This coerces, or relaxes, a fixed font setting.  Used by box drawing, to
+ * ensure that we get a temporary fixed font setting for known differenti-
+ * ated parts of game output text.  Pass in TRUE to coerce fixed font, and
+ * FALSE to relax it.
+ */
+static void gagt_coerce_fixed_font(int coerce) {
+	gagt_coerced_fixed = coerce;
+}
+
+
+/*
+ * gagt_pack_attributes()
+ *
+ * Pack a set of color and text rendering attributes into a single byte,
+ * and return it.  This function is used so that a set of text attributes
+ * can be encoded into a byte array that parallels the output strings that
+ * we buffer from the interpreter.
+ */
+static unsigned char gagt_pack_attributes(const gagt_attrset_t *attribute_set, int coerced) {
+	unsigned char packed;
+	assert(attribute_set);
+
+	/* Set the initial result to be color; these are the low bits. */
+	assert((attribute_set->color & ~GAGT_COLOR_MASK) == 0);
+	packed = attribute_set->color;
+
+	/*
+	 * Now OR in the text attributes settings, taking either the value for
+	 * fixed or the coerced fixed font.
+	 */
+	packed |= attribute_set->blink ? GAGT_BLINK_MASK : 0;
+	packed |= attribute_set->fixed || coerced ? GAGT_FIXED_MASK : 0;
+	packed |= attribute_set->emphasis ? GAGT_EMPHASIS_MASK : 0;
+
+	return packed;
+}
+
+
+/*
+ * gagt_unpack_attributes()
+ *
+ * Unpack a set of packed current color and text rendering attributes from a
+ * single byte, and return the result of unpacking.  This reconstitutes the
+ * text attributes that were current at the time of packing.
+ */
+static void gagt_unpack_attributes(unsigned char packed, gagt_attrset_t *attribute_set) {
+	assert(attribute_set);
+
+	attribute_set->color = packed & GAGT_COLOR_MASK;
+	attribute_set->blink = (packed & GAGT_BLINK_MASK) != 0;
+	attribute_set->fixed = (packed & GAGT_FIXED_MASK) != 0;
+	attribute_set->emphasis = (packed & GAGT_EMPHASIS_MASK) != 0;
+}
+
+
+/*
+ * gagt_pack_current_attributes()
+ *
+ * Pack the current color and text rendering attributes into a single byte,
+ * and return it.
+ */
+static unsigned char gagt_pack_current_attributes() {
+	return gagt_pack_attributes(&gagt_current_attribute_set, gagt_coerced_fixed);
+}
+
+
+/*
+ * gagt_init_user_styles()
+ *
+ * Attempt to set up two defined styles, User1 and User2, to represent
+ * fixed font with AGT emphasis (rendered as Glk subheader), and fixed font
+ * with AGT blink (rendered as Glk emphasis), respectively.
+ *
+ * The Glk stylehints here may not actually be honored by the Glk library.
+ * We'll try to detect this later on.
+ */
+static void gagt_init_user_styles() {
+	/*
+	 * Set User1 to be fixed width, bold, and not italic.  Here we're sort of
+	 * assuming that the style starts life equal to Normal.
+	 */
+	g_vm->glk_stylehint_set(wintype_TextBuffer, style_User1,
+	                        stylehint_Proportional, 0);
+	g_vm->glk_stylehint_set(wintype_TextBuffer, style_User1, stylehint_Weight, 1);
+	g_vm->glk_stylehint_set(wintype_TextBuffer, style_User1, stylehint_Oblique, 0);
+
+	/*
+	 * Set User2 to be fixed width, normal, and italic, with the same
+	 * assumptions.
+	 */
+	g_vm->glk_stylehint_set(wintype_TextBuffer, style_User2,
+	                        stylehint_Proportional, 0);
+	g_vm->glk_stylehint_set(wintype_TextBuffer, style_User2, stylehint_Weight, 0);
+	g_vm->glk_stylehint_set(wintype_TextBuffer, style_User2, stylehint_Oblique, 1);
+}
+
+
+/*
+ * gagt_confirm_appearance()
+ *
+ * Attempt to find out if a Glk style's on screen appearance matches a given
+ * expectation.  There's a chance (often 100% with current Xglk) that we
+ * can't tell, in which case we'll play safe, and say that it doesn't (our
+ * caller is hoping it does).
+ *
+ * That is, when we return FALSE, we mean either it's not as expected, or we
+ * don't know.
+ */
+static int gagt_confirm_appearance(glui32 style, glui32 stylehint, glui32 expected) {
+	uint result;
+
+	if (g_vm->glk_style_measure(gagt_main_window, style, stylehint, &result)) {
+		/*
+		 * Measurement succeeded, so return TRUE if the result matches the
+		 * caller's expectation.
+		 */
+		if (result == expected)
+			return TRUE;
+	}
+
+	/* No straight answer, or the style's stylehint failed to match. */
+	return FALSE;
+}
+
+
+/*
+ * gagt_is_style_fixed()
+ * gagt_is_style_bold()
+ * gagt_is_style_oblique()
+ *
+ * Convenience functions for gagt_select_style().  A return of TRUE indicates
+ * that the style has this attribute; FALSE indicates either that it hasn't,
+ * or that it's not determinable.
+ */
+static int gagt_is_style_fixed(glui32 style) {
+	return gagt_confirm_appearance(style, stylehint_Proportional, 0);
+}
+
+static int gagt_is_style_bold(glui32 style) {
+	return gagt_confirm_appearance(style, stylehint_Weight, 1);
+}
+
+static int gagt_is_style_oblique(glui32 style) {
+	return gagt_confirm_appearance(style, stylehint_Oblique, 1);
+}
+
+
+/*
+ * gagt_select_style()
+ *
+ * Given a set of AGT text attributes, this function returns a Glk style that
+ * is suitable (or more accurately, the best we can come up with) for render-
+ * ing this set of attributes.
+ *
+ * For now, we ignore color totally, and just concentrate on the other attr-
+ * ibutes.  This is because few, if any, games use color (no Photopia here),
+ * few Glk libraries, at least on Linux, allow fine grained control over text
+ * color, and even if you can get it, the scarcity of user-defined styles in
+ * Glk makes it too painful to contemplate.
+ */
+static glui32 gagt_select_style(gagt_attrset_t *attribute_set) {
+	glui32 style;
+	assert(attribute_set);
+
+	/*
+	 * Glk styles are mutually exclusive, so here we'll work here by making a
+	 * precedence selection: AGT emphasis take precedence over AGT blinking,
+	 * which itself takes precedence over normal text.  Fortunately, few, if
+	 * any, AGT games set both emphasis and blinking (not likely to be a
+	 * pleasant combination).
+	 *
+	 * We'll try to map AGT emphasis to Glk Subheader, AGT blink to Glk
+	 * Emphasized, and normal text to Glk Normal, with modifications to this
+	 * for fixed width requests.
+	 *
+	 * First, then, see if emphasized text is requested in the attributes.
+	 */
+	if (attribute_set->emphasis) {
+		/*
+		 * Consider whether something requested a fixed width font or
+		 * disallowed a proportional one.
+		 *
+		 * Glk Preformatted is boring, flat, and lifeless.  It often offers no
+		 * fine grained control over emphasis, and so on.  So here we try to
+		 * find something better.  However, not all Glk libraries implement
+		 * stylehints, so we need to try to be careful to ensure that we get a
+		 * fixed width font, no matter what else we may miss out on.
+		 */
+		if (attribute_set->fixed) {
+			/*
+			 * To start off, we'll see if User1, the font we set up for fixed
+			 * width bold, really is fixed width and bold.  If it is, we'll
+			 * use it.
+			 *
+			 * If it isn't, we'll check Subheader.  Our Glk library probably
+			 * isn't implementing stylehints, but if Subheader is fixed width,
+			 * it may provide a better look than Preformatted -- certainly
+			 * it's worth a go.
+			 *
+			 * If Subheader isn't fixed width, we'll take another look at User1.
+			 * It could be that the check for bold wasn't definitive, but it
+			 * is nevertheless bold.  So check for fixed width -- if set, it's
+			 * probably good enough to use this font, certainly no worse than
+			 * Preformatted.
+			 *
+			 * If Subheader isn't guaranteed fixed width, nor is User1, we're
+			 * cornered into Preformatted.
+			 */
+			if (gagt_is_style_fixed(style_User1)
+			        && gagt_is_style_bold(style_User1))
+				style = style_User1;
+
+			else if (gagt_is_style_fixed(style_Subheader))
+				style = style_Subheader;
+
+			else if (gagt_is_style_fixed(style_User1))
+				style = style_User1;
+
+			else
+				style = style_Preformatted;
+		} else
+			/* This is the easy case, use Subheader. */
+			style = style_Subheader;
+	} else if (attribute_set->blink) {
+		/*
+		 * Again, consider whether something requested a fixed width
+		 * font or disallowed a proportional one.
+		 */
+		if (attribute_set->fixed) {
+			/*
+			 * As above, try to find something better than Preformatted, first
+			 * trying User2, then Emphasized, then User2 again, and finally
+			 * settling for Preformatted if neither of these two looks any
+			 * better.
+			 */
+			if (gagt_is_style_fixed(style_User2)
+			        && gagt_is_style_oblique(style_User2))
+				style = style_User2;
+
+			else if (gagt_is_style_fixed(style_Emphasized))
+				style = style_Emphasized;
+
+			else if (gagt_is_style_fixed(style_User2))
+				style = style_User2;
+
+			else
+				style = style_Preformatted;
+		} else
+			/* This is the easy case, use Emphasized. */
+			style = style_Emphasized;
+	} else {
+		/*
+		 * There's no emphasis or blinking in the attributes.  In this case,
+		 * use Preformatted for fixed width, and Normal for text that can be
+		 * rendered proportionally.
+		 */
+		if (attribute_set->fixed)
+			style = style_Preformatted;
+		else
+			style = style_Normal;
+	}
+
+	return style;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port output buffering functions                                */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Buffering game output happens at two levels.  The first level is a single
+ * line buffer, used to catch text sent to us with agt_puts().  In parallel
+ * with the text strings, we keep and buffer the game text attributes, as
+ * handed to agt_textcolor(), that are in effect at the time the string is
+ * handed to us, packed for brevity.
+ *
+ * As each line is completed, by a call to agt_newline(), this single line
+ * buffer is transferred to a main text page buffer.  The main page buffer
+ * has places in it where we can assign paragraph, font hints, and perhaps
+ * other marker information to a line.  Initially unset, they're filled in
+ * at the point where we need to display the buffer.
+ */
+
+/*
+ * Definition of font hints values.  Font hints may be:
+ *   o none, for lines not in a definite paragraph;
+ *   o proportional, for lines that can probably be safely rendered in a
+ *     proportional font (if the AGT game text attributes allow it) and
+ *     where the newline may be replaced by a space;
+ *   o proportional_newline, for lines that may be rendered using a
+ *     proportional font, but where the newline looks like it matters;
+ *   o proportional_newline_standout, for proportional_newline lines that
+ *     are also standout (for spacing in display functions);
+ *   o fixed_width, for tables and other text that looks like it is a
+ *     candidate for fixed font output.
+ */
+typedef enum {
+	HINT_NONE,
+	HINT_PROPORTIONAL,
+	HINT_PROPORTIONAL_NEWLINE,
+	HINT_PROPORTIONAL_NEWLINE_STANDOUT,
+	HINT_FIXED_WIDTH
+} gagt_font_hint_t;
+
+/* Magic number used to ensure a pointer points to a page buffer line. */
+static const unsigned int GAGT_LINE_MAGIC = 0x5bc14482;
+
+/*
+ * Definition of a single line buffer.  This is a growable string and a
+ * parallel growable attributes array.  The string is buffered without any
+ * null terminator -- not needed since we retain length.
+ */
+typedef struct {
+	unsigned char *data;        /* Buffered character data. */
+	unsigned char *attributes;  /* Parallel character attributes, packed. */
+	int allocation;             /* Bytes allocated to each of the above. */
+	int length;                 /* Amount of data actually buffered. */
+} gagt_string_t;
+typedef gagt_string_t *gagt_stringref_t;
+
+/*
+ * Definition of a page buffer entry.  This is a structure that holds the
+ * the result of a single line buffer above, plus additional areas that
+ * describe line text positioning, a blank line flag, a paragraph pointer
+ * (NULL if not in a paragraph), and a font hint.
+ */
+typedef struct gagt_line_s *gagt_lineref_t;
+typedef struct gagt_paragraph_s *gagt_paragraphref_t;
+
+struct gagt_line_s {
+	unsigned int magic;             /* Assertion check dog-tag. */
+
+	gagt_string_t buffer;           /* Buffered line string data. */
+
+	int indent;                     /* Line indentation. */
+	int outdent;                    /* Trailing line whitespace. */
+	int real_length;                /* Real line length. */
+	int is_blank;                   /* Line blank flag. */
+	int is_hyphenated;              /* Line hyphenated flag. */
+
+	gagt_paragraphref_t paragraph;  /* Paragraph containing the line. */
+	gagt_font_hint_t font_hint;     /* Line's font hint. */
+
+	gagt_lineref_t next;            /* List next element. */
+	gagt_lineref_t prior;           /* List prior element. */
+};
+
+/*
+ * Definition of the actual page buffer.  This is a doubly-linked list of
+ * lines, with a tail pointer to facilitate adding entries at the end.
+ */
+static gagt_lineref_t gagt_page_head = NULL,
+                      gagt_page_tail = NULL;
+
+/*
+ * Definition of the current output line; this one is appended to on
+ * agt_puts(), and transferred into the page buffer on agt_newline().
+ */
+static gagt_string_t gagt_current_buffer = { NULL, NULL, 0, 0 };
+
+/*
+ * gagt_string_append()
+ * gagt_string_transfer()
+ * gagt_string_free()
+ *
+ * String append, move, and allocation free for string_t buffers.
+ */
+static void gagt_string_append(gagt_stringref_t buffer, const char *string,
+                               unsigned char packed_attributes) {
+	int length, bytes;
+
+	/*
+	 * Find the size we'll need from the line buffer to add this string,
+	 * and grow buffer if necessary.
+	 */
+	length = strlen(string);
+	for (bytes = buffer->allocation; bytes < buffer->length + length;)
+		bytes = bytes == 0 ? 1 : bytes << 1;
+
+	if (bytes > buffer->allocation) {
+		buffer->data = (uchar *)gagt_realloc(buffer->data, bytes);
+		buffer->attributes = (uchar *)gagt_realloc(buffer->attributes, bytes);
+
+		buffer->allocation = bytes;
+	}
+
+	/* Add string to the line buffer, and store packed text attributes. */
+	memcpy(buffer->data + buffer->length, string, length);
+	memset(buffer->attributes + buffer->length, packed_attributes, length);
+
+	buffer->length += length;
+}
+
+static void gagt_string_transfer(gagt_stringref_t from, gagt_stringref_t to) {
+	*to = *from;
+	from->data = from->attributes = NULL;
+	from->allocation = from->length = 0;
+}
+
+static void gagt_string_free(gagt_stringref_t buffer) {
+	free(buffer->data);
+	free(buffer->attributes);
+	buffer->data = buffer->attributes = NULL;
+	buffer->allocation = buffer->length = 0;
+}
+
+
+/*
+ * gagt_get_string_indent()
+ * gagt_get_string_outdent()
+ * gagt_get_string_real_length()
+ * gagt_is_string_blank()
+ * gagt_is_string_hyphenated()
+ *
+ * Metrics functions for string_t buffers.
+ */
+static int gagt_get_string_indent(const gagt_stringref_t buffer) {
+	int indent, index;
+
+	indent = 0;
+	for (index = 0;
+	        index < buffer->length && isspace(buffer->data[index]);
+	        index++)
+		indent++;
+
+	return indent;
+}
+
+static int gagt_get_string_outdent(const gagt_stringref_t buffer) {
+	int outdent, index;
+
+	outdent = 0;
+	for (index = buffer->length - 1;
+	        index >= 0 && isspace(buffer->data[index]); index--)
+		outdent++;
+
+	return outdent;
+}
+
+
+static int gagt_get_string_real_length(const gagt_stringref_t buffer) {
+	int indent, outdent;
+
+	indent = gagt_get_string_indent(buffer);
+	outdent = gagt_get_string_outdent(buffer);
+
+	return indent == buffer->length ? 0 : buffer->length - indent - outdent;
+}
+
+static int gagt_is_string_blank(const gagt_stringref_t buffer) {
+	return gagt_get_string_indent(buffer) == buffer->length;
+}
+
+static int gagt_is_string_hyphenated(const gagt_stringref_t buffer) {
+	int is_hyphenated;
+
+	is_hyphenated = FALSE;
+
+	if (!gagt_is_string_blank(buffer)
+	        && gagt_get_string_real_length(buffer) > 1) {
+		int last;
+
+		last = buffer->length - gagt_get_string_outdent(buffer) - 1;
+
+		if (buffer->data[last] == '-') {
+			if (isalpha(buffer->data[last - 1]))
+				is_hyphenated = TRUE;
+		}
+	}
+
+	return is_hyphenated;
+}
+
+
+/*
+ * gagt_output_delete()
+ *
+ * Delete all buffered page and line text.  Free all malloc'ed buffer memory,
+ * and return the buffer variables to their initial values.
+ */
+static void gagt_output_delete() {
+	gagt_lineref_t line, next_line;
+
+	for (line = gagt_page_head; line; line = next_line) {
+		assert(line->magic == GAGT_LINE_MAGIC);
+		next_line = line->next;
+
+		gagt_string_free(&line->buffer);
+
+		memset(line, 0, sizeof(*line));
+		free(line);
+	}
+
+	gagt_page_head = gagt_page_tail = NULL;
+
+	gagt_string_free(&gagt_current_buffer);
+}
+
+
+/*
+ * agt_puts()
+ *
+ * Buffer the string passed in into our current single line buffer.  The
+ * function converts to ISO 8859 Latin-1 encoding before buffering.
+ */
+void agt_puts(const char *cp_string) {
+	assert(cp_string);
+
+	if (!BATCH_MODE) {
+		char *iso_string;
+		unsigned char packed;
+		int length;
+
+		/* Update the apparent (virtual) window x position. */
+		length = strlen(cp_string);
+		curr_x += length;
+
+		/*
+		 * Convert the buffer from IBM cp 437 to Glk's ISO 8859 Latin-1, and
+		 * add string and packed text attributes to the current line buffer.
+		 */
+		iso_string = (char *)gagt_malloc(length + 1);
+		gagt_cp_to_iso((const uchar *)cp_string, (uchar *)iso_string);
+		packed = gagt_pack_current_attributes();
+		gagt_string_append(&gagt_current_buffer, iso_string, packed);
+
+		/* Add the string to any script file. */
+		if (script_on)
+			textputs(scriptfile, iso_string);
+
+		free(iso_string);
+		gagt_debug("agt_puts", "string='%s'", cp_string);
+	}
+}
+
+
+/*
+ * agt_newline()
+ *
+ * Accept a newline to the main window.  Our job here is to append the
+ * current line buffer to the page buffer, and clear the line buffer to
+ * begin accepting new text.
+ */
+void agt_newline() {
+	if (!BATCH_MODE) {
+		gagt_lineref_t line;
+
+		/* Update the apparent (virtual) window x position. */
+		curr_x = 0;
+
+		/* Create a new line entry for the page buffer. */
+		line = (gagt_lineref_t)gagt_malloc(sizeof(*line));
+		line->magic = GAGT_LINE_MAGIC;
+
+		/* Move the line from the line buffer into the page buffer. */
+		gagt_string_transfer(&gagt_current_buffer, &line->buffer);
+
+		/* Fill in the line buffer metrics. */
+		line->indent = gagt_get_string_indent(&line->buffer);
+		line->outdent = gagt_get_string_outdent(&line->buffer);
+		line->real_length = gagt_get_string_real_length(&line->buffer);
+		line->is_blank = gagt_is_string_blank(&line->buffer);
+		line->is_hyphenated = gagt_is_string_hyphenated(&line->buffer);
+
+		/* For now, default the remaining page buffer fields for the line. */
+		line->paragraph = NULL;
+		line->font_hint = HINT_NONE;
+
+		/* Add to the list, creating a new list if necessary. */
+		line->next = NULL;
+		line->prior = gagt_page_tail;
+		if (gagt_page_head)
+			gagt_page_tail->next = line;
+		else
+			gagt_page_head = line;
+		gagt_page_tail = line;
+
+		/* Add a newline to any script file. */
+		if (script_on)
+			textputs(scriptfile, "\n");
+
+		gagt_debug("agt_newline", "");
+	}
+}
+
+
+/*
+ * gagt_get_first_page_line()
+ * gagt_get_next_page_line()
+ * gagt_get_prior_page_line()
+ *
+ * Iterator functions for the page buffer.  These functions return the first
+ * line from the page buffer, the next line, or the previous line, given a
+ * line, respectively.  They return NULL if no lines, or no more lines, are
+ * available.
+ */
+static gagt_lineref_t gagt_get_first_page_line() {
+	gagt_lineref_t line;
+
+	line = gagt_page_head;
+	assert(!line || line->magic == GAGT_LINE_MAGIC);
+	return line;
+}
+
+static gagt_lineref_t gagt_get_next_page_line(const gagt_lineref_t line) {
+	gagt_lineref_t next_line;
+	assert(line && line->magic == GAGT_LINE_MAGIC);
+
+	next_line = line->next;
+	assert(!next_line || next_line->magic == GAGT_LINE_MAGIC);
+	return next_line;
+}
+
+static gagt_lineref_t gagt_get_prior_page_line(const gagt_lineref_t line) {
+	gagt_lineref_t prior_line;
+	assert(line && line->magic == GAGT_LINE_MAGIC);
+
+	prior_line = line->prior;
+	assert(!prior_line || prior_line->magic == GAGT_LINE_MAGIC);
+	return prior_line;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port paragraphing functions and data                           */
+/*---------------------------------------------------------------------*/
+
+/* Magic number used to ensure a pointer points to a paragraph. */
+static const unsigned int GAGT_PARAGRAPH_MAGIC = 0xb9a2297b;
+
+/* Forward definition of special paragraph reference. */
+typedef const struct gagt_special_s *gagt_specialref_t;
+
+/*
+ * Definition of a paragraph entry.  This is a structure that holds a
+ * pointer to the first line buffer in the paragraph.
+ */
+struct gagt_paragraph_s {
+	unsigned int magic;             /* Assertion check dog-tag. */
+
+	gagt_lineref_t first_line;      /* First line in the paragraph. */
+	gagt_specialref_t special;      /* Special paragraph entry. */
+
+	int line_count;                 /* Number of lines in the paragraph. */
+	int id;                         /* Paragraph id, sequence, for debug only. */
+
+	gagt_paragraphref_t next;       /* List next element. */
+	gagt_paragraphref_t prior;      /* List prior element. */
+};
+
+/*
+ * A doubly-linked list of paragraphs, with a tail pointer to facilitate
+ * adding entries at the end.
+ */
+static gagt_paragraphref_t gagt_paragraphs_head = NULL,
+                           gagt_paragraphs_tail = NULL;
+
+/*
+ * gagt_paragraphs_delete()
+ *
+ * Delete paragraphs held in the list.  This function doesn't delete the
+ * page buffer lines, just the paragraphs describing the page.
+ */
+static void gagt_paragraphs_delete() {
+	gagt_paragraphref_t paragraph, next_paragraph;
+
+	for (paragraph = gagt_paragraphs_head; paragraph; paragraph = next_paragraph) {
+		assert(paragraph->magic == GAGT_PARAGRAPH_MAGIC);
+		next_paragraph = paragraph->next;
+
+		memset(paragraph, 0, sizeof(*paragraph));
+		free(paragraph);
+	}
+
+	gagt_paragraphs_head = gagt_paragraphs_tail = NULL;
+}
+
+
+/*
+ * gagt_find_paragraph_start()
+ *
+ * Find and return the next non-blank line in the page buffer, given a start
+ * point.  Returns NULL if there are no more blank lines.
+ */
+static gagt_lineref_t gagt_find_paragraph_start(const gagt_lineref_t begin) {
+	gagt_lineref_t line, match;
+
+	/*
+	 * Advance line to the beginning of the next paragraph, stopping on the
+	 * first non-blank line, or at the end of the page buffer.
+	 */
+	match = NULL;
+	for (line = begin; line; line = gagt_get_next_page_line(line)) {
+		if (!line->is_blank) {
+			match = line;
+			break;
+		}
+	}
+
+	return match;
+}
+
+
+/*
+ * gagt_find_block_end()
+ * gagt_find_blank_line_block_end()
+ *
+ * Find and return the apparent end of a paragraph from the page buffer,
+ * given a start point, and an indentation reference.  The end is either
+ * the point where indentation returns to the reference indentation, or
+ * the next blank line.
+ *
+ * Indentation reference can be -1, indicating that only the next blank
+ * line will end the paragraph.  Indentation references less than 1 are
+ * also ignored.
+ */
+static gagt_lineref_t gagt_find_block_end(const gagt_lineref_t begin, int indent) {
+	gagt_lineref_t line, match;
+
+	/*
+	 * Initialize the match to be the start of the block, then advance line
+	 * until we hit a blank line or the end of the page buffer.  At this point,
+	 * match contains the last line checked.
+	 */
+	match = begin;
+	for (line = begin; line; line = gagt_get_next_page_line(line)) {
+		/*
+		 * Found if we reach a blank line, or when given an indentation to
+		 * check for, we find it.
+		 */
+		if (line->is_blank || (indent > 0 && line->indent == indent))
+			break;
+
+		match = line;
+	}
+
+	return match;
+}
+
+static gagt_lineref_t gagt_find_blank_line_block_end(const gagt_lineref_t begin) {
+	return gagt_find_block_end(begin, -1);
+}
+
+
+/*
+ * gagt_find_paragraph_end()
+ *
+ * Find and return the apparent end of a paragraph from the page buffer,
+ * given a start point.  The function attempts to recognize paragraphs by
+ * the "shape" of indentation.
+ */
+static gagt_lineref_t gagt_find_paragraph_end(const gagt_lineref_t first_line) {
+	gagt_lineref_t second_line;
+
+	/*
+	 * If the start line is the last line in the buffer, or if the next line
+	 * is a blank line, return the start line as also being the end of the
+	 * paragraph.
+	 */
+	second_line = gagt_get_next_page_line(first_line);
+	if (!second_line || second_line->is_blank) {
+		return first_line;
+	}
+
+	/*
+	 * Time to look at line indentations...
+	 *
+	 * If either line is grossly indented, forget about trying to infer
+	 * anything from this, and just break the paragraph on the next blank line.
+	 */
+	if (first_line->indent > screen_width / 4
+	        || second_line->indent > screen_width / 4) {
+		return gagt_find_blank_line_block_end(second_line);
+	}
+
+	/*
+	 * If the first line is indented more than the second, end the paragraph
+	 * on a blank line, or on a return in indentation to the level of the
+	 * first line.  Here we're looking for paragraphs with the shape
+	 *
+	 *     aksjdj jfkasjd fjkasjd ajksdj fkaj djf akjsd fkjas dfs
+	 * kasjdlkfjkj fj aksd jfjkasj dlkfja skjdk flaks dlf jalksdf
+	 * ksjdf kjs kdf lasjd fkjalks jdfkjasjd flkjasl djfkasjfdkl
+	 */
+	else if (first_line->indent > second_line->indent) {
+		return gagt_find_block_end(second_line, first_line->indent);
+	}
+
+	/*
+	 * If the second line is more indented than the first, this may indicate
+	 * a title line, followed by normal indented paragraphing.  In this case,
+	 * use the second line indentation as the reference, and begin searching
+	 * at the next line.  This finds
+	 *
+	 * ksjdkfjask ksadf
+	 *     kajskd fksjkfj jfkj jfkslaj fksjlfj jkjskjlfa j fjksal
+	 * sjkkdjf sj fkjkajkdlfj lsjak dfjk djkfjskl dklf alks dfll
+	 * fjksja jkj dksja kjdk kaj dskfj aksjdf aksjd kfjaks fjks
+	 *
+	 * and
+	 *
+	 * asdfj kjsdf kjs
+	 *     akjsdkj fkjs kdjfa lskjdl fjalsj dlfjksj kdj fjkd jlsjd
+	 *     jalksj jfk slj lkfjsa lkjd lfjlaks dlfkjals djkj alsjd
+	 *     kj jfksj fjksjl alkjs dlkjf lakjsd fkjas ldkj flkja fsd
+	 */
+	else if (second_line->indent > first_line->indent) {
+		gagt_lineref_t third_line;
+
+		/*
+		 * See if we have a third buffer line to look at.  If we don't, or if
+		 * we do but it's blank, the paragraph ends here.
+		 */
+		third_line = gagt_get_next_page_line(second_line);
+		if (!third_line || third_line->is_blank) {
+			return second_line;
+		}
+
+		/* As above, give up on gross indentation. */
+		if (second_line->indent > screen_width / 4
+		        || third_line->indent > screen_width / 4) {
+			return gagt_find_blank_line_block_end(third_line);
+		}
+
+		/*
+		 * If the second line indentation exceeds the third, this is probably
+		 * a paragraph with a title line.  In this case, end the paragraph on
+		 * a return to the indentation of the second line.  If not, just find
+		 * the next blank line.
+		 */
+		else if (second_line->indent > third_line->indent) {
+			return gagt_find_block_end(third_line, second_line->indent);
+		} else {
+			return gagt_find_blank_line_block_end(third_line);
+		}
+	}
+
+	/*
+	 * Otherwise, the first and second line indentations are the same, so
+	 * break only on the next empty line.  This finds the simple
+	 *
+	 * ksd kjal jdljf lakjsd lkj lakjsdl jfla jsldj lfaksdj fksj
+	 * lskjd fja kjsdlk fjlakjs ldkjfksj lkjdf kjalskjd fkjklal
+	 * skjd fkaj djfkjs dkfjal sjdlkfj alksjdf lkajs ldkjf alljjf
+	 */
+	else {
+		assert(second_line->indent == first_line->indent);
+		return gagt_find_blank_line_block_end(second_line);
+	}
+}
+
+
+/*
+ * gagt_paragraph_page()
+ *
+ * This function breaks the page buffer into what appear to be paragraphs,
+ * based on observations of indentation and blank separator lines.
+ */
+static void gagt_paragraph_page() {
+	gagt_lineref_t start;
+
+	assert(!gagt_paragraphs_head && !gagt_paragraphs_tail);
+
+	/* Find the start of the first paragraph. */
+	start = gagt_find_paragraph_start(gagt_get_first_page_line());
+	while (start) {
+		gagt_paragraphref_t paragraph;
+		gagt_lineref_t end, line;
+
+		/* Create a new paragraph entry. */
+		paragraph = (gagt_paragraphref_t)gagt_malloc(sizeof(*paragraph));
+		paragraph->magic = GAGT_PARAGRAPH_MAGIC;
+		paragraph->first_line = start;
+		paragraph->special = NULL;
+		paragraph->line_count = 1;
+		paragraph->id = gagt_paragraphs_tail ? gagt_paragraphs_tail->id + 1 : 0;
+
+		/* Add to the list, creating a new list if necessary. */
+		paragraph->next = NULL;
+		paragraph->prior = gagt_paragraphs_tail;
+		if (gagt_paragraphs_head)
+			gagt_paragraphs_tail->next = paragraph;
+		else
+			gagt_paragraphs_head = paragraph;
+		gagt_paragraphs_tail = paragraph;
+
+		/* From the start, identify the paragraph end. */
+		end = gagt_find_paragraph_end(start);
+
+		/*
+		 * Set paragraph in each line identified as part of this paragraph,
+		 * and increment the paragraph's line count.
+		 */
+		for (line = start;
+		        line != end; line = gagt_get_next_page_line(line)) {
+			line->paragraph = paragraph;
+			paragraph->line_count++;
+		}
+		end->paragraph = paragraph;
+
+		/*
+		 * If there's another line, look for the next paragraph there,
+		 * otherwise we're done.
+		 */
+		line = gagt_get_next_page_line(end);
+		if (line)
+			start = gagt_find_paragraph_start(line);
+		else
+			start = NULL;
+	}
+}
+
+
+/*
+ * gagt_get_first_paragraph()
+ * gagt_get_next_paragraph()
+ *
+ * Iterator functions for the paragraphs list.
+ */
+static gagt_paragraphref_t gagt_get_first_paragraph() {
+	gagt_paragraphref_t paragraph;
+
+	paragraph = gagt_paragraphs_head;
+	assert(!paragraph || paragraph->magic == GAGT_PARAGRAPH_MAGIC);
+	return paragraph;
+}
+
+static gagt_paragraphref_t gagt_get_next_paragraph(const gagt_paragraphref_t paragraph) {
+	gagt_paragraphref_t next_paragraph;
+	assert(paragraph && paragraph->magic == GAGT_PARAGRAPH_MAGIC);
+
+	next_paragraph = paragraph->next;
+	assert(!next_paragraph || next_paragraph->magic == GAGT_PARAGRAPH_MAGIC);
+	return next_paragraph;
+}
+
+
+/*
+ * gagt_get_first_paragraph_line()
+ * gagt_get_next_paragraph_line()
+ * gagt_get_prior_paragraph_line()
+ *
+ * Iterator functions for the page buffer.  These functions implement a
+ * paragraph-based view of the page buffer.
+ *
+ * The functions find the first line of a given paragraph; given a line,
+ * the next line in the same paragraph, or NULL if line is the last para-
+ * graph line (or the last line in the page buffer); and given a line,
+ * the previous line in the same paragraph, or NULL if line is the first
+ * paragraph line (or the first line in the page buffer).
+ */
+static gagt_lineref_t gagt_get_first_paragraph_line(const gagt_paragraphref_t paragraph) {
+	assert(paragraph && paragraph->magic == GAGT_PARAGRAPH_MAGIC);
+
+	/* Return the first line for the requested paragraph. */
+	return paragraph->first_line;
+}
+
+static gagt_lineref_t gagt_get_next_paragraph_line(const gagt_lineref_t line) {
+	gagt_lineref_t next_line;
+
+	/* Get the next line; return it if the paragraph matches, else NULL. */
+	next_line = gagt_get_next_page_line(line);
+	if (next_line && next_line->paragraph == line->paragraph)
+		return next_line;
+	else
+		return NULL;
+}
+
+static gagt_lineref_t gagt_get_prior_paragraph_line(const gagt_lineref_t line) {
+	gagt_lineref_t prior_line;
+
+	/* Get the previous line; return it if the paragraph matches, else NULL. */
+	prior_line = gagt_get_prior_page_line(line);
+	if (prior_line && prior_line->paragraph == line->paragraph)
+		return prior_line;
+	else
+		return NULL;
+}
+
+
+/*
+ * gagt_get_paragraph_line_count()
+ *
+ * Return the count of lines contained in the paragraph.
+ */
+static int gagt_get_paragraph_line_count(const gagt_paragraphref_t paragraph) {
+	assert(paragraph && paragraph->magic == GAGT_PARAGRAPH_MAGIC);
+
+	return paragraph->line_count;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port page buffer analysis functions                            */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Threshold for consecutive punctuation/spaces before we decide that a line
+ * is in fact part of a table, and a small selection of characters to apply
+ * a somewhat larger threshold to when looking for punctuation (typically,
+ * characters that appear together multiple times in non-table text).
+ */
+static const int GAGT_THRESHOLD = 4,
+                 GAGT_COMMON_THRESHOLD = 8;
+static const char *const GAGT_COMMON_PUNCTUATION = ".!?";
+
+
+/*
+ * gagt_line_is_standout()
+ *
+ * Return TRUE if a page buffer line appears to contain "standout" text.
+ * This is one of:
+ *    - a line where all characters have some form of AGT text attribute
+ *      set (blinking, fixed width font, or emphasis),
+ *    - a line where each alphabetical character is uppercase.
+ * Typically, this describes room and other miscellaneous header lines.
+ */
+static int gagt_line_is_standout(const gagt_lineref_t line) {
+	int index, all_formatted, upper_count, lower_count;
+
+	/*
+	 * Look at the line, for cases where all characters in it have AGT font
+	 * attributes, and counting the upper and lower case characters.  Iterate
+	 * over only the significant characters in the string.
+	 */
+	all_formatted = TRUE;
+	upper_count = lower_count = 0;
+	for (index = line->indent;
+	        index < line->buffer.length - line->outdent; index++) {
+		gagt_attrset_t attribute_set;
+		unsigned char character;
+
+		gagt_unpack_attributes(line->buffer.attributes[index], &attribute_set);
+		character = line->buffer.data[index];
+
+		/*
+		 * If no AGT attribute is set for this character, then not all of the
+		 * line is standout text.  In this case, reset the all_formatted flag.
+		 */
+		if (!(attribute_set.blink
+		        || attribute_set.fixed || attribute_set.emphasis))
+			all_formatted = FALSE;
+
+		/* Count upper and lower case characters. */
+		if (islower(character))
+			lower_count++;
+		else if (isupper(character))
+			upper_count++;
+	}
+
+	/*
+	 * Consider standout if every character was formatted, or if the string
+	 * is all uppercase.
+	 */
+	return all_formatted || (upper_count > 0 && lower_count == 0);
+}
+
+
+/*
+ * gagt_set_font_hint_proportional()
+ * gagt_set_font_hint_proportional_newline()
+ * gagt_set_font_hint_fixed_width()
+ *
+ * Helpers for assigning font hints.  Font hints have strengths, and these
+ * functions ensure that gagt_assign_paragraph_font_hints() only increases
+ * strengths, and doesn't need to worry about checking before setting.  In
+ * the case of newline, the function also adds standout to the font hint if
+ * appropriate.
+ */
+static void gagt_set_font_hint_proportional(gagt_lineref_t line) {
+	/* The only weaker hint than proportional is none. */
+	if (line->font_hint == HINT_NONE)
+		line->font_hint = HINT_PROPORTIONAL;
+}
+
+static void gagt_set_font_hint_proportional_newline(gagt_lineref_t line) {
+	/*
+	 * Proportional and none are weaker than newline.  Because of the way we
+	 * set font hints, this function can't be called with a current line hint
+	 * of proportional newline.
+	 */
+	if (line->font_hint == HINT_NONE || line->font_hint == HINT_PROPORTIONAL) {
+		if (gagt_line_is_standout(line))
+			line->font_hint = HINT_PROPORTIONAL_NEWLINE_STANDOUT;
+		else
+			line->font_hint = HINT_PROPORTIONAL_NEWLINE;
+	}
+}
+
+static void gagt_set_font_hint_fixed_width(gagt_lineref_t line) {
+	/* Fixed width font is the strongest hint. */
+	if (line->font_hint == HINT_NONE
+	        || line->font_hint == HINT_PROPORTIONAL
+	        || line->font_hint == HINT_PROPORTIONAL_NEWLINE
+	        || line->font_hint == HINT_PROPORTIONAL_NEWLINE_STANDOUT)
+		line->font_hint = HINT_FIXED_WIDTH;
+}
+
+
+/*
+ * gagt_assign_paragraph_font_hints()
+ *
+ * For a given paragraph in the page buffer, this function looks at the text
+ * style used, and assigns a font hint value to each line.  Font hints
+ * indicate whether the line probably requires fixed width font, or may be
+ * okay in variable width, and for lines that look like they might be okay
+ * in variable width, whether the newline should probably be rendered at the
+ * end of the line, or if it might be omitted.
+ */
+static void gagt_assign_paragraph_font_hints(const gagt_paragraphref_t paragraph) {
+	static int is_initialized = FALSE;
+	static int threshold[BYTE_MAX_VAL + 1];
+
+	gagt_lineref_t line, first_line;
+	int is_table, in_list;
+	assert(paragraph);
+
+	/* On first call, set up the table on punctuation run thresholds. */
+	if (!is_initialized) {
+		int character;
+
+		for (character = 0; character <= BYTE_MAX_VAL; character++) {
+			/*
+			 * Set the threshold, either a normal value, or a larger one for
+			 * punctuation characters that tend to have consecutive runs in
+			 * non-table text.
+			 */
+			if (ispunct(character)) {
+				threshold[character] = strchr(GAGT_COMMON_PUNCTUATION, character)
+				                       ? GAGT_COMMON_THRESHOLD : GAGT_THRESHOLD;
+			}
+		}
+
+		is_initialized = TRUE;
+	}
+
+	/*
+	 * Note the first paragraph line.  This value is commonly used, and under
+	 * certain circumstances, it's also modified later on.
+	 */
+	first_line = gagt_get_first_paragraph_line(paragraph);
+	assert(first_line);
+
+	/*
+	 * Phase 1 -- look for pages that consist of just one paragraph,
+	 *            itself consisting of only one line.
+	 *
+	 * There is no point in attempting alignment of text in a one paragraph,
+	 * one line page.  This would be, for example, an error message from the
+	 * interpreter parser.  In this case, set the line for proportional with
+	 * newline, and return immediately.
+	 */
+	if (gagt_get_first_paragraph() == paragraph
+	        && !gagt_get_next_paragraph(paragraph)
+	        && !gagt_get_next_paragraph_line(first_line)) {
+		/*
+		 * Set the first paragraph line for proportional with a newline, and
+		 * return.
+		 */
+		gagt_set_font_hint_proportional_newline(first_line);
+		return;
+	}
+
+	/*
+	 * Phase 2 -- try to identify paragraphs that are tables, based on
+	 *            looking for runs of punctuation.
+	 *
+	 * Search for any string that has a run of apparent line drawing or other
+	 * formatting characters in it.  If we find one, we'll consider the
+	 * paragraph to be a "table", that is, it has some quality that we might
+	 * destroy if we used a proportional font.
+	 */
+	is_table = FALSE;
+	for (line = first_line;
+	        line && !is_table; line = gagt_get_next_paragraph_line(line)) {
+		int index, counts[BYTE_MAX_VAL + 1], total_counts;
+
+		/*
+		 * Clear the initial counts.  Using memset() here is an order of
+		 * magnitude or two faster than a for-loop.  Also there's a total count
+		 * to detect when counts needs to be recleared, or is already clear.
+		 */
+		memset(counts, 0, sizeof(counts));
+		total_counts = 0;
+
+		/*
+		 * Count consecutive punctuation in the line, excluding the indentation
+		 * and outdent.
+		 */
+		for (index = line->indent;
+		        index < line->buffer.length - line->outdent && !is_table; index++) {
+			int character;
+			character = line->buffer.data[index];
+
+			/* Test this character for punctuation. */
+			if (ispunct(character)) {
+				/*
+				 * Increment the count for this character, and note that
+				 * counts are no longer empty, then compare against threshold.
+				 */
+				counts[character]++;
+				total_counts++;
+
+				is_table = (counts[character] >= threshold[character]);
+			} else {
+				/*
+				 * Re-clear all counts, again with memset() for speed, but only
+				 * if they need clearing.  As they often won't, this optimization
+				 * saves quite a bit of work.
+				 */
+				if (total_counts > 0) {
+					memset(counts, 0, sizeof(counts));
+					total_counts = 0;
+				}
+			}
+		}
+	}
+
+	/*
+	 * Phase 3 -- try again to identify paragraphs that are tables, based
+	 *            this time on looking for runs of whitespace.
+	 *
+	 * If no evidence found so far, look again, this time searching for any
+	 * run of four or more spaces on the line (excluding any lead-in or
+	 * trailing spaces).
+	 */
+	if (!is_table) {
+		for (line = first_line;
+		        line && !is_table; line = gagt_get_next_paragraph_line(line)) {
+			int index, count;
+
+			/*
+			 * Count consecutive spaces in the line, excluding the indentation
+			 * and outdent.
+			 */
+			count = 0;
+			for (index = line->indent;
+			        index < line->buffer.length - line->outdent && !is_table;
+			        index++) {
+				int character;
+				character = line->buffer.data[index];
+
+				if (isspace(character)) {
+					count++;
+					is_table = (count >= GAGT_THRESHOLD);
+				} else
+					count = 0;
+			}
+		}
+	}
+
+	/*
+	 * If the paragraph appears to be a table, and if it consists of more than
+	 * just a single line, mark all lines as fixed font output and return.
+	 */
+	if (is_table && gagt_get_next_paragraph_line(first_line)) {
+		for (line = first_line;
+		        line; line = gagt_get_next_paragraph_line(line)) {
+			gagt_set_font_hint_fixed_width(line);
+		}
+
+		/* Nothing more to do. */
+		return;
+	}
+
+	/*
+	 * Phase 4 -- consider separating the first line from the rest of
+	 *            the paragraph.
+	 *
+	 * Not a table, so the choice is between proportional rendering with a
+	 * newline, and proportional rendering without...
+	 *
+	 * If the first paragraph line is standout or short, render it pro-
+	 * portionally with a newline, and don't consider it as a further part of
+	 * the paragraph.
+	 */
+	if (gagt_line_is_standout(first_line)
+	        || first_line->real_length < screen_width / 2) {
+		/* Set the first paragraph line for a newline. */
+		gagt_set_font_hint_proportional_newline(first_line);
+
+		/*
+		 * Disassociate this line from the rest of the paragraph by moving on
+		 * the value of the first_line variable.  If it turns out that there
+		 * is no next paragraph line, then we have a one-line paragraph, and
+		 * there's no more to do.
+		 */
+		first_line = gagt_get_next_paragraph_line(first_line);
+		if (!first_line)
+			return;
+	}
+
+	/*
+	 * Phase 5 -- try to identify lists by a simple initial look at line
+	 *            indentations.
+	 *
+	 * Look through the paragraph for apparent lists, and decide for each
+	 * line whether it's appropriate to output a newline, and render
+	 * proportionally, or just render proportionally.
+	 *
+	 * After this loop, each line will have some form of font hint assigned
+	 * to it.
+	 */
+	in_list = FALSE;
+	for (line = first_line;
+	        line; line = gagt_get_next_paragraph_line(line)) {
+		gagt_lineref_t next_line;
+
+		next_line = gagt_get_next_paragraph_line(line);
+
+		/*
+		 * Special last-iteration processing.  The newline is always output at
+		 * the end of a paragraph, so if there isn't a next line, then this
+		 * line is the last paragraph line.  Set its font hint appropriately,
+		 * and do no more for the line.
+		 */
+		if (!next_line) {
+			gagt_set_font_hint_proportional_newline(line);
+			continue;
+		}
+
+		/*
+		 * If the next line's indentation is deeper that that of the first
+		 * line, this paragraph looks like it is trying to be some form of a
+		 * list.  In this case, make newline significant for the current line,
+		 * and set the in_list flag so we can delay the return to proportional
+		 * by one line.  On return to first line indentation, make newline
+		 * significant for the return line.
+		 */
+		if (next_line->indent > first_line->indent) {
+			gagt_set_font_hint_proportional_newline(line);
+			in_list = TRUE;
+		} else {
+			if (in_list)
+				gagt_set_font_hint_proportional_newline(line);
+			else
+				gagt_set_font_hint_proportional(line);
+			in_list = FALSE;
+		}
+	}
+
+	/*
+	 * Phase 6 -- look again for lines that look like they are supposed
+	 *            to stand out from their neighbors.
+	 *
+	 * Now rescan the paragraph, looking this time for lines that stand out
+	 * from their neighbours.  Make newline significant for each such line,
+	 * and the line above, if there is one.
+	 *
+	 * Here we split the loop on lines so that we avoid looking at the prior
+	 * line of the current first line -- because of "adjustments", it may not
+	 * be the real paragraph first line.
+	 *
+	 * So, deal with the current first line...
+	 */
+	if (gagt_line_is_standout(first_line)) {
+		/* Make newline significant for this line. */
+		gagt_set_font_hint_proportional_newline(first_line);
+	}
+
+	/* ... then deal with the rest of the lines, looking for standouts. */
+	for (line = gagt_get_next_paragraph_line(first_line);
+	        line; line = gagt_get_next_paragraph_line(line)) {
+		if (gagt_line_is_standout(line)) {
+			gagt_lineref_t prior_line;
+
+			/* Make newline significant for this line. */
+			gagt_set_font_hint_proportional_newline(line);
+
+			/*
+			 * Make newline significant for the line above.  There will always
+			 * be one because we start the loop past the first line.
+			 */
+			prior_line = gagt_get_prior_paragraph_line(line);
+			gagt_set_font_hint_proportional_newline(prior_line);
+		}
+	}
+
+	/*
+	 * Phase 7 -- special case short lines at the paragraph start.
+	 *
+	 * Make a special case of lines that begin a paragraph, and are short and
+	 * followed by a much longer line.  This should catch games which output
+	 * room titles above descriptions without using AGT fonts/bold/whatever.
+	 * Without this trap, room titles and their descriptions are run together.
+	 * This is more programmatic guesswork than heuristics.
+	 */
+	if (gagt_get_next_paragraph_line(first_line)) {
+		gagt_lineref_t next_line;
+
+		next_line = gagt_get_next_paragraph_line(first_line);
+
+		/*
+		 * See if the first line is less than half width, and the second line
+		 * is more than three quarters width.  If it is, set newline as
+		 * significant for the first paragraph line.
+		 */
+		if (first_line->real_length < screen_width / 2
+		        && next_line->real_length > screen_width * 3 / 4) {
+			gagt_set_font_hint_proportional_newline(first_line);
+		}
+	}
+
+	/*
+	 * Phase 8 -- special case paragraphs of only short lines.
+	 *
+	 * Make a special case out of paragraphs where all lines are short.  This
+	 * catches elements like indented addresses.
+	 */
+	if (gagt_get_next_paragraph_line(first_line)) {
+		int all_short;
+
+		all_short = TRUE;
+		for (line = first_line;
+		        line; line = gagt_get_next_paragraph_line(line)) {
+			/* Clear flag if this line isn't 'short'. */
+			if (line->real_length >= screen_width / 2) {
+				all_short = FALSE;
+				break;
+			}
+		}
+
+		/*
+		 * If all lines were short, mark the complete paragraph as having
+		 * significant newlines.
+		 */
+		if (all_short) {
+			for (line = first_line;
+			        line; line = gagt_get_next_paragraph_line(line)) {
+				gagt_set_font_hint_proportional_newline(line);
+			}
+		}
+	}
+}
+
+
+/*
+ * gagt_assign_font_hints()
+ *
+ *
+ * Sets a font hint for each line of each page buffer paragraph that is not
+ * a special paragraph.
+ */
+static void gagt_assign_font_hints() {
+	gagt_paragraphref_t paragraph;
+
+	for (paragraph = gagt_get_first_paragraph();
+	        paragraph; paragraph = gagt_get_next_paragraph(paragraph)) {
+		if (!paragraph->special)
+			gagt_assign_paragraph_font_hints(paragraph);
+	}
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port special paragraph functions and data                      */
+/*---------------------------------------------------------------------*/
+
+/*
+ * It's helpful to handle some AGiliTy interpreter output specially, to im-
+ * prove the look of the text where Glk fonts and styles are available.  We
+ * build a table of paragraphs the interpreter can come out with, and the
+ * replacement text we'll use when we see this paragraph.  Note that matches
+ * are made after factoring out indentation, and replacement lines do not
+ * automatically print with a newline.  All clear, then?  Here's the table
+ * entry definition.
+ */
+enum { GAGT_SPECIAL_MATCH_MAX = 5 };
+
+typedef const struct gagt_special_s {
+	const int line_count;
+	const char *const compare[GAGT_SPECIAL_MATCH_MAX + 1];
+	const char *const replace;
+} gagt_special_t;
+
+/*
+ * Table of special AGiliTy interpreter strings and paragraphs -- where one
+ * appears in game output, we'll print out its replacement instead.  Be
+ * warned; these strings are VERY specific to AGiliTy 1.1.1.1, and are extre-
+ * mely likely to change with any future interpreter releases.  They also
+ * omit initializers with abandon, expecting the compiler to default these
+ * to NULL/zero.  Replacement strings embed style encoding as |x, where x is
+ * E(mphasized), S(ubheader), or N(ormal) for convenience.
+ */
+static gagt_special_t GAGT_SPECIALS[] = {
+
+	/* Initial screen AGT game type line. */
+	{
+		1,
+		{"[Created with Malmberg and Welch's Adventure Game Toolkit]"},
+		"|ECreated with Malmberg and Welch's Adventure Game Toolkit|N\n"
+	},
+
+	/* Normal version of initial interpreter information block. */
+	{
+		4,
+		{
+			"This game is being executed by",
+			"AGiliTy: The (Mostly) Universal AGT Interpreter  version 1.1.1.1",
+			"Copyright (C) 1996-99,2001 by Robert Masenten",
+			"Glk version"
+		},
+		"This game is being executed by:\n\n"
+		"    |SAGiliTy, The (Mostly) Universal AGT Interpreter, Version 1.1.1.1|N\n"
+		"    |ECopyright (C) 1996-1999,2001 by Robert Masenten|N\n"
+		"    |EGlk version|N\n"
+	},
+
+	/* AGiliTy "information" screen header block. */
+	{
+		5,
+		{
+			"AGiliTy",
+			"The (Mostly) Universal AGT Interpreter, version 1.1.1.1",
+			"Copyright (C) 1996-1999,2001 by Robert Masenten",
+			"[Glk version]",
+			"-----------------------------------------------------------"
+		},
+		"|SAGiliTy, The (Mostly) Universal AGT Interpreter, Version 1.1.1.1|N\n"
+		"|ECopyright (C) 1996-1999,2001 by Robert Masenten|N\n"
+		"|EGlk version|N\n"
+	},
+
+	/* "HIT ANY KEY" message, usually displayed after a game's introduction. */
+	{
+		1,
+		{"--- HIT ANY KEY ---"},
+		"|E[Press any key...]|N"
+	},
+
+	/* Alternative, shrunken version of initial interpreter information block. */
+	{
+		2,
+		{
+			"Being run by AGiliTy  version 1.1.1.1, Copyright (C) 1996-99,2001"
+			" Robert Masenten",
+			"Glk version"
+		},
+		"This game is being executed by:\n\n"
+		"    |SAGiliTy, The (Mostly) Universal AGT Interpreter, Version 1.1.1.1|N\n"
+		"    |ECopyright (C) 1996-1999,2001 by Robert Masenten|N\n"
+		"    |EGlk version|N\n"
+	},
+
+	/* Alternative, minimal version of initial interpreter information block. */
+	{
+		1,
+		{
+			"Being run by AGiliTy  version 1.1.1.1, Copyright (C) 1996-99,2001"
+			" Robert Masenten"
+		},
+		"This game is being executed by:\n\n"
+		"    |SAGiliTy, The (Mostly) Universal AGT Interpreter, Version 1.1.1.1|N\n"
+		"    |ECopyright (C) 1996-1999,2001 by Robert Masenten|N\n"
+		"    |EGlk version|N\n"
+	},
+
+	/* Lengthy version of the "Created with..." message. */
+	{
+		2,
+		{
+			"This game was created with Malmberg and Welch's Adventure Game Toolkit;"
+			" it is",
+			"being executed by"
+		},
+		"|ECreated with Malmberg and Welch's Adventure Game Toolkit|N\n"
+	},
+
+	/* Three-line version of initial interpreter information block. */
+	{
+		3,
+		{
+			"AGiliTy: The (Mostly) Universal AGT Interpreter  version 1.1.1.1",
+			"Copyright (C) 1996-99,2001 by Robert Masenten",
+			"Glk version"
+		},
+		"This game is being executed by:\n\n"
+		"    |SAGiliTy, The (Mostly) Universal AGT Interpreter, Version 1.1.1.1|N\n"
+		"    |ECopyright (C) 1996-1999,2001 by Robert Masenten|N\n"
+		"    |EGlk version|N\n"
+	},
+
+	/*
+	 * Assorted special verb output messages, with the extra icky quality that
+	 * we have to spot messages that wrap because we forced screen_width to 80.
+	 */
+	{
+		2,
+		{
+			"[Now in BRIEF mode (room descriptions will only be printed"
+			" when they are entered",
+			"the first time)]"
+		},
+		"|E[Now in BRIEF mode: Room descriptions will only be printed"
+		" when rooms are entered for the first time.]|N\n"
+	},
+
+	{
+		2,
+		{
+			"[Now in VERBOSE mode (room descriptions will be printed"
+			" every time you enter a",
+			"room)]"
+		},
+		"|E[Now in VERBOSE mode: Room descriptions will be printed"
+		" every time you enter a room.]|N\n"
+	},
+
+	{
+		1,
+		{"[LISTEXIT mode on: room exits will be listed.]"},
+		"|E[LISTEXIT mode on: Room exits will be listed.]|N\n"
+	},
+
+	{
+		1,
+		{"[LISTEXIT mode off: room exits will not be listed.]"},
+		"|E[LISTEXIT mode off: Room exits will not be listed.]|N\n"
+	},
+
+	/* End of table sentinel entry.  Do not delete. */
+	{0, {NULL}, NULL}
+};
+
+
+/*
+ * gagt_compare_special_line()
+ * gagt_compare_special_paragraph()
+ *
+ * Helpers for gagt_find_equivalent_special().  Compare line data case-
+ * insensitively, taking care to use lengths rather than relying on line
+ * buffer data being NUL terminated (which it's not); and iterate a complete
+ * special paragraph comparison.
+ */
+static int gagt_compare_special_line(const char *compare, const gagt_lineref_t line) {
+	/*
+	 * Return true if the lengths match, and the real line data (excluding
+	 * indent and outdent) also matches, ignoring case.
+	 */
+	return (int)strlen(compare) == line->real_length
+	       && gagt_strncasecmp(compare,
+	                           (const char *)line->buffer.data + line->indent,
+	                           line->real_length) == 0;
+}
+
+static int gagt_compare_special_paragraph(const gagt_specialref_t special,
+        const gagt_paragraphref_t paragraph) {
+	/* If the line counts match, compare line by line. */
+	if (special->line_count == gagt_get_paragraph_line_count(paragraph)) {
+		gagt_lineref_t line;
+		int index, is_match;
+
+		is_match = TRUE;
+		for (index = 0, line = gagt_get_first_paragraph_line(paragraph);
+		        index < special->line_count && line;
+		        index++, line = gagt_get_next_paragraph_line(line)) {
+			if (!gagt_compare_special_line(special->compare[index], line)) {
+				is_match = FALSE;
+				break;
+			}
+		}
+
+		return is_match;
+	}
+
+	/* Line count mismatch; return FALSE. */
+	return FALSE;
+}
+
+
+/*
+ * gagt_find_equivalent_special()
+ *
+ * Given a paragraph, see if it matches any of the special ones set up in
+ * our array.  Returns the special, or NULL if no match.
+ */
+static gagt_specialref_t gagt_find_equivalent_special(gagt_paragraphref_t paragraph) {
+	gagt_specialref_t special, match;
+
+	/* Check each special paragraph entry for a match against this paragraph. */
+	match = NULL;
+	for (special = GAGT_SPECIALS; special->replace; special++) {
+		if (gagt_compare_special_paragraph(special, paragraph)) {
+			match = special;
+			break;
+		}
+	}
+
+	return match;
+}
+
+
+/*
+ * gagt_mark_specials()
+ *
+ * Search for and mark any lines that match special paragraphs.
+ */
+static void gagt_mark_specials() {
+	static int is_verified = FALSE;
+
+	/*
+	 * Verify special paragraphs table contents.  This checks that each entry
+	 * ends with a NULL comparison, has a replacement, and that the line count
+	 * matches.
+	 */
+	if (!is_verified) {
+		gagt_specialref_t special;
+
+		for (special = GAGT_SPECIALS; special->replace; special++) {
+			int line_count, index;
+
+			line_count = 0;
+			for (index = 0; special->compare[index]; index++)
+				line_count++;
+
+			assert(special->line_count == line_count);
+			assert(special->replace);
+			assert(!special->compare[GAGT_SPECIAL_MATCH_MAX]);
+		}
+
+		is_verified = TRUE;
+	}
+
+	/*
+	 * Search all paragraphs for special matches, if enabled.  When a special
+	 * match is found, mark the paragraph with a pointer to the matching entry.
+	 */
+	if (gagt_replacement_enabled) {
+		gagt_paragraphref_t paragraph;
+
+		for (paragraph = gagt_get_first_paragraph();
+		        paragraph; paragraph = gagt_get_next_paragraph(paragraph)) {
+			paragraph->special = gagt_find_equivalent_special(paragraph);
+		}
+	}
+}
+
+
+/*
+ * gagt_display_special()
+ *
+ * Display the replacement text for the specified special table entry.  The
+ * current Glk style in force is passed in; we return the Glk style in force
+ * after we've done.
+ */
+static glui32 gagt_display_special(const gagt_specialref_t special, glui32 current_style) {
+	glui32 set_style;
+	int index, marker, length;
+	const char *string;
+	assert(special);
+
+	/* Extract replacement string and length. */
+	string = special->replace;
+	assert(string);
+	length = strlen(string);
+
+	set_style = current_style;
+
+	/*
+	 * Iterate each character in replacement string, looking for style escapes,
+	 * and flushing delayed output when one is found.
+	 */
+	marker = 0;
+	for (index = 0; index < length; index++) {
+		if (string[index] == '|') {
+			glui32 style;
+
+			/* Flush delayed output accumulated so far, excluding escape. */
+			g_vm->glk_put_buffer(string + marker, index - marker);
+			marker = index + 2;
+
+			/* Determine any new text style. */
+			style = set_style;
+			switch (string[++index]) {
+			case 'E':
+				style = style_Emphasized;
+				break;
+
+			case 'S':
+				style = style_Subheader;
+				break;
+
+			case 'N':
+				style = style_Normal;
+				break;
+
+			default:
+				gagt_fatal("GLK: Invalid replacement style escape");
+				gagt_exit();
+			}
+
+			/* If style changed, update Glk's style setting. */
+			if (style != set_style) {
+				g_vm->glk_set_style(style);
+				set_style = style;
+			}
+		}
+	}
+
+	/* Output any remaining delayed characters. */
+	if (marker < length)
+		g_vm->glk_put_buffer(string + marker, length - marker);
+
+	return set_style;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port output functions                                          */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Flag for if the user entered "help" as their last input, or if hints have
+ * been silenced as a result of already using a Glk command.
+ */
+static int gagt_help_requested = FALSE,
+           gagt_help_hints_silenced = FALSE;
+
+/*
+ * gagt_display_register_help_request()
+ * gagt_display_silence_help_hints()
+ * gagt_display_provide_help_hint()
+ *
+ * Register a request for help, and print a note of how to get Glk command
+ * help from the interpreter unless silenced.
+ */
+static void gagt_display_register_help_request() {
+	gagt_help_requested = TRUE;
+}
+
+static void gagt_display_silence_help_hints() {
+	gagt_help_hints_silenced = TRUE;
+}
+
+static glui32 gagt_display_provide_help_hint(glui32 current_style) {
+	if (gagt_help_requested && !gagt_help_hints_silenced) {
+		g_vm->glk_set_style(style_Emphasized);
+		g_vm->glk_put_string("[Try 'glk help' for help on special interpreter"
+		                     " commands]\n");
+
+		gagt_help_requested = FALSE;
+		return style_Emphasized;
+	}
+
+	return current_style;
+}
+
+
+/*
+ * gagt_display_text_element()
+ *
+ * Display an element of a buffer string using matching packed attributes.
+ * The currently set Glk style is supplied, and the function returns the
+ * new currently set Glk style.
+ *
+ * The function handles a flag to coerce fixed width font.
+ */
+static glui32 gagt_display_text_element(const char *string, const unsigned char *attributes,
+                                        int length, glui32 current_style, int fixed_width) {
+	int marker, index;
+	glui32 set_style;
+	assert(g_vm->glk_stream_get_current());
+
+	set_style = current_style;
+
+	/*
+	 * Iterate each character in the line range.  We actually delay output
+	 * until we see a change in style; that way, we can send a buffer of
+	 * characters to Glk, rather than sending them just one at a time.
+	 */
+	marker = 0;
+	for (index = 0; index < length; index++) {
+		gagt_attrset_t attribute_set;
+		glui32 style;
+		assert(attributes && string);
+
+		/*
+		 * Unpack the AGT font attributes for this character, and add fixed
+		 * width font coercion.
+		 */
+		gagt_unpack_attributes(attributes[index], &attribute_set);
+		attribute_set.fixed |= fixed_width;
+
+		/*
+		 * Decide on any applicable new Glk text styling.  If it's different
+		 * to the current style, output the delayed characters, and update
+		 * Glk's style setting.
+		 */
+		style = gagt_select_style(&attribute_set);
+		if (style != set_style) {
+			g_vm->glk_put_buffer(string + marker, index - marker);
+			marker = index;
+
+			g_vm->glk_set_style(style);
+			set_style = style;
+		}
+	}
+
+	/* Output any remaining delayed characters. */
+	if (marker < length)
+		g_vm->glk_put_buffer(string + marker, length - marker);
+
+	return set_style;
+}
+
+
+/*
+ * gagt_display_line()
+ *
+ * Display a page buffer line, starting in the current Glk style, and
+ * returning the new current Glk style.
+ *
+ * The function takes additional flags to force fixed width font, skip over
+ * indentation and trailing line whitespace, and trim hyphens (if skipping
+ * trailing whitespace).
+ */
+static glui32 gagt_display_line(const gagt_lineref_t line, glui32 current_style,
+                                int fixed_width, int skip_indent, int skip_outdent,
+                                int trim_hyphen) {
+	int start, length;
+	glui32 set_style;
+
+	/*
+	 * Check the skip indent flag to find the first character to display, and
+	 * the count of characters to display.
+	 */
+	start = 0;
+	length = line->buffer.length;
+	if (skip_indent) {
+		start += line->indent;
+		length -= line->indent;
+	}
+
+	/* Adjust length for skipping outdent and trimming hyphens. */
+	if (skip_outdent) {
+		length -= line->outdent;
+		if (trim_hyphen && line->is_hyphenated)
+			length--;
+	}
+
+	/* Display this line segment. */
+	set_style = gagt_display_text_element((const char *)line->buffer.data + start,
+	                                      line->buffer.attributes + start,
+	                                      length, current_style, fixed_width);
+
+	return set_style;
+}
+
+
+/*
+ * gagt_display_hinted_line()
+ *
+ * Display a page buffer line, starting in the current Glk style, and
+ * returning the new current Glk style.  The function uses the font hints
+ * from the line, and receives the font hint of the prior line.
+ */
+static glui32 gagt_display_hinted_line(const gagt_lineref_t line, glui32 current_style,
+                                       gagt_font_hint_t prior_hint) {
+	glui32 style;
+
+	style = current_style;
+	switch (line->font_hint) {
+	case HINT_FIXED_WIDTH:
+		/* Force fixed width font on the line. */
+		style = gagt_display_line(line, style, TRUE, FALSE, FALSE, FALSE);
+
+		g_vm->glk_put_char('\n');
+		break;
+
+	case HINT_PROPORTIONAL:
+		/*
+		 * Permit proportional font, and suppress outdent.  Suppress indent
+		 * too if this line follows a line that suppressed newline, or is the
+		 * first line in the paragraph.  For all cases, trim the hyphen from
+		 * hyphenated lines.
+		 */
+		if (prior_hint == HINT_PROPORTIONAL || prior_hint == HINT_NONE)
+			style = gagt_display_line(line, style, FALSE, TRUE, TRUE, TRUE);
+		else
+			style = gagt_display_line(line, style, FALSE, FALSE, TRUE, TRUE);
+
+		/*
+		 * Where the line is not hyphenated, output a space in place of newline.
+		 * This lets paragraph text to flow to the full display width.
+		 */
+		if (!line->is_hyphenated)
+			g_vm->glk_put_char(' ');
+		break;
+
+	case HINT_PROPORTIONAL_NEWLINE:
+	case HINT_PROPORTIONAL_NEWLINE_STANDOUT:
+		/*
+		 * As above, permit proportional font, suppress outdent, and suppress
+		 * indent too under certain conditions; in this case, only when the
+		 * prior line suppressed newline.
+		 */
+		if (prior_hint == HINT_PROPORTIONAL)
+			style = gagt_display_line(line, style, FALSE, TRUE, TRUE, FALSE);
+		else
+			style = gagt_display_line(line, style, FALSE, FALSE, TRUE, FALSE);
+
+		g_vm->glk_put_char('\n');
+		break;
+
+	case HINT_NONE:
+		gagt_fatal("GLK: Page buffer line with no font hint");
+		gagt_exit();
+
+	default:
+		gagt_fatal("GLK: Invalid font hint encountered");
+		gagt_exit();
+	}
+
+	return style;
+}
+
+
+/*
+ * gagt_display_auto()
+ *
+ * Display buffered output text to the Glk main window using a bunch of
+ * occasionally rather dodgy heuristics to try to automatically set a suitable
+ * font for the way the text is structured, while replacing special paragraphs
+ * with altered text.
+ */
+static void gagt_display_auto() {
+	gagt_paragraphref_t paragraph;
+	glui32 style;
+
+	style = style_Normal;
+	g_vm->glk_set_style(style);
+
+	/* Handle each paragraph. */
+	for (paragraph = gagt_get_first_paragraph();
+	        paragraph; paragraph = gagt_get_next_paragraph(paragraph)) {
+		/* If a special paragraph, output replacement text instead. */
+		if (paragraph->special) {
+			style = gagt_display_special(paragraph->special, style);
+			g_vm->glk_put_char('\n');
+		} else {
+			gagt_lineref_t line;
+			gagt_font_hint_t prior_hint;
+
+			/* Get the first line of the paragraph. */
+			line = gagt_get_first_paragraph_line(paragraph);
+
+			/*
+			 * Output a blank line where the first line of the first paragraph
+			 * is standout; this sets it apart from the prompt.
+			 */
+			if (paragraph == gagt_get_first_paragraph()
+			        && line == gagt_get_first_paragraph_line(paragraph)) {
+				if (line->font_hint == HINT_PROPORTIONAL_NEWLINE_STANDOUT)
+					g_vm->glk_put_char('\n');
+			}
+
+			/* Handle each line of the paragraph. */
+			prior_hint = HINT_NONE;
+			for (; line; line = gagt_get_next_paragraph_line(line)) {
+				/*
+				 * Print this line according to its font hint, noting any change
+				 * of style and the line's font hint for use next iteration as
+				 * the prior hint.
+				 */
+				style = gagt_display_hinted_line(line, style, prior_hint);
+				prior_hint = line->font_hint;
+			}
+
+			/* Output the newline for the end of the paragraph. */
+			g_vm->glk_put_char('\n');
+		}
+	}
+
+	/* If no paragraphs at all, but a current buffer, output a newline. */
+	if (!gagt_get_first_paragraph() && gagt_current_buffer.length > 0)
+		g_vm->glk_put_char('\n');
+
+	/* Output any help hint and unterminated line from the line buffer. */
+	style = gagt_display_provide_help_hint(style);
+	style = gagt_display_text_element((const char *)gagt_current_buffer.data,
+	                                  gagt_current_buffer.attributes,
+	                                  gagt_current_buffer.length, style, FALSE);
+}
+
+
+/*
+ * gagt_display_manual()
+ *
+ * Display buffered output text in the Glk main window, with either a fixed
+ * width or a proportional font.
+ */
+static void gagt_display_manual(int fixed_width) {
+	gagt_lineref_t line;
+	glui32 style;
+
+	style = style_Normal;
+	g_vm->glk_set_style(style);
+
+	for (line = gagt_get_first_page_line();
+	        line; line = gagt_get_next_page_line(line)) {
+		gagt_paragraphref_t paragraph;
+
+		paragraph = line->paragraph;
+
+		/*
+		 * If this is a special paragraph, display the replacement text on
+		 * its first line and ignore remaining special lines.  Otherwise,
+		 * display the page buffer line using either fixed or proportional
+		 * font, as requested.
+		 */
+		if (paragraph && paragraph->special) {
+			if (gagt_get_first_paragraph_line(paragraph) == line)
+				style = gagt_display_special(paragraph->special, style);
+		} else {
+			style = gagt_display_line(line, style, fixed_width,
+			                          FALSE, FALSE, FALSE);
+			g_vm->glk_put_char('\n');
+		}
+	}
+
+	/* Output any help hint and unterminated line from the line buffer. */
+	style = gagt_display_provide_help_hint(style);
+	style = gagt_display_text_element((const char *)gagt_current_buffer.data,
+	                                  gagt_current_buffer.attributes,
+	                                  gagt_current_buffer.length,
+	                                  style, fixed_width);
+}
+
+
+/*
+ * gagt_display_debug()
+ *
+ * Display the analyzed page buffer in a form that shows all of its gory
+ * detail.
+ */
+static void gagt_display_debug() {
+	gagt_lineref_t line;
+	char buffer[256];
+
+	g_vm->glk_set_style(style_Preformatted);
+	for (line = gagt_get_first_page_line();
+	        line; line = gagt_get_next_page_line(line)) {
+		gagt_paragraphref_t paragraph;
+
+		paragraph = line->paragraph;
+		sprintf(buffer,
+		        "%2d:%2d->%2ld A=%-3d L=%-2d I=%-2d O=%-2d R=%-2d %c%c| ",
+		        paragraph ? paragraph->id + 1 : 0,
+		        paragraph ? paragraph->line_count : 0,
+		        paragraph && paragraph->special
+		        ? paragraph->special - GAGT_SPECIALS + 1 : 0,
+		        line->buffer.allocation, line->buffer.length,
+		        line->indent, line->outdent,
+		        line->real_length,
+		        line->is_hyphenated ? 'h' : '_',
+		        line->is_blank ? 'b' :
+		        line->font_hint == HINT_PROPORTIONAL ? 'P' :
+		        line->font_hint == HINT_PROPORTIONAL_NEWLINE ? 'N' :
+		        line->font_hint == HINT_PROPORTIONAL_NEWLINE_STANDOUT ? 'S' :
+		        line->font_hint == HINT_FIXED_WIDTH ? 'F' : '_');
+		g_vm->glk_put_string(buffer);
+
+		g_vm->glk_put_buffer((const char *)line->buffer.data, line->buffer.length);
+		g_vm->glk_put_char('\n');
+	}
+
+	if (gagt_current_buffer.length > 0) {
+		sprintf(buffer,
+		        "__,__->__ A=%-3d L=%-2d I=__ O=__ R=__ %s| ",
+		        gagt_current_buffer.allocation, gagt_current_buffer.length,
+		        gagt_help_requested ? "HR" : "__");
+		g_vm->glk_put_string(buffer);
+
+		g_vm->glk_put_buffer((const char *)gagt_current_buffer.data, gagt_current_buffer.length);
+	}
+
+	gagt_help_requested = FALSE;
+}
+
+
+/*
+ * gagt_output_flush()
+ *
+ * Flush any buffered output text to the Glk main window, and clear the
+ * buffer ready for new output text.  The function concerns itself with
+ * both the page buffer and any unterminated line in the line buffer.
+ */
+static void gagt_output_flush() {
+	/*
+	 * Run the analysis of page buffer contents.  This will fill in the
+	 * paragraph and font hints fields, any any applicable special pointer,
+	 * for every line held in the buffer.
+	 */
+	gagt_paragraph_page();
+	gagt_mark_specials();
+	gagt_assign_font_hints();
+
+	/*
+	 * Select the appropriate display routine to use, and call it.  The display
+	 * routines present somewhat different output, and are responsible for
+	 * displaying both the page buffer _and_ any buffered current line text.
+	 */
+	switch (gagt_font_mode) {
+	case FONT_AUTOMATIC:
+		gagt_display_auto();
+		break;
+
+	case FONT_FIXED_WIDTH:
+		gagt_display_manual(TRUE);
+		break;
+
+	case FONT_PROPORTIONAL:
+		gagt_display_manual(FALSE);
+		break;
+
+	case FONT_DEBUG:
+		gagt_display_debug();
+		break;
+
+	default:
+		gagt_fatal("GLK: Invalid font mode encountered");
+		gagt_exit();
+	}
+
+	/* Empty the buffer, ready for new game strings. */
+	gagt_paragraphs_delete();
+	gagt_output_delete();
+}
+
+
+/*
+ * agt_clrscr()
+ *
+ * Clear the main playing area window.  Although there may be little point
+ * in flushing (rather than emptying) the buffers, nevertheless that is
+ * what we do.
+ */
+void agt_clrscr() {
+	if (!BATCH_MODE) {
+		/* Update the apparent (virtual) window x position. */
+		curr_x = 0;
+
+		/* Flush any pending buffered output, and clear the main window. */
+		gagt_output_flush();
+		g_vm->glk_window_clear(gagt_main_window);
+
+		/* Add a series of newlines to any script file. */
+		if (script_on)
+			textputs(scriptfile, "\n\n\n\n");
+
+		gagt_debug("agt_clrscr", "");
+	}
+}
+
+
+/*
+ * gagt_styled_string()
+ * gagt_styled_char()
+ * gagt_standout_string()
+ * gagt_standout_char()
+ * gagt_normal_string()
+ * gagt_normal_char()
+ * gagt_header_string()
+ *
+ * Convenience functions to print strings in assorted styles.  A standout
+ * string is one that hints that it's from the interpreter, not the game.
+ */
+static void gagt_styled_string(glui32 style, const char *message) {
+	assert(message);
+
+	g_vm->glk_set_style(style);
+	g_vm->glk_put_string(message);
+	g_vm->glk_set_style(style_Normal);
+}
+
+static void gagt_styled_char(glui32 style, char c) {
+	char buffer[2];
+
+	buffer[0] = c;
+	buffer[1] = '\0';
+	gagt_styled_string(style, buffer);
+}
+
+static void gagt_standout_string(const char *message) {
+	gagt_styled_string(style_Emphasized, message);
+}
+
+static void gagt_standout_char(char c) {
+	gagt_styled_char(style_Emphasized, c);
+}
+
+static void gagt_normal_string(const char *message) {
+	gagt_styled_string(style_Normal, message);
+}
+
+static void gagt_normal_char(char c) {
+	gagt_styled_char(style_Normal, c);
+}
+
+static void gagt_header_string(const char *message) {
+	gagt_styled_string(style_Header, message);
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port delay functions                                           */
+/*---------------------------------------------------------------------*/
+
+/* Number of milliseconds in a second (traditionally, 1000). */
+static const int GAGT_MS_PER_SEC = 1000;
+
+/*
+ * Number of milliseconds to timeout.  Because of jitter in the way Glk
+ * generates timeouts, it's worthwhile implementing a delay using a number
+ * of shorter timeouts.  This minimizes inaccuracies in the actual delay.
+ */
+static const glui32 GAGT_DELAY_TIMEOUT = 50;
+
+/* The character key that can be pressed to cancel, and suspend, delays. */
+static const char GAGT_DELAY_SUSPEND = ' ';
+
+/*
+ * Flag to temporarily turn off all delays.  This is set when the user
+ * cancels a delay with a keypress, and remains set until the next time
+ * that AGiliTy requests user input.  This way, games that call agt_delay()
+ * sequentially don't require multiple keypresses to jump out of delay
+ * sections.
+ */
+static int gagt_delays_suspended = FALSE;
+
+
+/*
+ * agt_delay()
+ *
+ * Delay for the specified number of seconds.  The delay can be canceled
+ * by a user keypress.
+ */
+void agt_delay(int seconds) {
+	glui32 milliseconds, delayed;
+	int delay_completed;
+
+	/* Suppress delay if in fast replay or batch mode. */
+	if (fast_replay || BATCH_MODE)
+		return;
+
+	/*
+	 * Do nothing if Glk doesn't have timers, if the delay state is set to
+	 * ignore delays, if a zero or negative delay was specified, or if delays
+	 * are currently temporarily suspended.
+	 */
+	if (!g_vm->glk_gestalt(gestalt_Timer, 0)
+	        || gagt_delay_mode == DELAY_OFF
+	        || seconds <= 0 || gagt_delays_suspended)
+		return;
+
+	/* Flush any pending buffered output, and refresh status to show waiting. */
+	gagt_output_flush();
+	gagt_status_in_delay(TRUE);
+
+	/* Calculate the number of milliseconds to delay. */
+	milliseconds = (seconds * GAGT_MS_PER_SEC)
+	               / (gagt_delay_mode == DELAY_SHORT ? 2 : 1);
+
+	/* Request timer events, and let a keypress cancel the delay. */
+	g_vm->glk_request_char_event(gagt_main_window);
+	g_vm->glk_request_timer_events(GAGT_DELAY_TIMEOUT);
+
+	/*
+	 * Implement the delay using a sequence of shorter Glk timeouts, with an
+	 * option to cancel the delay with a keypress.
+	 */
+	delay_completed = TRUE;
+	for (delayed = 0; delayed < milliseconds; delayed += GAGT_DELAY_TIMEOUT) {
+		event_t event;
+
+		/* Wait for the next timeout, or a character. */
+		gagt_event_wait_2(evtype_CharInput, evtype_Timer, &event);
+		if (event.type == evtype_CharInput) {
+			/*
+			 * If suspend requested, stop the delay, and set the delay
+			 * suspension flag, and a note that the delay loop didn't complete.
+			 * Otherwise, reissue the character input request.
+			 */
+			if (event.val1 == GAGT_DELAY_SUSPEND) {
+				gagt_delays_suspended = TRUE;
+				delay_completed = FALSE;
+				break;
+			} else
+				g_vm->glk_request_char_event(gagt_main_window);
+		}
+	}
+
+	/* Cancel any pending character input, and timer events. */
+	if (delay_completed)
+		g_vm->glk_cancel_char_event(gagt_main_window);
+	g_vm->glk_request_timer_events(0);
+
+	/* Clear the waiting indicator. */
+	gagt_status_in_delay(FALSE);
+
+	gagt_debug("agt_delay", "seconds=%d [%lu mS] -> %s", seconds, milliseconds,
+	           delay_completed ? "completed" : "canceled");
+}
+
+
+/*
+ * gagt_delay_resume()
+ *
+ * Unsuspend delays.  This function should be called by agt_input() and
+ * agt_getkey(), to re-enable delays when the interpreter next requests
+ * user input.
+ */
+static void gagt_delay_resume() {
+	gagt_delays_suspended = FALSE;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port box drawing functions                                     */
+/*---------------------------------------------------------------------*/
+
+/* Saved details of any current box dimensions and flags. */
+static unsigned long gagt_box_flags = 0;
+static int gagt_box_busy = FALSE,
+           gagt_box_width = 0,
+           gagt_box_height = 0,
+           gagt_box_startx = 0;
+
+
+/*
+ * gagt_box_rule()
+ * gagt_box_position()
+ *
+ * Draw a line at the top or bottom of a box, and position the cursor
+ * with a box indent.
+ */
+static void gagt_box_rule(int width) {
+	char *ruler;
+
+	/* Write a +--...--+ ruler to delimit a box. */
+	ruler = (char *)gagt_malloc(width + 2 + 1);
+	memset(ruler + 1, '-', width);
+	ruler[0] = ruler[width + 1] = '+';
+	ruler[width + 2] = '\0';
+	agt_puts(ruler);
+	free(ruler);
+}
+
+static void gagt_box_position(int indent) {
+	char *spaces;
+
+	/* Write a newline before the indent. */
+	agt_newline();
+
+	/* Write the indent to the start of box text. */
+	spaces = (char *)gagt_malloc(indent + 1);
+	memset(spaces, ' ', indent);
+	spaces[indent] = '\0';
+	agt_puts(spaces);
+	free(spaces);
+}
+
+
+/*
+ * agt_makebox()
+ * agt_qnewline()
+ * agt_endbox()
+ *
+ * Start a box of given width, height, and with given flags.  Write a new
+ * line in the box.  And end the box.
+ */
+void agt_makebox(int width, int height, unsigned long flags) {
+	assert(!gagt_box_busy);
+
+	gagt_box_busy = TRUE;
+	gagt_box_flags = flags;
+	gagt_box_width = width;
+	gagt_box_height = height;
+
+	/* If no centering requested, set the indent to zero. */
+	if (gagt_box_flags & TB_NOCENT)
+		gagt_box_startx = 0;
+	else {
+		int centering_width;
+
+		/*
+		 * Calculate the indent for centering, adding 4 characters for borders.
+		 * Here, since screen_width is artificial, we'll center off status_width
+		 * if it is less than screen width, otherwise we'll center by using
+		 * screen_width.  The reason for shrinking to screen_width is that if
+		 * we don't, we could drive curr_x to beyond screen_width with our box
+		 * indentations, and that confuses AGiliTy.
+		 */
+		if (status_width < screen_width)
+			centering_width = status_width;
+		else
+			centering_width = screen_width;
+		if (gagt_box_flags & TB_BORDER)
+			gagt_box_startx = (centering_width - gagt_box_width - 4) / 2;
+		else
+			gagt_box_startx = (centering_width - gagt_box_width) / 2;
+
+		/* If the box turns out wider than the window, abandon centering. */
+		if (gagt_box_startx < 0)
+			gagt_box_startx = 0;
+	}
+
+	/*
+	 * When in a box, we'll coerce fixed width font by setting it in the AGT
+	 * font attributes.  This ensures that the box displays as accurately as
+	 * we're able to achieve.
+	 */
+	gagt_coerce_fixed_font(TRUE);
+
+	/* Position the cursor for the box, and if bordered, write the rule. */
+	gagt_box_position(gagt_box_startx);
+	if (gagt_box_flags & TB_BORDER) {
+		gagt_box_rule(gagt_box_width + 2);
+		gagt_box_position(gagt_box_startx);
+		agt_puts("| ");
+	}
+
+	gagt_debug("agt_makebox", "width=%d, height=%d, flags=0x%lx",
+	           width, height, flags);
+}
+
+void agt_qnewline() {
+	assert(gagt_box_busy);
+
+	/* Write box characters for the current and next line. */
+	if (gagt_box_flags & TB_BORDER) {
+		agt_puts(" |");
+		gagt_box_position(gagt_box_startx);
+		agt_puts("| ");
+	} else
+		gagt_box_position(gagt_box_startx);
+
+	gagt_debug("agt_qnewline", "");
+}
+
+void agt_endbox() {
+	assert(gagt_box_busy);
+
+	/* Finish off the current box. */
+	if (gagt_box_flags & TB_BORDER) {
+		agt_puts(" |");
+		gagt_box_position(gagt_box_startx);
+		gagt_box_rule(gagt_box_width + 2);
+	}
+	agt_newline();
+
+	/* An extra newline here improves the appearance. */
+	agt_newline();
+
+	/* Back to allowing proportional font output again. */
+	gagt_coerce_fixed_font(FALSE);
+
+	gagt_box_busy = FALSE;
+	gagt_box_flags = gagt_box_width = gagt_box_startx = 0;
+
+	gagt_debug("agt_endbox", "");
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk command escape functions                                       */
+/*---------------------------------------------------------------------*/
+
+/*
+ * gagt_command_script()
+ *
+ * Turn game output scripting (logging) on and off.
+ */
+static void gagt_command_script(const char *argument) {
+	assert(argument);
+
+	if (gagt_strcasecmp(argument, "on") == 0) {
+		frefid_t fileref;
+
+		if (gagt_transcript_stream) {
+			gagt_normal_string("Glk transcript is already on.\n");
+			return;
+		}
+
+		fileref = g_vm->glk_fileref_create_by_prompt(fileusage_Transcript
+		          | fileusage_TextMode,
+		          filemode_WriteAppend, 0);
+		if (!fileref) {
+			gagt_standout_string("Glk transcript failed.\n");
+			return;
+		}
+
+		gagt_transcript_stream = g_vm->glk_stream_open_file(fileref,
+		                         filemode_WriteAppend, 0);
+		g_vm->glk_fileref_destroy(fileref);
+		if (!gagt_transcript_stream) {
+			gagt_standout_string("Glk transcript failed.\n");
+			return;
+		}
+
+		g_vm->glk_window_set_echo_stream(gagt_main_window, gagt_transcript_stream);
+
+		gagt_normal_string("Glk transcript is now on.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "off") == 0) {
+		if (!gagt_transcript_stream) {
+			gagt_normal_string("Glk transcript is already off.\n");
+			return;
+		}
+
+		g_vm->glk_stream_close(gagt_transcript_stream, NULL);
+		gagt_transcript_stream = NULL;
+
+		g_vm->glk_window_set_echo_stream(gagt_main_window, NULL);
+
+		gagt_normal_string("Glk transcript is now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gagt_normal_string("Glk transcript is ");
+		gagt_normal_string(gagt_transcript_stream ? "on" : "off");
+		gagt_normal_string(".\n");
+	}
+
+	else {
+		gagt_normal_string("Glk transcript can be ");
+		gagt_standout_string("on");
+		gagt_normal_string(", or ");
+		gagt_standout_string("off");
+		gagt_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gagt_command_inputlog()
+ *
+ * Turn game input logging on and off.
+ */
+static void gagt_command_inputlog(const char *argument) {
+	assert(argument);
+
+	if (gagt_strcasecmp(argument, "on") == 0) {
+		frefid_t fileref;
+
+		if (gagt_inputlog_stream) {
+			gagt_normal_string("Glk input logging is already on.\n");
+			return;
+		}
+
+		fileref = g_vm->glk_fileref_create_by_prompt(fileusage_InputRecord
+		          | fileusage_BinaryMode,
+		          filemode_WriteAppend, 0);
+		if (!fileref) {
+			gagt_standout_string("Glk input logging failed.\n");
+			return;
+		}
+
+		gagt_inputlog_stream = g_vm->glk_stream_open_file(fileref,
+		                       filemode_WriteAppend, 0);
+		g_vm->glk_fileref_destroy(fileref);
+		if (!gagt_inputlog_stream) {
+			gagt_standout_string("Glk input logging failed.\n");
+			return;
+		}
+
+		gagt_normal_string("Glk input logging is now on.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "off") == 0) {
+		if (!gagt_inputlog_stream) {
+			gagt_normal_string("Glk input logging is already off.\n");
+			return;
+		}
+
+		g_vm->glk_stream_close(gagt_inputlog_stream, NULL);
+		gagt_inputlog_stream = NULL;
+
+		gagt_normal_string("Glk input log is now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gagt_normal_string("Glk input logging is ");
+		gagt_normal_string(gagt_inputlog_stream ? "on" : "off");
+		gagt_normal_string(".\n");
+	}
+
+	else {
+		gagt_normal_string("Glk input logging can be ");
+		gagt_standout_string("on");
+		gagt_normal_string(", or ");
+		gagt_standout_string("off");
+		gagt_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gagt_command_readlog()
+ *
+ * Set the game input log, to read input from a file.
+ */
+static void gagt_command_readlog(const char *argument) {
+	assert(argument);
+
+	if (gagt_strcasecmp(argument, "on") == 0) {
+		frefid_t fileref;
+
+		if (gagt_readlog_stream) {
+			gagt_normal_string("Glk read log is already on.\n");
+			return;
+		}
+
+		fileref = g_vm->glk_fileref_create_by_prompt(fileusage_InputRecord
+		          | fileusage_BinaryMode,
+		          filemode_Read, 0);
+		if (!fileref) {
+			gagt_standout_string("Glk read log failed.\n");
+			return;
+		}
+
+		if (!g_vm->glk_fileref_does_file_exist(fileref)) {
+			g_vm->glk_fileref_destroy(fileref);
+			gagt_standout_string("Glk read log failed.\n");
+			return;
+		}
+
+		gagt_readlog_stream = g_vm->glk_stream_open_file(fileref, filemode_Read, 0);
+		g_vm->glk_fileref_destroy(fileref);
+		if (!gagt_readlog_stream) {
+			gagt_standout_string("Glk read log failed.\n");
+			return;
+		}
+
+		gagt_normal_string("Glk read log is now on.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "off") == 0) {
+		if (!gagt_readlog_stream) {
+			gagt_normal_string("Glk read log is already off.\n");
+			return;
+		}
+
+		g_vm->glk_stream_close(gagt_readlog_stream, NULL);
+		gagt_readlog_stream = NULL;
+
+		gagt_normal_string("Glk read log is now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gagt_normal_string("Glk read log is ");
+		gagt_normal_string(gagt_readlog_stream ? "on" : "off");
+		gagt_normal_string(".\n");
+	}
+
+	else {
+		gagt_normal_string("Glk read log can be ");
+		gagt_standout_string("on");
+		gagt_normal_string(", or ");
+		gagt_standout_string("off");
+		gagt_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gagt_command_abbreviations()
+ *
+ * Turn abbreviation expansions on and off.
+ */
+static void gagt_command_abbreviations(const char *argument) {
+	assert(argument);
+
+	if (gagt_strcasecmp(argument, "on") == 0) {
+		if (gagt_abbreviations_enabled) {
+			gagt_normal_string("Glk abbreviation expansions are already on.\n");
+			return;
+		}
+
+		gagt_abbreviations_enabled = TRUE;
+		gagt_normal_string("Glk abbreviation expansions are now on.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "off") == 0) {
+		if (!gagt_abbreviations_enabled) {
+			gagt_normal_string("Glk abbreviation expansions are already off.\n");
+			return;
+		}
+
+		gagt_abbreviations_enabled = FALSE;
+		gagt_normal_string("Glk abbreviation expansions are now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gagt_normal_string("Glk abbreviation expansions are ");
+		gagt_normal_string(gagt_abbreviations_enabled ? "on" : "off");
+		gagt_normal_string(".\n");
+	}
+
+	else {
+		gagt_normal_string("Glk abbreviation expansions can be ");
+		gagt_standout_string("on");
+		gagt_normal_string(", or ");
+		gagt_standout_string("off");
+		gagt_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gagt_command_fonts()
+ *
+ * Set the value for gagt_font_mode depending on the argument from the
+ * user's command escape.
+ *
+ * Despite our best efforts, font control may still be wrong in some games.
+ * This command gives us a chance to correct that.
+ */
+static void gagt_command_fonts(const char *argument) {
+	assert(argument);
+
+	if (gagt_strcasecmp(argument, "fixed") == 0) {
+		if (gagt_font_mode == FONT_FIXED_WIDTH) {
+			gagt_normal_string("Glk font control is already 'fixed'.\n");
+			return;
+		}
+
+		gagt_font_mode = FONT_FIXED_WIDTH;
+		gagt_normal_string("Glk font control is now 'fixed'.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "variable") == 0
+	         || gagt_strcasecmp(argument, "proportional") == 0) {
+		if (gagt_font_mode == FONT_PROPORTIONAL) {
+			gagt_normal_string("Glk font control is already 'proportional'.\n");
+			return;
+		}
+
+		gagt_font_mode = FONT_PROPORTIONAL;
+		gagt_normal_string("Glk font control is now 'proportional'.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "auto") == 0
+	         || gagt_strcasecmp(argument, "automatic") == 0) {
+		if (gagt_font_mode == FONT_AUTOMATIC) {
+			gagt_normal_string("Glk font control is already 'automatic'.\n");
+			return;
+		}
+
+		gagt_font_mode = FONT_AUTOMATIC;
+		gagt_normal_string("Glk font control is now 'automatic'.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "debug") == 0) {
+		if (gagt_font_mode == FONT_DEBUG) {
+			gagt_normal_string("Glk font control is already 'debug'.\n");
+			return;
+		}
+
+		gagt_font_mode = FONT_DEBUG;
+		gagt_normal_string("Glk font control is now 'debug'.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gagt_normal_string("Glk font control is set to '");
+		switch (gagt_font_mode) {
+		case FONT_AUTOMATIC:
+			gagt_normal_string("automatic");
+			break;
+
+		case FONT_FIXED_WIDTH:
+			gagt_normal_string("fixed");
+			break;
+
+		case FONT_PROPORTIONAL:
+			gagt_normal_string("proportional");
+			break;
+
+		case FONT_DEBUG:
+			gagt_normal_string("debug");
+			break;
+
+		default:
+			gagt_fatal("GLK: Invalid font mode encountered");
+			gagt_exit();
+		}
+		gagt_normal_string("'.\n");
+	}
+
+	else {
+		/* Avoid mentioning the debug setting. */
+		gagt_normal_string("Glk font control can be ");
+		gagt_standout_string("fixed");
+		gagt_normal_string(", ");
+		gagt_standout_string("proportional");
+		gagt_normal_string(", or ");
+		gagt_standout_string("automatic");
+		gagt_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gagt_command_delays()
+ *
+ * Set a value for gagt_delay_mode depending on the argument from
+ * the user's command escape.
+ */
+static void gagt_command_delays(const char *argument) {
+	assert(argument);
+
+	if (!g_vm->glk_gestalt(gestalt_Timer, 0)) {
+		gagt_normal_string("Glk delays are not available.\n");
+		return;
+	}
+
+	if (gagt_strcasecmp(argument, "full") == 0
+	        || gagt_strcasecmp(argument, "on") == 0) {
+		if (gagt_delay_mode == DELAY_FULL) {
+			gagt_normal_string("Glk delay mode is already 'full'.\n");
+			return;
+		}
+
+		gagt_delay_mode = DELAY_FULL;
+		gagt_normal_string("Glk delay mode is now 'full'.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "short") == 0
+	         || gagt_strcasecmp(argument, "half") == 0) {
+		if (gagt_delay_mode == DELAY_SHORT) {
+			gagt_normal_string("Glk delay mode is already 'short'.\n");
+			return;
+		}
+
+		gagt_delay_mode = DELAY_SHORT;
+		gagt_normal_string("Glk delay mode is now 'short'.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "none") == 0
+	         || gagt_strcasecmp(argument, "off") == 0) {
+		if (gagt_delay_mode == DELAY_OFF) {
+			gagt_normal_string("Glk delay mode is already 'none'.\n");
+			return;
+		}
+
+		gagt_delay_mode = DELAY_OFF;
+		gagt_normal_string("Glk delay mode is now 'none'.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gagt_normal_string("Glk delay mode is set to '");
+		switch (gagt_delay_mode) {
+		case DELAY_FULL:
+			gagt_normal_string("full");
+			break;
+
+		case DELAY_SHORT:
+			gagt_normal_string("short");
+			break;
+
+		case DELAY_OFF:
+			gagt_normal_string("none");
+			break;
+
+		default:
+			gagt_fatal("GLK: Invalid delay mode encountered");
+			gagt_exit();
+		}
+		gagt_normal_string("'.\n");
+	}
+
+	else {
+		gagt_normal_string("Glk delay mode can be ");
+		gagt_standout_string("full");
+		gagt_normal_string(", ");
+		gagt_standout_string("short");
+		gagt_normal_string(", or ");
+		gagt_standout_string("none");
+		gagt_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gagt_command_width()
+ *
+ * Print out the (approximate) display width, from status_width.  It's
+ * approximate because the main window might include a scrollbar that
+ * the status window doesn't have, may use a different size font, and so
+ * on.  But the main window won't tell us a width at all - it always
+ * returns zero.  If we don't happen to have a status window available
+ * to us, there's not much we can say.
+ *
+ * Note that this function uses the interpreter variable status_width,
+ * so it's important to keep this updated with the current window size at
+ * all times.
+ */
+static void gagt_command_width(const char *argument) {
+	char buffer[16];
+	assert(argument);
+
+	if (!gagt_status_window) {
+		gagt_normal_string("Glk's current display width is unknown.\n");
+		return;
+	}
+
+	gagt_normal_string("Glk's current display width is approximately ");
+	sprintf(buffer, "%d", status_width);
+	gagt_normal_string(buffer);
+	gagt_normal_string(status_width == 1 ? " character" : " characters");
+	gagt_normal_string(".\n");
+}
+
+
+/*
+ * gagt_command_replacements()
+ *
+ * Turn Glk special paragraph replacement on and off.
+ */
+static void gagt_command_replacements(const char *argument) {
+	assert(argument);
+
+	if (gagt_strcasecmp(argument, "on") == 0) {
+		if (gagt_replacement_enabled) {
+			gagt_normal_string("Glk replacements are already on.\n");
+			return;
+		}
+
+		gagt_replacement_enabled = TRUE;
+		gagt_normal_string("Glk replacements are now on.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "off") == 0) {
+		if (!gagt_replacement_enabled) {
+			gagt_normal_string("Glk replacements are already off.\n");
+			return;
+		}
+
+		gagt_replacement_enabled = FALSE;
+		gagt_normal_string("Glk replacements are now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gagt_normal_string("Glk replacements are ");
+		gagt_normal_string(gagt_replacement_enabled ? "on" : "off");
+		gagt_normal_string(".\n");
+	}
+
+	else {
+		gagt_normal_string("Glk replacements can be ");
+		gagt_standout_string("on");
+		gagt_normal_string(", or ");
+		gagt_standout_string("off");
+		gagt_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gagt_command_statusline()
+ *
+ * Turn the extended status line on and off.
+ */
+static void gagt_command_statusline(const char *argument) {
+	assert(argument);
+
+	if (!gagt_status_window) {
+		gagt_normal_string("Glk status window is not available.\n");
+		return;
+	}
+
+	if (gagt_strcasecmp(argument, "extended") == 0
+	        || gagt_strcasecmp(argument, "full") == 0) {
+		if (gagt_extended_status_enabled) {
+			gagt_normal_string("Glk status line mode is already 'extended'.\n");
+			return;
+		}
+
+		/* Expand the status window down to a second line. */
+		g_vm->glk_window_set_arrangement(g_vm->glk_window_get_parent(gagt_status_window),
+		                                 winmethod_Above | winmethod_Fixed, 2, NULL);
+		gagt_extended_status_enabled = TRUE;
+
+		gagt_normal_string("Glk status line mode is now 'extended'.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "short") == 0
+	         || gagt_strcasecmp(argument, "normal") == 0) {
+		if (!gagt_extended_status_enabled) {
+			gagt_normal_string("Glk status line mode is already 'short'.\n");
+			return;
+		}
+
+		/* Shrink the status window down to one line. */
+		g_vm->glk_window_set_arrangement(g_vm->glk_window_get_parent(gagt_status_window),
+		                                 winmethod_Above | winmethod_Fixed, 1, NULL);
+		gagt_extended_status_enabled = FALSE;
+
+		gagt_normal_string("Glk status line mode is now 'short'.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gagt_normal_string("Glk status line mode is set to '");
+		gagt_normal_string(gagt_extended_status_enabled ? "extended" : "short");
+		gagt_normal_string("'.\n");
+	}
+
+	else {
+		gagt_normal_string("Glk status line can be ");
+		gagt_standout_string("extended");
+		gagt_normal_string(", or ");
+		gagt_standout_string("short");
+		gagt_normal_string(".\n");
+	}
+}
+
+
+/*
+ * gagt_command_print_version_number()
+ * gagt_command_version()
+ *
+ * Print out the Glk library version number.
+ */
+static void gagt_command_print_version_number(glui32 version) {
+	char buffer[64];
+
+	sprintf(buffer, "%u.%u.%u",
+	        version >> 16, (version >> 8) & 0xff, version & 0xff);
+	gagt_normal_string(buffer);
+}
+
+static void gagt_command_version(const char *argument) {
+	glui32 version;
+	assert(argument);
+
+	gagt_normal_string("This is version ");
+	gagt_command_print_version_number(GAGT_PORT_VERSION);
+	gagt_normal_string(" of the Glk AGiliTy port.\n");
+
+	version = g_vm->glk_gestalt(gestalt_Version, 0);
+	gagt_normal_string("The Glk library version is ");
+	gagt_command_print_version_number(version);
+	gagt_normal_string(".\n");
+}
+
+
+/*
+ * gagt_command_commands()
+ *
+ * Turn command escapes off.  Once off, there's no way to turn them back on.
+ * Commands must be on already to enter this function.
+ */
+static void gagt_command_commands(const char *argument) {
+	assert(argument);
+
+	if (gagt_strcasecmp(argument, "on") == 0) {
+		gagt_normal_string("Glk commands are already on.\n");
+	}
+
+	else if (gagt_strcasecmp(argument, "off") == 0) {
+		gagt_commands_enabled = FALSE;
+		gagt_normal_string("Glk commands are now off.\n");
+	}
+
+	else if (strlen(argument) == 0) {
+		gagt_normal_string("Glk commands are ");
+		gagt_normal_string(gagt_commands_enabled ? "on" : "off");
+		gagt_normal_string(".\n");
+	}
+
+	else {
+		gagt_normal_string("Glk commands can be ");
+		gagt_standout_string("on");
+		gagt_normal_string(", or ");
+		gagt_standout_string("off");
+		gagt_normal_string(".\n");
+	}
+}
+
+/* Glk subcommands and handler functions. */
+struct gagt_command_t {
+	const char *const command;                      /* Glk subcommand. */
+	void (* const handler)(const char *argument);   /* Subcommand handler. */
+	const int takes_argument;                       /* Argument flag. */
+} ;
+typedef const gagt_command_t *gagt_commandref_t;
+
+static void gagt_command_summary(const char *argument);
+static void gagt_command_help(const char *argument);
+
+static gagt_command_t GAGT_COMMAND_TABLE[] = {
+	{"summary",        gagt_command_summary,        FALSE},
+	{"script",         gagt_command_script,         TRUE},
+	{"inputlog",       gagt_command_inputlog,       TRUE},
+	{"readlog",        gagt_command_readlog,        TRUE},
+	{"abbreviations",  gagt_command_abbreviations,  TRUE},
+	{"fonts",          gagt_command_fonts,          TRUE},
+	{"delays",         gagt_command_delays,         TRUE},
+	{"width",          gagt_command_width,          FALSE},
+	{"replacements",   gagt_command_replacements,   TRUE},
+	{"statusline",     gagt_command_statusline,     TRUE},
+	{"version",        gagt_command_version,        FALSE},
+	{"commands",       gagt_command_commands,       TRUE},
+	{"help",           gagt_command_help,           TRUE},
+	{NULL, NULL, FALSE}
+};
+
+
+/*
+ * gagt_command_summary()
+ *
+ * Report all current Glk settings.
+ */
+static void gagt_command_summary(const char *argument) {
+	gagt_commandref_t entry;
+	assert(argument);
+
+	/*
+	 * Call handlers that have status to report with an empty argument,
+	 * prompting each to print its current setting.
+	 */
+	for (entry = GAGT_COMMAND_TABLE; entry->command; entry++) {
+		if (entry->handler == gagt_command_summary
+		        || entry->handler == gagt_command_help)
+			continue;
+
+		entry->handler("");
+	}
+}
+
+
+/*
+ * gagt_command_help()
+ *
+ * Document the available Glk cmds.
+ */
+static void gagt_command_help(const char *cmd) {
+	gagt_commandref_t entry, matched;
+	assert(cmd);
+
+	if (strlen(cmd) == 0) {
+		gagt_normal_string("Glk cmds are");
+		for (entry = GAGT_COMMAND_TABLE; entry->command; entry++) {
+			gagt_commandref_t next;
+
+			next = entry + 1;
+			gagt_normal_string(next->command ? " " : " and ");
+			gagt_standout_string(entry->command);
+			gagt_normal_string(next->command ? "," : ".\n\n");
+		}
+
+		gagt_normal_string("Glk cmds may be abbreviated, as long as"
+		                   " the abbreviation is unambiguous.  Use ");
+		gagt_standout_string("glk help");
+		gagt_normal_string(" followed by a Glk cmd name for help on that"
+		                   " cmd.\n");
+		return;
+	}
+
+	matched = NULL;
+	for (entry = GAGT_COMMAND_TABLE; entry->command; entry++) {
+		if (gagt_strncasecmp(cmd, entry->command, strlen(cmd)) == 0) {
+			if (matched) {
+				gagt_normal_string("The Glk cmd ");
+				gagt_standout_string(cmd);
+				gagt_normal_string(" is ambiguous.  Try ");
+				gagt_standout_string("glk help");
+				gagt_normal_string(" for more information.\n");
+				return;
+			}
+			matched = entry;
+		}
+	}
+	if (!matched) {
+		gagt_normal_string("The Glk cmd ");
+		gagt_standout_string(cmd);
+		gagt_normal_string(" is not valid.  Try ");
+		gagt_standout_string("glk help");
+		gagt_normal_string(" for more information.\n");
+		return;
+	}
+
+	if (matched->handler == gagt_command_summary) {
+		gagt_normal_string("Prints a summary of all the current Glk AGiliTy"
+		                   " settings.\n");
+	}
+
+	else if (matched->handler == gagt_command_script) {
+		gagt_normal_string("Logs the game's output to a file.\n\nUse ");
+		gagt_standout_string("glk script on");
+		gagt_normal_string(" to begin logging game output, and ");
+		gagt_standout_string("glk script off");
+		gagt_normal_string(" to end it.  Glk AGiliTy will ask you for a file"
+		                   " when you turn scripts on.\n");
+	}
+
+	else if (matched->handler == gagt_command_inputlog) {
+		gagt_normal_string("Records the cmds you type into a game.\n\nUse ");
+		gagt_standout_string("glk inputlog on");
+		gagt_normal_string(", to begin recording your cmds, and ");
+		gagt_standout_string("glk inputlog off");
+		gagt_normal_string(" to turn off input logs.  You can play back"
+		                   " recorded cmds into a game with the ");
+		gagt_standout_string("glk readlog");
+		gagt_normal_string(" cmd.\n");
+	}
+
+	else if (matched->handler == gagt_command_readlog) {
+		gagt_normal_string("Plays back cmds recorded with ");
+		gagt_standout_string("glk inputlog on");
+		gagt_normal_string(".\n\nUse ");
+		gagt_standout_string("glk readlog on");
+		gagt_normal_string(".  cmd play back stops at the end of the"
+		                   " file.  You can also play back cmds from a"
+		                   " text file created using any standard editor.\n");
+	}
+
+	else if (matched->handler == gagt_command_abbreviations) {
+		gagt_normal_string("Controls abbreviation expansion.\n\nGlk AGiliTy"
+		                   " automatically expands several standard single"
+		                   " letter abbreviations for you; for example, \"x\""
+		                   " becomes \"examine\".  Use ");
+		gagt_standout_string("glk abbreviations on");
+		gagt_normal_string(" to turn this feature on, and ");
+		gagt_standout_string("glk abbreviations off");
+		gagt_normal_string(" to turn it off.  While the feature is on, you"
+		                   " can bypass abbreviation expansion for an"
+		                   " individual game cmd by prefixing it with a"
+		                   " single quote.\n");
+	}
+
+	else if (matched->handler == gagt_command_fonts) {
+		gagt_normal_string("Controls the way Glk AGiliTy uses fonts.\n\n"
+		                   "AGT games normally assume 80x25 monospaced font"
+		                   " displays.  Glk can often use proportional fonts."
+		                   "  To try to improve text display, Glk AGiliTy will"
+		                   " attempt to automatically detect when game text"
+		                   " can be displayed safely in a proportional font,"
+		                   " and when fixed width fonts are required.  For"
+		                   " some games, however, you may need to override"
+		                   " it.  Use ");
+		gagt_standout_string("glk fonts automatic");
+		gagt_normal_string(", ");
+		gagt_standout_string("glk fonts proportional");
+		gagt_normal_string(", and ");
+		gagt_standout_string("glk fonts fixed");
+		gagt_normal_string(" to switch between Glk AGiliTy font modes.\n");
+	}
+
+	else if (matched->handler == gagt_command_delays) {
+		gagt_normal_string("Shortens, or eliminates, AGT game delays.\n\nUse ");
+		gagt_standout_string("glk delays full");
+		gagt_normal_string(", ");
+		gagt_standout_string("glk delays short");
+		gagt_normal_string(", or ");
+		gagt_standout_string("glk delays none");
+		gagt_normal_string(".  In Glk AGiliTy, you can also end an AGT game's"
+		                   " delay early, by pressing Space while the game is"
+		                   " delaying.\n");
+	}
+
+	else if (matched->handler == gagt_command_width) {
+		gagt_normal_string("Prints the screen width available for fixed font"
+		                   " display.\n\nEven though Glk AGiliTy tries to handle"
+		                   " issues surrounding proportional font displays for"
+		                   " you automatically, some game elements may still"
+		                   " need to display in fixed width fonts.  These"
+		                   " elements will be happiest if the available screen"
+		                   " width is at least 80 columns.\n");
+	}
+
+	else if (matched->handler == gagt_command_replacements) {
+		gagt_normal_string("Controls game text scanning and replacement.\n\n"
+		                   "Glk AGiliTy can monitor the game's output, and"
+		                   " replace a few selected standard messages with"
+		                   " equivalents, printed using a style that stands"
+		                   " out better in Glk displays.  Use ");
+		gagt_standout_string("glk replacements on");
+		gagt_normal_string(" to turn this feature on, and ");
+		gagt_standout_string("glk replacements off");
+		gagt_normal_string(" to turn it off.\n");
+	}
+
+	else if (matched->handler == gagt_command_statusline) {
+		gagt_normal_string("Controls the Glk AGiliTy status line display.\n\n"
+		                   "Use ");
+		gagt_standout_string("glk statusline extended");
+		gagt_normal_string(" to display a full, two line status display, and ");
+		gagt_standout_string("glk statusline short");
+		gagt_normal_string(" for a single line status display.\n");
+	}
+
+	else if (matched->handler == gagt_command_version) {
+		gagt_normal_string("Prints the version numbers of the Glk library"
+		                   " and the Glk AGiliTy port.\n");
+	}
+
+	else if (matched->handler == gagt_command_commands) {
+		gagt_normal_string("Turn off Glk cmds.\n\nUse ");
+		gagt_standout_string("glk cmds off");
+		gagt_normal_string(" to disable all Glk cmds, including this one."
+		                   "  Once turned off, there is no way to turn Glk"
+		                   " cmds back on while inside the game.\n");
+	}
+
+	else if (matched->handler == gagt_command_help)
+		gagt_command_help("");
+
+	else
+		gagt_normal_string("There is no help available on that Glk cmd."
+		                   "  Sorry.\n");
+}
+
+
+/*
+ * gagt_command_escape()
+ *
+ * This function is handed each input line.  If the line contains a specific
+ * Glk port command, handle it and return TRUE, otherwise return FALSE.
+ */
+static int gagt_command_escape(const char *string) {
+	int posn;
+	char *string_copy, *cmd, *argument;
+	assert(string);
+
+	/*
+	 * Return FALSE if the string doesn't begin with the Glk command escape
+	 * introducer.
+	 */
+	posn = strspn(string, "\t ");
+	if (gagt_strncasecmp(string + posn, "glk", strlen("glk")) != 0)
+		return FALSE;
+
+	/* Take a copy of the string, without any leading space or introducer. */
+	string_copy = (char *)gagt_malloc(strlen(string + posn) + 1 - strlen("glk"));
+	strcpy(string_copy, string + posn + strlen("glk"));
+
+	/*
+	 * Find the subcommand; the first word in the string copy.  Find its end,
+	 * and ensure it terminates with a NUL.
+	 */
+	posn = strspn(string_copy, "\t ");
+	cmd = string_copy + posn;
+	posn += strcspn(string_copy + posn, "\t ");
+	if (string_copy[posn] != '\0')
+		string_copy[posn++] = '\0';
+
+	/*
+	 * Now find any argument data for the command, ensuring it too terminates
+	 * with a NUL.
+	 */
+	posn += strspn(string_copy + posn, "\t ");
+	argument = string_copy + posn;
+	posn += strcspn(string_copy + posn, "\t ");
+	string_copy[posn] = '\0';
+
+	/*
+	 * Try to handle the command and argument as a Glk subcommand.  If it
+	 * doesn't run unambiguously, print command usage.  Treat an empty command
+	 * as "help".
+	 */
+	if (strlen(cmd) > 0) {
+		gagt_commandref_t entry, matched;
+		int matches;
+
+		/*
+		 * Search for the first unambiguous table cmd string matching
+		 * the cmd passed in.
+		 */
+		matches = 0;
+		matched = NULL;
+		for (entry = GAGT_COMMAND_TABLE; entry->command; entry++) {
+			if (gagt_strncasecmp(cmd, entry->command, strlen(cmd)) == 0) {
+				matches++;
+				matched = entry;
+			}
+		}
+
+		/* If the match was unambiguous, call the command handler. */
+		if (matches == 1) {
+			gagt_normal_char('\n');
+			matched->handler(argument);
+
+			if (!matched->takes_argument && strlen(argument) > 0) {
+				gagt_normal_string("[The ");
+				gagt_standout_string(matched->command);
+				gagt_normal_string(" cmd ignores arguments.]\n");
+			}
+		}
+
+		/* No match, or the cmd was ambiguous. */
+		else {
+			gagt_normal_string("\nThe Glk cmd ");
+			gagt_standout_string(cmd);
+			gagt_normal_string(" is ");
+			gagt_normal_string(matches == 0 ? "not valid" : "ambiguous");
+			gagt_normal_string(".  Try ");
+			gagt_standout_string("glk help");
+			gagt_normal_string(" for more information.\n");
+		}
+	} else {
+		gagt_normal_char('\n');
+		gagt_command_help("");
+	}
+
+	/* The string contained a Glk cmd; return TRUE. */
+	free(string_copy);
+	return TRUE;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port input functions                                           */
+/*---------------------------------------------------------------------*/
+
+/* Longest line we're going to buffer for input. */
+enum { GAGT_INPUTBUFFER_LENGTH = 256 };
+
+/* Table of single-character command abbreviations. */
+typedef const struct {
+	const char abbreviation;       /* Abbreviation character. */
+	const char *const expansion;   /* Expansion string. */
+} gagt_abbreviation_t;
+typedef gagt_abbreviation_t *gagt_abbreviationref_t;
+
+static gagt_abbreviation_t GAGT_ABBREVIATIONS[] = {
+	{'c', "close"},    {'g', "again"},  {'i', "inventory"},
+	{'k', "attack"},   {'l', "look"},   {'p', "open"},
+	{'q', "quit"},     {'r', "drop"},   {'t', "take"},
+	{'x', "examine"},  {'y', "yes"},    {'z', "wait"},
+	{'\0', NULL}
+};
+
+
+/*
+ * gagt_expand_abbreviations()
+ *
+ * Expand a few common one-character abbreviations commonly found in other
+ * game systems, but not always normal in AGT games.
+ */
+static void gagt_expand_abbreviations(char *buffer, int size) {
+	char *command_, abbreviation;
+	const char *expansion;
+	gagt_abbreviationref_t entry;
+	assert(buffer);
+
+	/* Ignore anything that isn't a single letter command_. */
+	command_ = buffer + strspn(buffer, "\t ");
+	if (!(strlen(command_) == 1
+	        || (strlen(command_) > 1 && isspace(command_[1]))))
+		return;
+
+	/* Scan the abbreviations table for a match. */
+	abbreviation = g_vm->glk_char_to_lower((unsigned char) command_[0]);
+	expansion = NULL;
+	for (entry = GAGT_ABBREVIATIONS; entry->expansion; entry++) {
+		if (entry->abbreviation == abbreviation) {
+			expansion = entry->expansion;
+			break;
+		}
+	}
+
+	/*
+	 * If a match found, check for a fit, then replace the character with the
+	 * expansion string.
+	 */
+	if (expansion) {
+		if ((int)strlen(buffer) + (int)strlen(expansion) - 1 >= size)
+			return;
+
+		memmove(command_ + strlen(expansion) - 1, command_, strlen(command_) + 1);
+		memcpy(command_, expansion, strlen(expansion));
+
+		gagt_standout_string("[");
+		gagt_standout_char(abbreviation);
+		gagt_standout_string(" -> ");
+		gagt_standout_string(expansion);
+		gagt_standout_string("]\n");
+	}
+}
+
+
+/*
+ * agt_input()
+ *
+ * Read a line from the keyboard, allocating space for it using malloc.
+ * AGiliTy defines the following for the in_type argument:
+ *
+ *   in_type: 0=command, 1=number, 2=question, 3=userstr, 4=filename,
+ *               5=RESTART,RESTORE,UNDO,QUIT
+ *   Negative values are for internal use by the interface (i.e. this module)
+ *   and so are free to be defined by the porter.
+ *
+ * Since it's unclear what use we can make of this information in Glk,
+ * for the moment the argument is ignored.  It seems that no-one else
+ * uses it, either.
+ */
+char *agt_input(int in_type) {
+	event_t event;
+	int length;
+	char *buffer;
+
+	/*
+	 * Update the current status line display, and flush any pending buffered
+	 * output.  Release any suspension of delays.
+	 */
+	gagt_status_notify();
+	gagt_output_flush();
+	gagt_delay_resume();
+
+	/* Reset current x, as line input implies a newline. */
+	curr_x = 0;
+
+	/* Allocate a line input buffer, allowing 256 characters and a NUL. */
+	length = GAGT_INPUTBUFFER_LENGTH + 1;
+	buffer = (char *)gagt_malloc(length);
+
+	/*
+	 * If we have an input log to read from, use that until it is exhausted.
+	 * On end of file, close the stream and resume input from line requests.
+	 */
+	if (gagt_readlog_stream) {
+		glui32 chars;
+
+		/* Get the next line from the log stream. */
+		chars = g_vm->glk_get_line_stream(gagt_readlog_stream, buffer, length);
+		if (chars > 0) {
+			/* Echo the line just read in input style. */
+			g_vm->glk_set_style(style_Input);
+			g_vm->glk_put_buffer(buffer, chars);
+			g_vm->glk_set_style(style_Normal);
+
+			/*
+			 * Convert the string from Glk's ISO 8859 Latin-1 to IBM cp 437,
+			 * add to any script, and return it.
+			 */
+			gagt_iso_to_cp((const uchar *)buffer, (uchar *)buffer);
+			if (script_on)
+				textputs(scriptfile, buffer);
+			return buffer;
+		}
+
+		/*
+		 * We're at the end of the log stream.  Close it, and then continue
+		 * on to request a line from Glk.
+		 */
+		g_vm->glk_stream_close(gagt_readlog_stream, NULL);
+		gagt_readlog_stream = NULL;
+	}
+
+	/* Set this up as a read buffer for the main window, and wait. */
+	g_vm->glk_request_line_event(gagt_main_window, buffer, length - 1, 0);
+	gagt_event_wait(evtype_LineInput, &event);
+
+	/* Terminate the input line with a NUL. */
+	assert((int)event.val1 < length);
+	buffer[event.val1] = '\0';
+
+	/*
+	 * If neither abbreviations nor local commands are enabled, use the data
+	 * read above without further massaging.
+	 */
+	if (gagt_abbreviations_enabled || gagt_commands_enabled) {
+		char *cmd;
+
+		/*
+		 * If the first non-space input character is a quote, bypass all
+		 * abbreviation expansion and local command recognition, and use the
+		 * unadulterated input, less introductory quote.
+		 */
+		cmd = buffer + strspn(buffer, "\t ");
+		if (cmd[0] == '\'') {
+			/* Delete the quote with memmove(). */
+			memmove(cmd, cmd + 1, strlen(cmd));
+		} else {
+			/* Check for, and expand, any abbreviated commands. */
+			if (gagt_abbreviations_enabled)
+				gagt_expand_abbreviations(buffer, length);
+
+			/*
+			 * Check for standalone "help", then for Glk port special commands;
+			 * suppress the interpreter's use of this input for Glk commands.
+			 */
+			if (gagt_commands_enabled) {
+				int posn;
+
+				posn = strspn(buffer, "\t ");
+				if (gagt_strncasecmp(buffer + posn, "help", strlen("help")) == 0) {
+					if (strspn(buffer + posn + strlen("help"), "\t ")
+					        == strlen(buffer + posn + strlen("help"))) {
+						gagt_display_register_help_request();
+					}
+				}
+
+				if (gagt_command_escape(buffer)) {
+					gagt_display_silence_help_hints();
+					buffer[0] = '\0';
+					return buffer;
+				}
+			}
+		}
+	}
+
+	/*
+	 * If there is an input log active, log this input string to it.  Note that
+	 * by logging here we get any abbreviation expansions but we won't log glk
+	 * special commands, nor any input read from a current open input log.
+	 */
+	if (gagt_inputlog_stream) {
+		g_vm->glk_put_string_stream(gagt_inputlog_stream, buffer);
+		g_vm->glk_put_char_stream(gagt_inputlog_stream, '\n');
+	}
+
+	/*
+	 * Convert from Glk's ISO 8859 Latin-1 to IBM cp 437, and add to any script.
+	 */
+	gagt_iso_to_cp((const uchar *)buffer, (uchar *)buffer);
+	if (script_on)
+		textputs(scriptfile, buffer);
+
+	gagt_debug("agt_input", "in_type=%d -> '%s'", in_type, buffer);
+	return buffer;
+}
+
+
+/*
+ * agt_getkey()
+ *
+ * Read a single character and return it.  AGiliTy defines the echo_char
+ * argument as:
+ *
+ *   If echo_char=1, echo character. If 0, then the character is not
+ *   required to be echoed (and ideally shouldn't be).
+ *
+ * However, I've found that not all other ports really do this, and in
+ * practice it doesn't always look right.  So for Glk, the character is
+ * always echoed to the main window.
+ */
+char agt_getkey(rbool echo_char) {
+	event_t event;
+	char buffer[3];
+	assert(g_vm->glk_stream_get_current());
+
+	/*
+	 * Update the current status line display, and flush any pending buffered
+	 * output.  Release any suspension of delays.
+	 */
+	gagt_status_notify();
+	gagt_output_flush();
+	gagt_delay_resume();
+
+	/* Reset current x, as echoed character input implies a newline. */
+	curr_x = 0;
+
+	/*
+	 * If we have an input log to read from, use that as above until it is
+	 * exhausted.  We take just the first character of a given line.
+	 */
+	if (gagt_readlog_stream) {
+		glui32 chars;
+		char logbuffer[GAGT_INPUTBUFFER_LENGTH + 1];
+
+		/* Get the next line from the log stream. */
+		chars = g_vm->glk_get_line_stream(gagt_readlog_stream,
+		                                  logbuffer, sizeof(logbuffer));
+		if (chars > 0) {
+			/* Take just the first character, adding a newline if necessary. */
+			buffer[0] = logbuffer[0];
+			buffer[1] = buffer[0] == '\n' ? '\0' : '\n';
+			buffer[2] = '\0';
+
+			/* Echo the character just read in input style. */
+			g_vm->glk_set_style(style_Input);
+			g_vm->glk_put_string(buffer);
+			g_vm->glk_set_style(style_Normal);
+
+			/*
+			 * Convert from Glk's ISO 8859 Latin-1 to IBM cp 437, add to any
+			 * script, and return the character.
+			 */
+			gagt_iso_to_cp((const uchar *)buffer, (uchar *)buffer);
+			if (script_on)
+				textputs(scriptfile, buffer);
+			return buffer[0];
+		}
+
+		/*
+		 * We're at the end of the log stream.  Close it, and then continue
+		 * on to request a character from Glk.
+		 */
+		g_vm->glk_stream_close(gagt_readlog_stream, NULL);
+		gagt_readlog_stream = NULL;
+	}
+
+	/*
+	 * Request a single character from main window, and wait.  Ignore non-
+	 * ASCII codes that Glk returns for special function keys; we just want
+	 * one ASCII return value.  (Glk does treat Return as a special key,
+	 * though, and we want to pass that back as ASCII return.)
+	 */
+	do {
+		g_vm->glk_request_char_event(gagt_main_window);
+		gagt_event_wait(evtype_CharInput, &event);
+	} while (event.val1 > BYTE_MAX_VAL && event.val1 != keycode_Return);
+
+	/*
+	 * Save the character into a short string buffer, converting Return
+	 * to newline, and adding a newline if not Return.
+	 */
+	buffer[0] = event.val1 == keycode_Return ? '\n' : event.val1;
+	buffer[1] = buffer[0] == '\n' ? '\0' : '\n';
+	buffer[2] = '\0';
+
+	/* If there is an input log active, log this input string to it. */
+	if (gagt_inputlog_stream)
+		g_vm->glk_put_string_stream(gagt_inputlog_stream, buffer);
+
+	/*
+	 * No matter what echo_char says, as it happens, the output doesn't look
+	 * great if we don't write out the character, and also a newline (c.f.
+	 * the "Yes/No" confirmation of the QUIT command)...
+	 */
+	g_vm->glk_set_style(style_Input);
+	g_vm->glk_put_string(buffer);
+	g_vm->glk_set_style(style_Normal);
+
+	/*
+	 * Convert from Glk's ISO 8859 Latin-1 to IBM cp 437, and add to any
+	 * script.
+	 */
+	gagt_iso_to_cp((const uchar *)buffer, (uchar *)buffer);
+	if (script_on)
+		textputs(scriptfile, buffer);
+
+	gagt_debug("agt_getkey", "echo_char=%d -> '%c'",
+	           echo_char, buffer[0] == '\n' ? '$' : buffer[0]);
+	return buffer[0];
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk port event functions                                           */
+/*---------------------------------------------------------------------*/
+
+/*
+ * We have some clever atexit() finalizer handling for exit() calls that
+ * come from the core interpreter.  However, an exit() call could also come
+ * from Glk; Xkill for example.  To tell the difference, we'll have the
+ * event wait functions set a flag to indicate when g_vm->glk_select() is active.
+ */
+static int gagt_in_glk_select = FALSE;
+
+/*
+ * gagt_event_wait_2()
+ * gagt_event_wait()
+ *
+ * Process Glk events until one of the expected type, or types, arrives.
+ * Return the event of that type.
+ */
+static void gagt_event_wait_2(glui32 wait_type_1, glui32 wait_type_2, event_t *event) {
+	assert(event);
+
+	do {
+		gagt_in_glk_select = TRUE;
+		g_vm->glk_select(event);
+		gagt_in_glk_select = FALSE;
+
+		switch (event->type) {
+		case evtype_Arrange:
+		case evtype_Redraw:
+			gagt_status_redraw();
+			break;
+		default:
+			break;
+		}
+	} while (!(event->type == (EvType)wait_type_1 || event->type == (EvType)wait_type_2));
+}
+
+static void gagt_event_wait(glui32 wait_type, event_t *event) {
+	assert(event);
+	gagt_event_wait_2(wait_type, evtype_None, event);
+}
+
+
+/*
+ * gagt_event_in_glk_select()
+ *
+ * Return TRUE if we're currently awaiting an event in g_vm->glk_select().  Used
+ * by the finalizer to distinguish interpreter and glk exit() calls.
+ */
+static int gagt_event_in_glk_select() {
+	return gagt_in_glk_select;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Miscellaneous Glk port startup and options functions               */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Default screen height and width, and also a default status width for
+ * use with Glk libraries that don't support separate windows.
+ */
+static const int GAGT_DEFAULT_SCREEN_WIDTH = 80,
+                 GAGT_DEFAULT_SCREEN_HEIGHT = 25,
+                 GAGT_DEFAULT_STATUS_WIDTH = 76;
+
+
+/*
+ * agt_option()
+ *
+ * Platform-specific setup and options handling.  AGiliTy defines the
+ * arguments and options as:
+ *
+ *   If setflag is 0, then the option was prefixed with NO_. Return 1 if
+ *   the option is recognized.
+ *
+ * The Glk port has no options file handling, so none of this is
+ * implemented here.
+ */
+rbool agt_option(int optnum, char *optstr[], rbool setflag) {
+	gagt_debug("agt_option", "optnum=%d, optstr=%s, setflag=%d",
+	           optnum, optstr[0], setflag);
+	return 0;
+}
+
+
+/*
+ * agt_globalfile()
+ *
+ * Global options file handle handling.  For now, this is a stub, since
+ * there is no .agilrc for this port.
+ */
+genfile agt_globalfile(int fid) {
+	gagt_debug("agt_globalfile", "fid=%d", fid);
+	return badfile(fCFG);
+}
+
+
+/*
+ * init_interface()
+ *
+ * General initialization for the module; sets some variables, and creates
+ * the Glk windows to work in.  Called from the AGiliTy main().
+ */
+void init_interface(int argc, char *argv[]) {
+	glui32 status_height;
+
+	/*
+	 * Begin with some default values for global variables that this module
+	 * is somehow responsible for.
+	 */
+	script_on = center_on = par_fill_on = FALSE;
+	scriptfile = badfile(fSCR);
+	debugfile = nullptr; // stderr;
+
+	/*
+	 * Set up AGT-specific Glk styles.  This needs to be done before any Glk
+	 * window is opened.
+	 */
+	gagt_init_user_styles();
+
+	/*
+	 * Create the main game window.  The main game window creation must succeed.
+	 * If it fails, we'll return, and the caller can detect this by looking
+	 * for a NULL main window.
+	 */
+	gagt_main_window = g_vm->glk_window_open(0, 0, 0, wintype_TextBuffer, 0);
+	if (!gagt_main_window)
+		return;
+
+	/*
+	 * Set the main window to be the default window, for convenience.  We do
+	 * this again in glk_main() -- this call is here just in case this version
+	 * of init_interface() is ever called by AGiliTy's main.
+	 */
+	g_vm->glk_set_window(gagt_main_window);
+
+	/*
+	 * Screen height is something we don't use.  Linux Xglk returns dimensions
+	 * of 0x0 for text buffer windows, so we can't measure the main window
+	 * height anyway.  But... the height does come into play in AGiliTy's
+	 * agil.c, when the interpreter is deciding how to output game titles, and
+	 * how much of its own subsequent verbiage to output.  This gives us a
+	 * problem, since this "verbiage" is stuff we look for and replace with
+	 * our own special text.  So... sigh, set 25, and try to cope in the
+	 * special text we've set up with all the variations that ensue.
+	 *
+	 * Screen width does get used, but so, so many games, and for that matter
+	 * the interpreter itself, assume 80 chars, so it's simplest just to set,
+	 * and keep, this, and put up with the minor odd effects (making it match
+	 * status_width, or making it something like MAX_INT to defeat the game's
+	 * own wrapping, gives a lot of odder effects, trust me on this one...).
+	 */
+	screen_width = GAGT_DEFAULT_SCREEN_WIDTH;
+	screen_height = GAGT_DEFAULT_SCREEN_HEIGHT;
+
+	/*
+	 * Create a status window, with one or two lines as selected by user
+	 * options or flags.  We can live without a status window if we have to.
+	 */
+	status_height = gagt_extended_status_enabled ? 2 : 1;
+	g_vm->glk_stylehint_set(wintype_TextGrid, style_User1, stylehint_ReverseColor, 1);
+	gagt_status_window = g_vm->glk_window_open(gagt_main_window,
+	                     winmethod_Above | winmethod_Fixed,
+	                     status_height, wintype_TextGrid, 0);
+	if (gagt_status_window) {
+		/*
+		 * Call gagt_status_redraw() to set the interpreter's status_width
+		 * variable initial value.
+		 */
+		gagt_status_redraw();
+	} else {
+		/*
+		 * No status window, so set a suitable default status width.  In this
+		 * case, we're using a value four characters less than the set screen
+		 * width.  AGiliTy's status line code will fill to this width with
+		 * justified text, and we add two characters of bracketing when
+		 * displaying status lines for Glks that don't support separate windows,
+		 * making a total of 78 characters, which should be fairly standard.
+		 */
+		status_width = GAGT_DEFAULT_STATUS_WIDTH;
+	}
+
+	agt_clrscr();
+	gagt_debug("init_interface", "argc=%d, argv=%p", argc, argv);
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Replacement interface.c functions                                  */
+/*---------------------------------------------------------------------*/
+
+/* Get_user_file() type codes. */
+enum {
+	AGT_SCRIPT = 0,
+	AGT_SAVE = 1,
+	AGT_RESTORE = 2,
+	AGT_LOG_READ = 3,
+	AGT_LOG_WRITE = 4
+};
+
+/* Longest acceptable filename. */
+enum { GAGT_MAX_PATH = 1024 };
+
+
+#ifdef GLK_ANSI_ONLY
+/*
+ * gagt_confirm()
+ *
+ * Print a confirmation prompt, and read a single input character, taking
+ * only [YyNn] input.  If the character is 'Y' or 'y', return TRUE.
+ *
+ * This function is only required for the ANSI version of get_user_file().
+ */
+static int
+gagt_confirm(const char *prompt) {
+	event_t event;
+	unsigned char response;
+	assert(prompt);
+
+	/*
+	 * Print the confirmation prompt, in a style that hints that it's from the
+	 * interpreter, not the game.
+	 */
+	gagt_standout_string(prompt);
+
+	/* Wait for a single 'Y' or 'N' character response. */
+	response = ' ';
+	do {
+		g_vm->glk_request_char_event(gagt_main_window);
+		gagt_event_wait(evtype_CharInput, &event);
+
+		if (event.val1 <= BYTE_MAX_VAL)
+			response = g_vm->glk_char_to_upper(event.val1);
+	} while (!(response == 'Y' || response == 'N'));
+
+	/* Echo the confirmation response, and a blank line. */
+	g_vm->glk_set_style(style_Input);
+	g_vm->glk_put_string(response == 'Y' ? "Yes" : "No");
+	g_vm->glk_set_style(style_Normal);
+	g_vm->glk_put_string("\n");
+
+	return response == 'Y';
+}
+#endif
+
+
+/*
+ * gagt_get_user_file()
+ *
+ * Alternative versions of functions to get a file name from the user, and
+ * return a file stream structure.  These functions are front-ended by the
+ * main get_user_file() function, which first converts the AGT file type
+ * into Glk usage and filemode, and also a mode for fopen()/fdopen().
+ *
+ * The ANSI version of the function prompts for the file using the simple
+ * method of querying the user through input in the main window.  It then
+ * constructs a file stream around the path entered, and returns it.
+ *
+ * The non-ANSI, Glk version is more sneaky.  It prompts for a file using
+ * Glk's functions to get filenames by prompt, file selection dialog, or
+ * whatever.  Then it attempts to uncover which file descriptor Glk opened
+ * its file on, dup's it, closes the Glk stream, and returns a file stream
+ * built on this file descriptor.  This is all highly non-ANSI, requiring
+ * dup() and fdopen(), and making some assumptions about the way that dup,
+ * open, and friends work.  It works on Linux, and on Mac (CodeWarrior).
+ * It may also work for you, but if it doesn't, or if your system lacks
+ * things like dup or fdopen, define g_vm->glk_ANSI_ONLY and use the safe version.
+ *
+ * If GARGLK is used, non-ansi version calls garglk_fileref_get_name()
+ * instead, and opens a file the highly portable way, but still with a
+ * Glkily nice prompt dialog.
+ */
+#ifdef GLK_ANSI_ONLY
+static genfile
+gagt_get_user_file(glui32 usage, glui32 fmode, const char *fdtype) {
+	char filepath[GAGT_MAX_PATH];
+	event_t event;
+	int index, all_spaces;
+	genfile retfile;
+	assert(fdtype);
+
+	/* Prompt in a similar way to Glk. */
+	switch (usage) {
+	case fileusage_SavedGame:
+		gagt_normal_string("Enter saved game");
+		break;
+
+	case fileusage_Transcript:
+		gagt_normal_string("Enter transcript file");
+		break;
+
+	case fileusage_InputRecord:
+		gagt_normal_string("Enter command record file");
+		break;
+	}
+	switch (fmode) {
+	case filemode_Read:
+		gagt_normal_string(" to load: ");
+		break;
+
+	case filemode_Write:
+		gagt_normal_string(" to store: ");
+		break;
+	}
+
+	/* Get the path to the file from the user. */
+	g_vm->glk_request_line_event(gagt_main_window, filepath, sizeof(filepath) - 1, 0);
+	gagt_event_wait(evtype_LineInput, &event);
+
+	/* Terminate the file path with a NUL. */
+	assert(event.val1 < sizeof(filepath));
+	filepath[event.val1] = '\0';
+
+	/* Reject file paths that only contain any whitespace characters. */
+	all_spaces = TRUE;
+	for (index = 0; index < strlen(filepath); index++) {
+		if (!isspace(filepath[index])) {
+			all_spaces = FALSE;
+			break;
+		}
+	}
+	if (all_spaces)
+		return badfile(fSAV);
+
+	/* Confirm overwrite of any existing file. */
+	if (fmode == filemode_Write) {
+		genfile file;
+
+		file = fopen(filepath, "r");
+		if (file) {
+			fclose(file);
+
+			if (!gagt_confirm("Overwrite existing file? [y/n] "))
+				return badfile(fSAV);
+		}
+	}
+
+	/* Open and return a FILE* stream, or badfile if this fails. */
+	retfile = fopen(filepath, fdtype);
+	return retfile ? retfile : badfile(fSAV);
+}
+#endif
+
+#ifndef GLK_ANSI_ONLY
+static genfile gagt_get_user_file(glui32 usage, glui32 fmode, const char *fdtype) {
+	frefid_t fileref;
+	genfile retfile;
+	assert(fdtype);
+
+	/* Try to get a Glk file reference with these attributes. */
+	fileref = g_vm->glk_fileref_create_by_prompt(usage, (FileMode)fmode, 0);
+	if (!fileref)
+		return badfile(fSAV);
+
+	/*
+	 * Reject the file reference if we're expecting to read from it,
+	 * and the referenced file doesn't exist.
+	 */
+	if (fmode == filemode_Read && !g_vm->glk_fileref_does_file_exist(fileref)) {
+		g_vm->glk_fileref_destroy(fileref);
+		return badfile(fSAV);
+	}
+
+	/*
+	 * Now, it gets ugly.  Glk assumes that the interpreter will do all of
+	 * its reading and writing using the Glk streams read/write functions.
+	 * It won't; at least, not without major surgery.  So here we're going
+	 * to do some dangerous stuff...
+	 *
+	 * Since a Glk stream is opaque, it's hard to tell what the underlying
+	 * file descriptor is for it.  We can get it if we want to play around
+	 * in the internals of the strid_t structure, but it's unpleasant.
+	 * The alternative is, arguably, no more pleasant, but it makes for
+	 * (perhaps) more portable code.  What we'll do is to dup a file, then
+	 * immediately close it, and call g_vm->glk_stream_open_file().  The open()
+	 * in g_vm->glk_stream_open_file() will return the same file descriptor number
+	 * that we just close()d (in theory...).  This makes the following two
+	 * major assumptions:
+	 *
+	 *  1) g_vm->glk_stream_open_file() opens precisely one file with open()
+	 *  2) open() always uses the lowest available file descriptor number,
+	 *     like dup()
+	 *
+	 * Believe it or not, this is better than the alternatives.  There is
+	 * no Glk function to return the filename from a frefid_t, and it
+	 * moves about in different Glk libraries so we can't just take it
+	 * from a given offset.  And there is no Glk function to return the
+	 * underlying file descriptor or FILE* from a Glk stream either. :-(
+	 */
+
+#ifdef GARGLK
+	retfile = fopen(g_vm->garglk_fileref_get_name(fileref), fdtype);
+#else
+	strid_t stream;
+	int tryfd, glkfd, dupfd, retfd;
+
+	/* So, start by dup()'ing the first file descriptor we can, ... */
+	glkfd = -1;
+	for (tryfd = 0; tryfd < FD_SETSIZE; tryfd++) {
+		glkfd = fcntl(tryfd, F_DUPFD, 0);
+		if (glkfd != -1)
+			break;
+	}
+	if (tryfd >= FD_SETSIZE) {
+		g_vm->glk_fileref_destroy(fileref);
+		return badfile(fSAV);
+	}
+
+	/* ...then closing it, ... */
+	close(glkfd);
+
+	/* ...now open the Glk stream, assuming it opens on file 'glkfd', ... */
+	stream = g_vm->glk_stream_open_file(fileref, fmode, 0);
+	if (!stream) {
+		g_vm->glk_fileref_destroy(fileref);
+		return badfile(fSAV);
+	}
+
+	/* ...dup() the Glk file onto another file descriptor, ... */
+	dupfd = fcntl(glkfd, F_DUPFD, 0);
+	assert(dupfd != -1);
+
+	/* ...close and destroy the Glk edifice for this file, ... */
+	g_vm->glk_stream_close(stream, NULL);
+	g_vm->glk_fileref_destroy(fileref);
+
+	/* ...for neatness, dup() back to the old Glk file descriptor, ... */
+	retfd = fcntl(dupfd, F_DUPFD, 0);
+	assert(retfd != -1 && retfd == glkfd);
+	close(dupfd);
+
+	/* ...and finally, open a FILE* stream onto the return descriptor. */
+	retfile = fdopen(retfd, fdtype);
+	if (!retfile)
+		return badfile(fSAV);
+#endif /* GARGLK */
+
+	/*
+	 * The result of all of this should now be that retfile is a FILE* wrapper
+	 * round a file descriptor open on a file indicated by the user through Glk.
+	 * Return it.
+	 */
+	return retfile;
+}
+#endif
+
+
+/*
+ * get_user_file()
+ *
+ * Get a file name from the user, and return the file stream structure.
+ * This is a front-end to ANSI and non-ANSI variants of the function.
+ */
+genfile get_user_file(int type) {
+	glui32 usage = 0, fmode = 0;
+	const char *fdtype;
+	genfile retfile;
+
+	gagt_output_flush();
+
+	/* Map AGiliTy type to Glk usage and filemode. */
+	switch (type) {
+	case AGT_SCRIPT:
+		usage = fileusage_Transcript;
+		fmode = filemode_Write;
+		break;
+
+	case AGT_SAVE:
+		usage = fileusage_SavedGame;
+		fmode = filemode_Write;
+		break;
+
+	case AGT_RESTORE:
+		usage = fileusage_SavedGame;
+		fmode = filemode_Read;
+		break;
+
+	case AGT_LOG_READ:
+		usage = fileusage_InputRecord;
+		fmode = filemode_Read;
+		break;
+
+	case AGT_LOG_WRITE:
+		usage = fileusage_InputRecord;
+		fmode = filemode_Write;
+		break;
+
+	default:
+		gagt_fatal("GLK: Unknown file type encountered");
+		gagt_exit();
+	}
+
+	/* From these, determine a mode type for the f[d]open() call. */
+	if (fmode == filemode_Write)
+		fdtype = usage == fileusage_SavedGame ? "wb" : "w";
+	else
+		fdtype = usage == fileusage_SavedGame ? "rb" : "r";
+
+	/* Get a file stream from these using the appropriate function. */
+	retfile = gagt_get_user_file(usage, fmode, fdtype);
+
+	gagt_debug("get_user_file", "type=%d -> %p", type, retfile);
+	return retfile;
+}
+
+
+/*
+ * set_default_filenames()
+ *
+ * Set defaults for last save, log, and script filenames.
+ */
+void set_default_filenames(fc_type fc) {
+	/*
+	 * There is nothing to do in this function, since Glk has its own ideas on
+	 * default names for files obtained with a prompt.
+	 */
+	gagt_debug("set_default_filenames", "fc=%p", fc);
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Functions intercepted by link-time wrappers                        */
+/*---------------------------------------------------------------------*/
+
+/*
+ * __wrap_toupper()
+ * __wrap_tolower()
+ *
+ * Wrapper functions around toupper(), tolower(), and fatal().  The Linux
+ * linker's --wrap option will convert calls to mumble() to __wrap_mumble()
+ * if we give it the right options.  We'll use this feature to translate
+ * all toupper() and tolower() calls in the interpreter code into calls to
+ * Glk's versions of these functions.
+ *
+ * It's not critical that we do this.  If a linker, say a non-Linux one,
+ * won't do --wrap, then just do without it.  It's unlikely that there
+ * will be much noticeable difference.
+ */
+int __wrap_toupper(int ch) {
+	unsigned char uch;
+
+	uch = g_vm->glk_char_to_upper((unsigned char) ch);
+	return (int) uch;
+}
+
+int __wrap_tolower(int ch) {
+	unsigned char lch;
+
+	lch = g_vm->glk_char_to_lower((unsigned char) ch);
+	return (int) lch;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Replacements for AGiliTy main() and options parsing                */
+/*---------------------------------------------------------------------*/
+
+/* External declaration of interface.c's set default options function. */
+extern void set_default_options();
+
+/*
+ * The following values need to be passed between the startup_code and main
+ * functions.
+ */
+static int gagt_saved_argc = 0;         /* Recorded argc. */
+static char **gagt_saved_argv = NULL,   /* Recorded argv. */
+              *gagt_gamefile = NULL;      /* Name of game file. */
+static const char *gagt_game_message = NULL;  /* Error message. */
+
+/*
+ * Flag to set if we want to test for a clean exit.  Without this it's a
+ * touch tricky sometimes to corner AGiliTy into calling exit() for us; it
+ * tends to require a broken game file.
+ */
+static int gagt_clean_exit_test = FALSE;
+
+
+/*
+ * gagt_parse_option()
+ *
+ * Glk-ified version of AGiliTy's parse_options() function.  In practice,
+ * because Glk has got to them first, most options that come in here are
+ * probably going to be single-character ones, since this is what we told
+ * Glk in the arguments structure above.  The Glk font control and other
+ * special tweaky flags will probably be the only multiple-character ones.
+ */
+static int gagt_parse_option(const char *option) {
+	unsigned int index;
+	assert(option);
+
+	assert(option[0] == '-');
+	for (index = 1; option[index]; index++) {
+		switch (option[index]) {
+		case 'g':
+			switch (option[++index]) {
+			case 'f':
+				gagt_font_mode = FONT_FIXED_WIDTH;
+				break;
+			case 'p':
+				gagt_font_mode = FONT_PROPORTIONAL;
+				break;
+			case 'a':
+				gagt_font_mode = FONT_AUTOMATIC;
+				break;
+			case 'd':
+				gagt_delay_mode = DELAY_FULL;
+				break;
+			case 'h':
+				gagt_delay_mode = DELAY_SHORT;
+				break;
+			case 'n':
+				gagt_delay_mode = DELAY_OFF;
+				break;
+			case 'r':
+				gagt_replacement_enabled = FALSE;
+				break;
+			case 'x':
+				gagt_abbreviations_enabled = FALSE;
+				break;
+			case 's':
+				gagt_extended_status_enabled = TRUE;
+				break;
+			case 'l':
+				gagt_extended_status_enabled = FALSE;
+				break;
+			case 'c':
+				gagt_commands_enabled = FALSE;
+				break;
+			case 'D':
+				DEBUG_OUT = TRUE;
+				break;
+			case '#':
+				gagt_clean_exit_test = TRUE;
+				break;
+			default:
+				return FALSE;
+			}
+			break;
+
+		case 'p':
+			debug_parse = TRUE;
+			break;
+		case 'a':
+			DEBUG_DISAMBIG = TRUE;
+			break;
+		case 'd':
+			DEBUG_AGT_CMD = TRUE;
+			break;
+		case 'x':
+			DEBUG_EXEC_VERB = TRUE;
+			break;
+		case 's':
+			DEBUG_SMSG = TRUE;
+			break;
+#ifdef MEM_INFO
+		case 'M':
+			DEBUG_MEM = TRUE;
+			break;
+#endif
+		case 'm':
+			descr_maxmem = 0;
+			break;
+		case 't':
+			BATCH_MODE = TRUE;
+			break;
+		case 'c':
+			make_test = TRUE;
+			break;
+		case '1':
+			irun_mode = TRUE;
+			break;
+#ifdef OPEN_FILE_AS_TEXT
+		case 'b':
+			open_as_binary = TRUE;
+			break;
+#endif
+
+		case '?':
+		default:
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+
+/*
+ * gagt_startup_code()
+ * gagt_main()
+ *
+ * Together, these functions take the place of the original AGiliTy main().
+ * The first one is called from glkunix_startup_code(), to parse and
+ * generally handle options.  The second is called from glk_main(), and
+ * does the real work of running the game.
+ */
+int gagt_startup_code(int argc, char *argv[]) {
+	int argv_index;
+
+	/*
+	 * Before doing anything else, stash argc and argv away for use by
+	 * gagt_main() below.
+	 */
+	gagt_saved_argc = argc;
+	gagt_saved_argv = argv;
+
+	/* Make the mandatory call for initialization. */
+	set_default_options();
+
+	/* Handle command line arguments. */
+	for (argv_index = 1;
+	        argv_index < argc && argv[argv_index][0] == '-'; argv_index++) {
+		/*
+		 * Handle an option string coming after "-".  If the options parse
+		 * fails, return FALSE.
+		 */
+		if (!gagt_parse_option(argv[argv_index]))
+			return FALSE;
+	}
+
+	/*
+	 * Get the name of the game file.  Since we need this in our call from
+	 * glk_main, we need to keep it in a module static variable.  If the game
+	 * file name is omitted, then here we'll set the pointer to NULL, and
+	 * complain about it later in main.  Passing the message string around
+	 * like this is a nuisance...
+	 */
+	if (argv_index == argc - 1) {
+		gagt_gamefile = argv[argv_index];
+		gagt_game_message = NULL;
+#ifdef GARGLK
+		char *s;
+		s = strrchr(gagt_gamefile, '\\');
+		if (s) g_vm->garglk_set_story_name(s + 1);
+		s = strrchr(gagt_gamefile, '/');
+		if (s) g_vm->garglk_set_story_name(s + 1);
+#endif /* GARGLK */
+	} else {
+		gagt_gamefile = NULL;
+		if (argv_index < argc - 1)
+			gagt_game_message = "More than one game file was given"
+			                    " on the command line.";
+		else
+			gagt_game_message = "No game file was given on the command line.";
+	}
+
+	/* All startup options were handled successfully. */
+	return TRUE;
+}
+
+static void gagt_main() {
+	fc_type fc;
+	assert(gagt_saved_argc != 0 && gagt_saved_argv);
+
+	/* Ensure AGiliTy internal types have the right sizes. */
+	if (sizeof(integer) < 2 || sizeof(int32) < 4 || sizeof(uint32) < 4) {
+		gagt_fatal("GLK: Types sized incorrectly, recompilation is needed");
+		gagt_exit();
+	}
+
+	/*
+	 * Initialize the interface.  As it happens, init_interface() is in our
+	 * module here (above), and ignores argc and argv, but since the main() in
+	 * AGiliTy passes them, we'll do so here, just in case we ever want to go
+	 * back to using AGiliTy's main() function.
+	 *
+	 * init_interface() can fail if there is a problem creating the main
+	 * window.  As it doesn't return status, we have to detect this by checking
+	 * that gagt_main_window is not NULL.
+	 */
+	init_interface(gagt_saved_argc, gagt_saved_argv);
+	if (!gagt_main_window) {
+		gagt_fatal("GLK: Can't open main window");
+		gagt_exit();
+	}
+	g_vm->glk_window_clear(gagt_main_window);
+	g_vm->glk_set_window(gagt_main_window);
+	g_vm->glk_set_style(style_Normal);
+
+	/* If there's a problem with the game file, complain now. */
+	if (!gagt_gamefile) {
+		assert(gagt_game_message);
+		if (gagt_status_window)
+			g_vm->glk_window_close(gagt_status_window, NULL);
+		gagt_header_string("Glk AGiliTy Error\n\n");
+		gagt_normal_string(gagt_game_message);
+		gagt_normal_char('\n');
+		gagt_exit();
+	}
+
+	/*
+	 * Create a game file context, and try to ensure it will open successfully
+	 * in run_game().
+	 */
+	fc = init_file_context(gagt_gamefile, fDA1);
+	if (!(gagt_workround_fileexist(fc, fAGX)
+	        || gagt_workround_fileexist(fc, fDA1))) {
+		if (gagt_status_window)
+			g_vm->glk_window_close(gagt_status_window, NULL);
+		gagt_header_string("Glk AGiliTy Error\n\n");
+		gagt_normal_string("Can't find or open game '");
+		gagt_normal_string(gagt_gamefile);
+		gagt_normal_char('\'');
+		gagt_normal_char('\n');
+		gagt_exit();
+	}
+
+	/*
+	 * Run the game interpreter in AGiliTy.  run_game() releases the file
+	 * context, so we don't have to, don't want to, and shouldn't.
+	 */
+	run_game(fc);
+
+	/*
+	 * Handle any updated status, and flush all remaining buffered output;
+	 * this also frees all malloc'ed memory in the buffers.
+	 */
+	gagt_status_notify();
+	gagt_output_flush();
+
+	/*
+	 * Free any temporary memory that may have been used by status line
+	 * functions.
+	 */
+	gagt_status_cleanup();
+
+	/* Close any open transcript, input log, and/or read log. */
+	if (gagt_transcript_stream) {
+		g_vm->glk_stream_close(gagt_transcript_stream, NULL);
+		gagt_transcript_stream = NULL;
+	}
+	if (gagt_inputlog_stream) {
+		g_vm->glk_stream_close(gagt_inputlog_stream, NULL);
+		gagt_inputlog_stream = NULL;
+	}
+	if (gagt_readlog_stream) {
+		g_vm->glk_stream_close(gagt_readlog_stream, NULL);
+		gagt_readlog_stream = NULL;
+	}
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Linkage between Glk entry/exit calls and the AGiliTy interpreter   */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Safety flags, to ensure we always get startup before main, and that
+ * we only get a call to main once.
+ */
+static int gagt_startup_called = FALSE,
+           gagt_main_called = FALSE;
+
+/*
+ * We try to catch calls to exit() from the interpreter, and redirect them
+ * to g_vm->glk_exit().  To help tell these calls from a call to exit() from
+ * g_vm->glk_exit() itself, we need to monitor when interpreter code is running,
+ * and when not.
+ */
+static int gagt_agility_running = FALSE;
+
+
+/*
+ * gagt_finalizer()
+ *
+ * ANSI atexit() handler.  This is the first part of trying to catch and re-
+ * direct the calls the core AGiliTy interpreter makes to exit() -- we really
+ * want it to call g_vm->glk_exit(), but it's hard to achieve.  There are three
+ * basic approaches possible, and all have drawbacks:
+ *
+ *   o #define exit to gagt_something, and provide the gagt_something()
+ *     function.  This type of macro definition is portable for the most
+ *     part, but tramples the code badly, and messes up the build of the
+ *     non-interpreter "support" binaries.
+ *   o Use ld's --wrap to wrapper exit.  This only works with Linux's linker
+ *     and so isn't at all portable.
+ *   o Register an exit handler with atexit(), and try to cope in it after
+ *     exit() has been called.
+ *
+ * Here we try the last of these.  The one sticky part of it is that in our
+ * exit handler we'll want to call g_vm->glk_exit(), which will in all likelihood
+ * call exit().  And multiple calls to exit() from a program are "undefined".
+ *
+ * In practice, C runtimes tend to do one of three things: they treat the
+ * exit() call from the exit handler as if it was a return; they recurse
+ * indefinitely through the hander; or they do something ugly (abort, for
+ * example).  The first of these is fine, ideal in fact, and seems to be the
+ * Linux and SVR4 behavior.  The second we can avoid with a flag.  The last
+ * is the problem case, seen only with SVR3 (and even then, it occurs only
+ * on program exit, after everything's cleaned up, and for that matter only
+ * on abnormal exit).
+ *
+ * Note that here we're not expecting to get a call to this routine, and if
+ * we do, and interpreter code is still running, it's a sign that we need
+ * to take actions we'd hoped not to have to take.
+ */
+static void gagt_finalizer() {
+	/*
+	 * If interpreter code is still active, and we're not in a g_vm->glk_select(),
+	 * the core interpreter code called exit().  Handle cleanup.
+	 */
+	if (gagt_agility_running && !gagt_event_in_glk_select()) {
+		event_t event;
+
+		/*
+		 * If we have a main window, try to update status (which may go to the
+		 * status window, or to the main window) and flush any pending buffered
+		 * output.
+		 */
+		if (gagt_main_window) {
+			gagt_status_notify();
+			gagt_output_flush();
+		}
+
+		/*
+		 * Clear the flag to avoid recursion, and call g_vm->glk_exit() to clean up
+		 * Glk and terminate.  This is the call that probably re-calls exit(),
+		 * and thus prods "undefined" bits of the C runtime, so we'll make it
+		 * configurable and overrideable for problem cases.
+		 */
+		gagt_agility_running = FALSE;
+
+		/*
+		 * We've decided not to take the dangerous route.
+		 *
+		 * In that case, providing we have a main window, fake a Glk-like-ish
+		 * hit-any-key-and-wait message using a simple string in the main
+		 * window.  Not great, but usable where we're forced into bypassing
+		 * g_vm->glk_exit().  If we have no main window, there's no point in doing
+		 * anything more.
+		 */
+		if (gagt_main_window) {
+			g_vm->glk_cancel_char_event(gagt_main_window);
+			g_vm->glk_cancel_line_event(gagt_main_window, NULL);
+
+			g_vm->glk_set_style(style_Alert);
+			g_vm->glk_put_string("\n\nHit any key to exit.\n");
+			g_vm->glk_request_char_event(gagt_main_window);
+			gagt_event_wait(evtype_CharInput, &event);
+		}
+	}
+}
+
+
+/*
+ * gagt_exit()
+ *
+ * g_vm->glk_exit() local wrapper.  This is the second part of trying to catch
+ * and redirect calls to exit().  g_vm->glk_finalizer() above needs to know that
+ * we called g_vm->glk_exit() already from here, so it doesn't try to do it again.
+ */
+static void gagt_exit() {
+	assert(gagt_agility_running);
+
+	/*
+	 * Clear the running flag to neutralize gagt_finalizer(), throw out any
+	 * buffered output data, and then call the real g_vm->glk_exit().
+	 */
+	gagt_agility_running = FALSE;
+	gagt_output_delete();
+	g_vm->glk_exit();
+}
+
+
+/*
+ * __wrap_exit()
+ *
+ * Exit() wrapper where a linker does --wrap.  This is the third part of
+ * trying to catch and redirect calls to exit().
+ *
+ * This function is for use only with IFP, and avoids a nasty attempt at
+ * reusing a longjmp buffer.   IFP will redirect calls to exit() into
+ * g_vm->glk_exit() as a matter of course.  It also handles atexit(), and we've
+ * registered a function with atexit() that calls g_vm->glk_exit(), and
+ * IFP redirects g_vm->glk_exit() to be an effective return from glk_main().  At
+ * that point it calls finalizers.  So without doing something special for
+ * IFP, we'll find ourselves calling g_vm->glk_exit() twice -- once as the IFP
+ * redirected exit(), and once from our finalizer.  Two returns from the
+ * function glk_main() is a recipe for unpleasantness.
+ *
+ * As IFP is Linux-only, at present, --wrap will always be available to IFP
+ * plugin builds.  So here, we'll wrap exit() before IFP can get to it, and
+ * handle it safely.  For non-IFP/non-wrap links, this is just an unused
+ * function definition, and can be safely ignored...
+ */
+void __wrap_exit(int status) {
+	assert(gagt_agility_running);
+
+	/*
+	 * In an IFP plugin, only the core interpreter code could have called exit()
+	 * here -- we don't, and IFP redirects g_vm->glk_exit(), the only other potential
+	 * caller of exit().  (It also redirects exit() if we don't get to it here
+	 * first.)
+	 *
+	 * So, if we have a main window, flush it.  This is the same cleanup as
+	 * done by the finalizer.
+	 */
+	if (gagt_main_window) {
+		gagt_status_notify();
+		gagt_output_flush();
+	}
+
+	/* Clear the running flag, and transform exit() into a g_vm->glk_exit(). */
+	gagt_agility_running = FALSE;
+	g_vm->glk_exit();
+}
+
+
+/*
+ * glk_main()
+ *
+ * Main entry point for Glk.  Here, all startup is done, and we call our
+ * function to run the game.
+ */
+void glk_main() {
+	assert(gagt_startup_called && !gagt_main_called);
+	gagt_main_called = TRUE;
+
+	/*
+	 * Register gagt_finalizer() with atexit() to cleanup on exit.  Note that
+	 * this module doesn't expect the atexit() handler to be called on all
+	 * forms of exit -- see comments in gagt_finalizer() for more.
+	 */
+	if (atexit(gagt_finalizer) != 0) {
+		gagt_fatal("GLK: Failed to register finalizer");
+		gagt_exit();
+	}
+
+	/*
+	 * If we're testing for a clean exit, deliberately call exit() to see what
+	 * happens.  We're hoping for a clean process termination, but our exit
+	 * code explores "undefined" ANSI.  If we get something ugly, like a core
+	 * dump, we'll want to set GLK[AGIL]_CLEAN_EXIT.
+	 */
+	if (gagt_clean_exit_test) {
+		gagt_agility_running = TRUE;
+		return;
+	}
+
+	/*
+	 * The final part of trapping exit().  Set the running flag, and call the
+	 * interpreter main function.  Clear the flag when the main function returns.
+	 */
+	gagt_agility_running = TRUE;
+	gagt_main();
+	gagt_agility_running = FALSE;
+}
+
+
+/*---------------------------------------------------------------------*/
+/*  Glk linkage relevant only to the UNIX platform                     */
+/*---------------------------------------------------------------------*/
+
+/*
+ * Glk arguments for UNIX versions of the Glk interpreter.
+ */
+/*
+glkunix_argumentlist_t glkunix_arguments[] = {
+ {(char *) "-gf", glkunix_arg_NoValue,
+  (char *) "-gf        Force Glk to use only a fixed width font"},
+ {(char *) "-gp", glkunix_arg_NoValue,
+  (char *) "-gp        Allow Glk to use only a proportional font"},
+ {(char *) "-ga", glkunix_arg_NoValue,
+  (char *) "-ga        Try to use a suitable Glk font automatically"},
+ {(char *) "-gd", glkunix_arg_NoValue,
+  (char *) "-gd        Delay for the full period in Glk"},
+ {(char *) "-gh", glkunix_arg_NoValue,
+  (char *) "-gh        Delay for approximately half the period in Glk"},
+ {(char *) "-gn", glkunix_arg_NoValue,
+  (char *) "-gn        Turn off all game delays in Glk"},
+ {(char *) "-gr", glkunix_arg_NoValue,
+  (char *) "-gr        Turn off Glk text replacement"},
+ {(char *) "-gx", glkunix_arg_NoValue,
+  (char *) "-gx        Turn off Glk abbreviation expansions"},
+ {(char *) "-gs", glkunix_arg_NoValue,
+  (char *) "-gs        Display a short status window in Glk"},
+ {(char *) "-gl", glkunix_arg_NoValue,
+  (char *) "-gl        Display an extended status window in Glk"},
+ {(char *) "-gc", glkunix_arg_NoValue,
+  (char *) "-gc        Turn off Glk command escapes in games"},
+ {(char *) "-gD", glkunix_arg_NoValue,
+  (char *) "-gD        Turn on Glk port module debug tracing"},
+ {(char *) "-g#", glkunix_arg_NoValue,
+  (char *) "-g#        Test for clean exit (Glk module debugging only)"},
+ {(char *) "-1", glkunix_arg_NoValue,
+  (char *) "-1         IRUN Mode: Print messages in first person"},
+ {(char *) "-d", glkunix_arg_NoValue,
+  (char *) "-d         Debug metacommand execution"},
+ {(char *) "-t", glkunix_arg_NoValue,
+  (char *) "-t         Test mode"},
+ {(char *) "-c", glkunix_arg_NoValue,
+  (char *) "-c         Create test file"},
+ {(char *) "-m", glkunix_arg_NoValue,
+  (char *) "-m         Force descriptions to be loaded from disk"},
+#ifdef OPEN_AS_TEXT
+ {(char *) "-b", glkunix_arg_NoValue,
+  (char *) "-b         Open data files as binary files"},
+#endif
+ {(char *) "-p", glkunix_arg_NoValue,
+  (char *) "-p         Debug parser"},
+ {(char *) "-x", glkunix_arg_NoValue,
+  (char *) "-x         Debug verb execution loop"},
+ {(char *) "-a", glkunix_arg_NoValue,
+  (char *) "-a         Debug disambiguation system"},
+ {(char *) "-s", glkunix_arg_NoValue,
+  (char *) "-s         Debug STANDARD message handler"},
+#ifdef MEM_INFO
+ {(char *) "-M", glkunix_arg_NoValue,
+  (char *) "-M         Debug memory allocation"},
+#endif
+ {(char *) "", glkunix_arg_ValueCanFollow,
+  (char *) "filename   game to run"},
+ {NULL, glkunix_arg_End, NULL}
+};
+
+*/
+/*
+ * glkunix_startup_code()
+ *
+ * Startup entry point for UNIX versions of Glk AGiliTy.  Glk will call
+ * glkunix_startup_code() to pass in arguments.  On startup, we call our
+ * function to parse arguments and generally set stuff up.
+ */
+
+int glk_startup_code(int argc, char *argv[]) {
+	assert(!gagt_startup_called);
+	gagt_startup_called = TRUE;
+
+	return gagt_startup_code(argc, argv);
+}
+
+} // End of namespace AGT
+} // End of namespace Glk