path: root/engines/glk/agt/os_glk.cpp

/* 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() {
	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();
}


/*---------------------------------------------------------------------*/
/*  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();

/*
 * 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().  The second is called
 * from glk_main(), and does the real work of running the game.
 */
bool gagt_startup_code() {
	/* Make the mandatory call for initialization. */
	set_default_options();

	/* All startup options were handled successfully. */
	return TRUE;
}

static void gagt_main() {
	fc_type fc;

	/*
	 * 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();
	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);

	/*
	 * Create a game file context, and try to ensure it will open successfully
	 * in run_game().
	 */
	fc = init_file_context(g_vm->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(g_vm->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.
 */
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;

	/*
	 * 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() {
	assert(!gagt_startup_called);
	gagt_startup_called = TRUE;

	return gagt_startup_code();
}

} // End of namespace AGT
} // End of namespace Glk