xref: /dports/games/scummvm/scummvm-2.5.1/engines/glk/tads/tads2/output.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/tads/tads2/character_map.h"
#include "glk/tads/tads2/debug.h"
#include "glk/tads/tads2/error.h"
#include "glk/tads/tads2/memory_cache.h"
#include "glk/tads/tads2/os.h"
#include "glk/tads/tads2/run.h"
#include "glk/tads/tads2/text_io.h"
#include "glk/tads/tads2/vocabulary.h"
#include "glk/tads/os_glk.h"

namespace Glk {
namespace TADS {
namespace TADS2 {

/* Forward declarations */
struct out_stream_info;

/*
 *   use our own isxxx - anything outside the US ASCII range is not reliably
 *   classifiable by the normal C isxxx routines
 */
#define outissp(c) (((uchar)(c)) <= 127 && Common::isSpace((uchar)(c)))
#define outisal(c) (((uchar)(c)) <= 127 && Common::isAlpha((uchar)(c)))
#define outisdg(c) (((uchar)(c)) <= 127 && Common::isDigit((uchar)(c)))
#define outisup(c) (((uchar)(c)) <= 127 && Common::isUpper((uchar)(c)))
#define outislo(c) (((uchar)(c)) <= 127 && Common::isLower((uchar)(c)))


/*
 *   Turn on formatter-level MORE mode, EXCEPT under any of the following
 *   conditions:
 *
 *   - this is a MAC OS port
 *.  - this is an HTML TADS interpreter
 *.  - USE_OS_LINEWRAP is defined
 *
 *   Formatter-level MORE mode and formatter-level line wrapping go together;
 *   you can't have one without the other.  So, if USE_OS_LINEWRAP is
 *   defined, we must also use OS-level MORE mode, which means we don't want
 *   formatter-level MORE mode.
 *
 *   For historical reasons, we check specifically for MAC_OS.  This was the
 *   first platform for which OS-level MORE mode and OS-level line wrapping
 *   were invented; at the time, we foolishly failed to anticipate that more
 *   platforms might eventually come along with the same needs, so we coded a
 *   test for MAC_OS rather than some more abstract marker.  For
 *   compatibility, we retain this specific test.
 *
 *   USE_OS_LINEWRAP is intended as the more abstract marker we should
 *   originally have used.  A port should #define USE_OS_LINEWRAP in its
 *   system-specific os_xxx.h header to turn on OS-level line wrapping and
 *   OS-level MORE mode.  Ports should avoid adding new #ifndef tests for
 *   specific platforms here; we've only retained the MAC_OS test because we
 *   don't want to break the existing MAC_OS port.
 */
#ifndef MAC_OS
# ifndef USE_HTML
#  ifndef USE_OS_LINEWRAP
#   define USE_MORE                   /* activate formatter-level more-mode */
#  endif /* USE_OS_LINEWRAP */
# endif /* USE_HTML */
#endif /* MAC_OS */

/*
 *   In HTML mode, don't use MORE mode.  Note that we explicitly turn MORE
 *   mode OFF, even though we won't have turned it on above, because it might
 *   have been turned on by an os_xxx.h header.  This is here for historical
 *   reasons; in particular, some of the HTML interpreter builds include
 *   headers that were originally written for the normal builds for those
 *   same platforms, and those original headers explicitly #define USE_MORE
 *   somewhere.  So, to be absolutely sure we get it right here, we have to
 *   explicitly turn off USE_MORE when compiling for HTML mode.
 */
#ifdef USE_HTML
# ifdef USE_MORE
#  undef USE_MORE
# endif
#endif

/*
 *   QSPACE is the special character for a quoted space (internally, the
 *   sequence "\ " (backslash-space) is converted to QSPACE).  It must not
 *   be any printable character.  The value here may need to be changed in
 *   the extremely unlikely event that TADS is ever ported to an EBCDIC
 *   machine.
 */
#define QSPACE 26

/*
 *   QTAB is a special hard tab character indicator.  We use this when we
 *   need to generate a hard tab to send to the underlying output layer
 *   (in particular, we use this to send hard tabs to the HTML formatter
 *   when we're in HTML mode).
 */
#define QTAB 25


/* maximum width of the display */
#define MAXWIDTH  OS_MAXWIDTH


/* ------------------------------------------------------------------------ */
/*
 *   Globals and statics.  These should really be moved into a context
 *   structure, so that the output formatter subsystem could be shared
 *   among multiple clients.  For now, there's no practical problem using
 *   statics, because we only need a single output subsystem at one time.
 */

/* current script (command input) file */
extern osfildef *scrfp;

/*
 *   This should be TRUE if the output should have two spaces after a
 *   period (or other such punctuation. It should generally be TRUE for
 *   fixed-width fonts, and FALSE for proportional fonts.
 */
static int doublespace = 1;

/*
 *   Log file handle and name.  If we're copying output to a log file,
 *   these will tell us about the file.
 */
osfildef *logfp;
static char logfname[OSFNMAX];

/* flag indicating whether output has occurred since last check */
static uchar outcnt;

/* flag indicating whether hidden output has occurred */
static uchar hidout;

/* flag indicating whether to show (TRUE) or hide (FALSE) output */
static uchar outflag;

/* flag indicating whether output is hidden for debugging purposes */
int dbghid;

/*
 *   Current recursion level in formatter invocation
 */
static int G_recurse = 0;

/* active stream in current recursion level */
static out_stream_info *G_cur_stream;

/* watchpoint mode flag */
static uchar outwxflag;

/*
 *   User filter function.  When this function is set, we'll invoke this
 *   function for each string that's displayed through the output
 *   formatter.
 */
static objnum G_user_filter = MCMONINV;


/* ------------------------------------------------------------------------ */
/*
 *   Hack to run with TADS 2.0 with minimal reworking.  Rather than using
 *   an allocated output layer context, store our subsystem context
 *   information in some statics.  This is less clean than using a real
 *   context, but doesn't create any practical problems as we don't need
 *   to share the output formatter subsystem among multiple simultaneous
 *   callers.
 */
static runcxdef *runctx;                               /* execution context */
static uchar    *fmsbase;                        /* format string area base */
static uchar    *fmstop;                          /* format string area top */
static objnum    cmdActor;                                 /* current actor */

/* forward declarations of static functions */
static void outstring_stream(out_stream_info *stream, const char *s);
static void outchar_noxlat_stream(out_stream_info *stream, char c);
static char out_parse_entity(char *outbuf, size_t outbuf_size, const char **sp, size_t *slenp);


/* ------------------------------------------------------------------------ */
/*
 *   HTML lexical analysis mode
 */
#define HTML_MODE_NORMAL  0                    /* normal text, not in a tag */
#define HTML_MODE_TAG     1                         /* parsing inside a tag */
#define HTML_MODE_SQUOTE  2           /* in a single-quoted string in a tag */
#define HTML_MODE_DQUOTE  3           /* in a double-quoted string in a tag */

/*
 *   HTML parsing mode flag for <BR> tags.  We defer these until we've
 *   read the full tag in order to obey an HEIGHT attribute we find.  When
 *   we encounter a <BR>, we figure out whether we think we'll need a
 *   flush or a blank line; if we find a HEIGHT attribute, we may change
 *   this opinion.
 */
#define HTML_DEFER_BR_NONE   0                           /* no pending <BR> */
#define HTML_DEFER_BR_FLUSH  1                   /* only need an outflush() */
#define HTML_DEFER_BR_BLANK  2                        /* need an outblank() */

/*
 *   If we're compiling for an HTML-enabled underlying output subsystem,
 *   we want to call the underlying OS layer when switching in and out of
 *   HTML mode.  If the underlying system doesn't process HTML, we don't
 *   need to let it know anything about HTML mode.
 */
#ifdef USE_HTML
# define out_start_html(stream) os_start_html()
# define out_end_html(stream)   os_end_html()
#else
# define out_start_html(stream)
# define out_end_html(stream)
#endif


/* ------------------------------------------------------------------------ */
/*
 *   Output formatter stream state structure.  This structure encapsulates
 *   the state of an individual output stream.
 */
struct out_stream_info {
	/* low-level display routine (va_list version) */
	void (*do_print)(out_stream_info *stream, const char *str);

	/* current line position and output column */
	uchar linepos;
	uchar linecol;

	/* number of lines on the screen (since last MORE prompt) */
	int linecnt;

	/* output buffer */
	char linebuf[MAXWIDTH];

	/*
	 *   attribute buffer - we keep one attribute entry for each character in
	 *   the line buffer
	 */
	int attrbuf[MAXWIDTH];

	/* current attribute for text we're buffering into linebuf */
	int cur_attr;

	/* last attribute we wrote to the osifc layer */
	int os_attr;

	/* CAPS mode - next character output is converted to upper-case */
	uchar capsflag;

	/* NOCAPS mode - next character output is converted to lower-case */
	uchar nocapsflag;

	/* ALLCAPS mode - all characters output are converted to upper-case */
	uchar allcapsflag;

	/* capture information */
	mcmcxdef *capture_ctx;           /* memory context to use for capturing */
	mcmon     capture_obj;                /* object holding captured output */
	uint      capture_ofs;                /* write offset in capture object */
	int       capturing;                 /* true -> we are capturing output */

	/* "preview" state for line flushing */
	int preview;

	/* flag indicating that we just flushed a new line */
	int just_did_nl;

	/* this output stream uses "MORE" mode */
	int use_more_mode;

	/*
	 *   This output stream uses OS-level line wrapping - if this is set,
	 *   the output formatter will not insert a newline at the end of a
	 *   line that it's flushing for word wrapping, but will instead let
	 *   the underlying OS display layer handle the wrapping.
	 */
	int os_line_wrap;

	/*
	 *   Flag indicating that the underlying output system wants to
	 *   receive its output as HTML.
	 *
	 *   If this is true, we'll pass through HTML to the underlying output
	 *   system, and in addition generate HTML sequences for certain
	 *   TADS-native escapes (for example, we'll convert the "\n" sequence
	 *   to a <BR> sequence).
	 *
	 *   If this is false, we'll do just the opposite: we'll remove HTML
	 *   from the output stream and convert it into normal text sequences.
	 */
	int html_target;

	/*
	 *   Flag indicating that the target uses plain text.  If this flag is
	 *   set, we won't add the OS escape codes for highlighted characters.
	 */
	int plain_text_target;

	/*
	 *   Flag indicating that the caller is displaying HTML.  We always
	 *   start off in text mode; the client can switch to HTML mode by
	 *   displaying a special escape sequence, and can switch back to text
	 *   mode by displaying a separate special escape sequence.
	 */
	int html_mode;

	/* current lexical analysis mode */
	unsigned int html_mode_flag;

	/* <BR> defer mode */
	unsigned int html_defer_br;

	/*
	 *   HTML "ignore" mode - we suppress all output when parsing the
	 *   contents of a <TITLE> or <ABOUTBOX> tag
	 */
	int html_in_ignore;

	/*
	 *   HTML <TITLE> mode - when we're in this mode, we're gathering the
	 *   title (i.e., we're inside a <TITLE> tag's contents).  We'll copy
	 *   characters to the title buffer rather than the normal output
	 *   buffer, and then call os_set_title() when we reach the </TITLE>
	 *   tag.
	 */
	int html_in_title;

	/* buffer for the title */
	char html_title_buf[256];

	/* pointer to next available character in title buffer */
	char *html_title_ptr;

	/* quoting level */
	int html_quote_level;

	/* PRE nesting level */
	int html_pre_level;

	/*
	 *   Parsing mode flag for ALT attributes.  If we're parsing a tag
	 *   that allows ALT, such as IMG or SOUND, we'll set this flag, then
	 *   insert the ALT text if we encounter it during parsing.
	 */
	int html_allow_alt;
};

/*
 *   Default output converter.  This is the output converter for the
 *   standard display.  Functions in the public interface that do not
 *   specify an output converter will use this converter by default.
 */
static out_stream_info G_std_disp;

/*
 *   Log file converter.  This is the output converter for a log file.
 *   Whenever we open a log file, we'll initialize this converter; as we
 *   display text to the main display, we'll also copy it to the log file.
 *
 *   We maintain an entire separate conversion context for the log file,
 *   so that we can perform a different set of conversions on it.  We may
 *   want, for example, to pass HTML text through to the OS display
 *   subsystem (this is the case for the HTML-enabled interpreter), but
 *   we'll still want to convert log file output to text.  By keeping a
 *   separate display context for the log file, we can format output to
 *   the log file using an entirely different style than we do for the
 *   display.
 */
static out_stream_info G_log_disp;


/* ------------------------------------------------------------------------ */
/*
 *   low-level output handlers for the standard display and log file
 */

/* standard display printer */
static void do_std_print(out_stream_info *stream, const char *str)
{
	VARUSED(stream);

	/* display the text through the OS layer */
	os_printz(str);
}

/* log file printer */
static void do_log_print(out_stream_info *stream, const char *str)
{
	VARUSED(stream);

	/* display to the log file */
	if (logfp != 0 && G_os_moremode)
	{
		os_fprintz(logfp, str);
		osfflush(logfp);
	}
}


/* ------------------------------------------------------------------------ */
/*
 *   initialize a generic output formatter state structure
 */
static void out_state_init(out_stream_info *stream)
{
	/* start out at the first column */
	stream->linepos = 0;
	stream->linecol = 0;
	stream->linebuf[0] = '\0';

	/* set normal text attributes */
	stream->cur_attr = 0;
	stream->os_attr = 0;

	/* start out at the first line */
	stream->linecnt = 0;

	/* we're not in either "caps", "nocaps", or "allcaps" mode yet */
	stream->capsflag = stream->nocapsflag = stream->allcapsflag = FALSE;

	/* we're not capturing yet */
	stream->capturing = FALSE;
	stream->capture_obj = MCMONINV;

	/* we aren't previewing a line yet */
	stream->preview = 0;

	/* we haven't flushed a new line yet */
	stream->just_did_nl = FALSE;

	/* presume this stream does not use "MORE" mode */
	stream->use_more_mode = FALSE;

	/* presume this stream uses formatter-level line wrapping */
	stream->os_line_wrap = FALSE;

	/* assume that the underlying system is not HTML-enabled */
	stream->html_target = FALSE;

	/* presume this target accepts OS highlighting sequences */
	stream->plain_text_target = FALSE;

	/* start out in text mode */
	stream->html_mode = FALSE;

	/* start out in "normal" lexical state */
	stream->html_mode_flag = HTML_MODE_NORMAL;

	/* not in an ignored tag yet */
	stream->html_in_ignore = FALSE;

	/* not in title mode yet */
	stream->html_in_title = FALSE;

	/* not yet deferring line breaks */
	stream->html_defer_br = HTML_DEFER_BR_NONE;

	/* not yet in quotes */
	stream->html_quote_level = 0;

	/* not yet in a PRE block */
	stream->html_pre_level = 0;

	/* not in an ALT tag yet */
	stream->html_allow_alt = FALSE;
}


/* ------------------------------------------------------------------------ */
/*
 *   initialize a standard display stream
 */
static void out_init_std(out_stream_info *stream)
{
	/* there's no user output filter function yet */
	out_set_filter(MCMONINV);

	/* initialize the basic stream state */
	out_state_init(stream);

	/* set up the low-level output routine */
	G_std_disp.do_print = do_std_print;

#ifdef USE_MORE
	/*
	 *   We're compiled for MORE mode, and we're not compiling for an
	 *   underlying HTML formatting layer, so use MORE mode for the
	 *   standard display stream.
	 */
	stream->use_more_mode = TRUE;
#else
	/*
	 *   We're compiled for OS-layer (or HTML-layer) MORE handling.  For
	 *   this case, use OS-layer (or HTML-layer) line wrapping as well.
	 */
	stream->os_line_wrap = TRUE;
#endif

#ifdef USE_HTML
	/*
	 *   if we're compiled for HTML mode, set the standard output stream
	 *   so that it knows it has an HTML target - this will ensure that
	 *   HTML tags are passed through to the underlying stream, and that
	 *   we generate HTML equivalents for our own control sequences
	 */
	stream->html_target = TRUE;
#endif
}

/*
 *   initialize a standard log file stream
 */
static void out_init_log(out_stream_info *stream)
{
	/* initialize the basic stream state */
	out_state_init(stream);

	/* set up the low-level output routine */
	stream->do_print = do_log_print;

	/* use plain text in the log file stream */
	stream->plain_text_target = TRUE;
}



/* ------------------------------------------------------------------------ */
/*
 *   table of '&' character name sequences
 */
struct amp_tbl_t {
	/* entity name */
	const char *cname;

	/* HTML Unicode character value */
	uint        html_cval;

	/* native character set expansion */
	char       *expan;
};

/*
 *   HTML entity mapping table.  When we're in non-HTML mode, we keep our
 *   own expansion table so that we can map HTML entity names into the
 *   local character set.
 *
 *   The entries in this table must be in sorted order (by HTML entity
 *   name), because we use a binary search to find an entity name in the
 *   table.
 */
static struct amp_tbl_t amp_tbl[] = {
	{ "AElig", 198, 0 },
	{ "Aacute", 193, 0 },
	{ "Abreve", 258, 0 },
	{ "Acirc", 194, 0 },
	{ "Agrave", 192, 0 },
	{ "Alpha", 913, 0 },
	{ "Aogon", 260, 0 },
	{ "Aring", 197, 0 },
	{ "Atilde", 195, 0 },
	{ "Auml", 196, 0 },
	{ "Beta", 914, 0 },
	{ "Cacute", 262, 0 },
	{ "Ccaron", 268, 0 },
	{ "Ccedil", 199, 0 },
	{ "Chi", 935, 0 },
	{ "Dagger", 8225, 0 },
	{ "Dcaron", 270, 0 },
	{ "Delta", 916, 0 },
	{ "Dstrok", 272, 0 },
	{ "ETH", 208, 0 },
	{ "Eacute", 201, 0 },
	{ "Ecaron", 282, 0 },
	{ "Ecirc", 202, 0 },
	{ "Egrave", 200, 0 },
	{ "Eogon", 280, 0 },
	{ "Epsilon", 917, 0 },
	{ "Eta", 919, 0 },
	{ "Euml", 203, 0 },
	{ "Gamma", 915, 0 },
	{ "Iacute", 205, 0 },
	{ "Icirc", 206, 0 },
	{ "Igrave", 204, 0 },
	{ "Iota", 921, 0 },
	{ "Iuml", 207, 0 },
	{ "Kappa", 922, 0 },
	{ "Lacute", 313, 0 },
	{ "Lambda", 923, 0 },
	{ "Lcaron", 317, 0 },
	{ "Lstrok", 321, 0 },
	{ "Mu", 924, 0 },
	{ "Nacute", 323, 0 },
	{ "Ncaron", 327, 0 },
	{ "Ntilde", 209, 0 },
	{ "Nu", 925, 0 },
	{ "OElig", 338, 0 },
	{ "Oacute", 211, 0 },
	{ "Ocirc", 212, 0 },
	{ "Odblac", 336, 0 },
	{ "Ograve", 210, 0 },
	{ "Omega", 937, 0 },
	{ "Omicron", 927, 0 },
	{ "Oslash", 216, 0 },
	{ "Otilde", 213, 0 },
	{ "Ouml", 214, 0 },
	{ "Phi", 934, 0 },
	{ "Pi", 928, 0 },
	{ "Prime", 8243, 0 },
	{ "Psi", 936, 0 },
	{ "Racute", 340, 0 },
	{ "Rcaron", 344, 0 },
	{ "Rho", 929, 0 },
	{ "Sacute", 346, 0 },
	{ "Scaron", 352, 0 },
	{ "Scedil", 350, 0 },
	{ "Sigma", 931, 0 },
	{ "THORN", 222, 0 },
	{ "Tau", 932, 0 },
	{ "Tcaron", 356, 0 },
	{ "Tcedil", 354, 0 },
	{ "Theta", 920, 0 },
	{ "Uacute", 218, 0 },
	{ "Ucirc", 219, 0 },
	{ "Udblac", 368, 0 },
	{ "Ugrave", 217, 0 },
	{ "Upsilon", 933, 0 },
	{ "Uring", 366, 0 },
	{ "Uuml", 220, 0 },
	{ "Xi", 926, 0 },
	{ "Yacute", 221, 0 },
	{ "Yuml", 376, 0 },
	{ "Zacute", 377, 0 },
	{ "Zcaron", 381, 0 },
	{ "Zdot", 379, 0 },
	{ "Zeta", 918, 0 },
	{ "aacute", 225, 0 },
	{ "abreve", 259, 0 },
	{ "acirc", 226, 0 },
	{ "acute", 180, 0 },
	{ "aelig", 230, 0 },
	{ "agrave", 224, 0 },
	{ "alefsym", 8501, 0 },
	{ "alpha", 945, 0 },
	{ "amp", '&', 0 },
	{ "and", 8743, 0 },
	{ "ang", 8736, 0 },
	{ "aogon", 261, 0 },
	{ "aring", 229, 0 },
	{ "asymp", 8776, 0 },
	{ "atilde", 227, 0 },
	{ "auml", 228, 0 },
	{ "bdquo", 8222, 0 },
	{ "beta", 946, 0 },
	{ "breve", 728, 0 },
	{ "brvbar", 166, 0 },
	{ "bull", 8226, 0 },
	{ "cacute", 263, 0 },
	{ "cap", 8745, 0 },
	{ "caron", 711, 0 },
	{ "ccaron", 269, 0 },
	{ "ccedil", 231, 0 },
	{ "cedil", 184, 0 },
	{ "cent", 162, 0 },
	{ "chi", 967, 0 },
	{ "circ", 710, 0 },
	{ "clubs", 9827, 0 },
	{ "cong", 8773, 0 },
	{ "copy", 169, 0 },
	{ "crarr", 8629, 0 },
	{ "cup", 8746, 0 },
	{ "curren", 164, 0 },
	{ "dArr", 8659, 0 },
	{ "dagger", 8224, 0 },
	{ "darr", 8595, 0 },
	{ "dblac", 733, 0 },
	{ "dcaron", 271, 0 },
	{ "deg", 176, 0 },
	{ "delta", 948, 0 },
	{ "diams", 9830, 0 },
	{ "divide", 247, 0 },
	{ "dot", 729, 0 },
	{ "dstrok", 273, 0 },
	{ "eacute", 233, 0 },
	{ "ecaron", 283, 0 },
	{ "ecirc", 234, 0 },
	{ "egrave", 232, 0 },
	{ "emdash", 8212, 0 },
	{ "empty", 8709, 0 },
	{ "endash", 8211, 0 },
	{ "eogon", 281, 0 },
	{ "epsilon", 949, 0 },
	{ "equiv", 8801, 0 },
	{ "eta", 951, 0 },
	{ "eth", 240, 0 },
	{ "euml", 235, 0 },
	{ "exist", 8707, 0 },
	{ "fnof", 402, 0 },
	{ "forall", 8704, 0 },
	{ "frac12", 189, 0 },
	{ "frac14", 188, 0 },
	{ "frac34", 190, 0 },
	{ "frasl", 8260, 0 },
	{ "gamma", 947, 0 },
	{ "ge", 8805, 0 },
	{ "gt", '>', 0 },
	{ "hArr", 8660, 0 },
	{ "harr", 8596, 0 },
	{ "hearts", 9829, 0 },
	{ "hellip", 8230, 0 },
	{ "iacute", 237, 0 },
	{ "icirc", 238, 0 },
	{ "iexcl", 161, 0 },
	{ "igrave", 236, 0 },
	{ "image", 8465, 0 },
	{ "infin", 8734, 0 },
	{ "int", 8747, 0 },
	{ "iota", 953, 0 },
	{ "iquest", 191, 0 },
	{ "isin", 8712, 0 },
	{ "iuml", 239, 0 },
	{ "kappa", 954, 0 },
	{ "lArr", 8656, 0 },
	{ "lacute", 314, 0 },
	{ "lambda", 955, 0 },
	{ "lang", 9001, 0 },
	{ "laquo", 171, 0 },
	{ "larr", 8592, 0 },
	{ "lcaron", 318, 0 },
	{ "lceil", 8968, 0 },
	{ "ldq", 8220, 0 },
	{ "ldquo", 8220, 0 },
	{ "le", 8804, 0 },
	{ "lfloor", 8970, 0 },
	{ "lowast", 8727, 0 },
	{ "loz", 9674, 0 },
	{ "lsaquo", 8249, 0 },
	{ "lsq", 8216, 0 },
	{ "lsquo", 8216, 0 },
	{ "lstrok", 322, 0 },
	{ "lt", '<', 0 },
	{ "macr", 175, 0 },
	{ "mdash", 8212, 0 },
	{ "micro", 181, 0 },
	{ "middot", 183, 0 },
	{ "minus", 8722, 0 },
	{ "mu", 956, 0 },
	{ "nabla", 8711, 0 },
	{ "nacute", 324, 0 },
	{ "nbsp", QSPACE, 0 },
	{ "ncaron", 328, 0 },
	{ "ndash", 8211, 0 },
	{ "ne", 8800, 0 },
	{ "ni", 8715, 0 },
	{ "not", 172, 0 },
	{ "notin", 8713, 0 },
	{ "nsub", 8836, 0 },
	{ "ntilde", 241, 0 },
	{ "nu", 957, 0 },
	{ "oacute", 243, 0 },
	{ "ocirc", 244, 0 },
	{ "odblac", 337, 0 },
	{ "oelig", 339, 0 },
	{ "ogon", 731, 0 },
	{ "ograve", 242, 0 },
	{ "oline", 8254, 0 },
	{ "omega", 969, 0 },
	{ "omicron", 959, 0 },
	{ "oplus", 8853, 0 },
	{ "or", 8744, 0 },
	{ "ordf", 170, 0 },
	{ "ordm", 186, 0 },
	{ "oslash", 248, 0 },
	{ "otilde", 245, 0 },
	{ "otimes", 8855, 0 },
	{ "ouml", 246, 0 },
	{ "para", 182, 0 },
	{ "part", 8706, 0 },
	{ "permil", 8240, 0 },
	{ "perp", 8869, 0 },
	{ "phi", 966, 0 },
	{ "pi", 960, 0 },
	{ "piv", 982, 0 },
	{ "plusmn", 177, 0 },
	{ "pound", 163, 0 },
	{ "prime", 8242, 0 },
	{ "prod", 8719, 0 },
	{ "prop", 8733, 0 },
	{ "psi", 968, 0 },
	{ "quot", '"', 0 },
	{ "rArr", 8658, 0 },
	{ "racute", 341, 0 },
	{ "radic", 8730, 0 },
	{ "rang", 9002, 0 },
	{ "raquo", 187, 0 },
	{ "rarr", 8594, 0 },
	{ "rcaron", 345, 0 },
	{ "rceil", 8969, 0 },
	{ "rdq", 8221, 0 },
	{ "rdquo", 8221, 0 },
	{ "real", 8476, 0 },
	{ "reg", 174, 0 },
	{ "rfloor", 8971, 0 },
	{ "rho", 961, 0 },
	{ "rsaquo", 8250, 0 },
	{ "rsq", 8217, 0 },
	{ "rsquo", 8217, 0 },
	{ "sacute", 347, 0 },
	{ "sbquo", 8218, 0 },
	{ "scaron", 353, 0 },
	{ "scedil", 351, 0 },
	{ "sdot", 8901, 0 },
	{ "sect", 167, 0 },
	{ "shy", 173, 0 },
	{ "sigma", 963, 0 },
	{ "sigmaf", 962, 0 },
	{ "sim", 8764, 0 },
	{ "spades", 9824, 0 },
	{ "sub", 8834, 0 },
	{ "sube", 8838, 0 },
	{ "sum", 8721, 0 },
	{ "sup", 8835, 0 },
	{ "sup1", 185, 0 },
	{ "sup2", 178, 0 },
	{ "sup3", 179, 0 },
	{ "supe", 8839, 0 },
	{ "szlig", 223, 0 },
	{ "tau", 964, 0 },
	{ "tcaron", 357, 0 },
	{ "tcedil", 355, 0 },
	{ "there4", 8756, 0 },
	{ "theta", 952, 0 },
	{ "thetasym", 977, 0 },
	{ "thorn", 254, 0 },
	{ "thorn", 254, 0 },
	{ "tilde", 732, 0 },
	{ "times", 215, 0 },
	{ "trade", 8482, 0 },
	{ "uArr", 8657, 0 },
	{ "uacute", 250, 0 },
	{ "uarr", 8593, 0 },
	{ "ucirc", 251, 0 },
	{ "udblac", 369, 0 },
	{ "ugrave", 249, 0 },
	{ "uml", 168, 0 },
	{ "upsih", 978, 0 },
	{ "upsilon", 965, 0 },
	{ "uring", 367, 0 },
	{ "uuml", 252, 0 },
	{ "weierp", 8472, 0 },
	{ "xi", 958, 0 },
	{ "yacute", 253, 0 },
	{ "yen", 165, 0 },
	{ "yuml", 255, 0 },
	{ "zacute", 378, 0 },
	{ "zcaron", 382, 0 },
	{ "zdot", 380, 0 },
	{ "zeta", 950, 0 }
};


/* ------------------------------------------------------------------------ */
/*
 *   turn on CAPS mode for a stream
 */
static void outcaps_stream(out_stream_info *stream)
{
	/* turn on CAPS mode */
	stream->capsflag = TRUE;

	/* turn off NOCAPS and ALLCAPS mode */
	stream->nocapsflag = FALSE;
	stream->allcapsflag = FALSE;
}

/*
 *   turn on NOCAPS mode for a stream
 */
static void outnocaps_stream(out_stream_info *stream)
{
	/* turn on NOCAPS mode */
	stream->nocapsflag = TRUE;

	/* turn off CAPS and ALLCAPS mode */
	stream->capsflag = FALSE;
	stream->allcapsflag = FALSE;
}

/*
 *   turn on or off ALLCAPS mode for a stream
 */
static void outallcaps_stream(out_stream_info *stream, int all_caps)
{
	/* set the ALLCAPS flag */
	stream->allcapsflag = all_caps;

	/* clear the CAPS and NOCAPS flags */
	stream->capsflag = FALSE;
	stream->nocapsflag = FALSE;
}

/* ------------------------------------------------------------------------ */
/*
 *   write a string to a stream
 */
static void stream_print(out_stream_info *stream, char *str)
{
	/* call the stream's do_print method */
	(*stream->do_print)(stream, str);
}

/*
 *   Write out a line
 */
static void t_outline(out_stream_info *stream, int nl,
					  const char *txt, const int *attr)
{
	extern int scrquiet;

	/*
	 *   Check the "script quiet" mode - this indicates that we're reading
	 *   a script and not echoing output to the display.  If this mode is
	 *   on, and we're writing to the display, suppress this write.  If
	 *   the mode is off, or we're writing to another stream (such as the
	 *   log file), show the output as normal.
	 */
	if (!scrquiet || stream != &G_std_disp)
	{
		size_t i;
		char buf[MAXWIDTH];
		char *dst;

		/*
		 *   Check to see if we've reached the end of the screen, and if
		 *   so run the MORE prompt.  Note that we don't make this check
		 *   at all if USE_MORE is undefined, since this means that the OS
		 *   layer code is taking responsibility for pagination issues.
		 *   We also don't display a MORE prompt when reading from a
		 *   script file.
		 *
		 *   Note that we suppress the MORE prompt if nl == 0, since this
		 *   is used to flush a partial line of text without starting a
		 *   new line (for example, when displaying a prompt where the
		 *   input will appear on the same line following the prompt).
		 *
		 *   Skip the MORE prompt if this stream doesn't use it.
		 */
		if (stream->use_more_mode
			&& scrfp == 0
			&& G_os_moremode
			&& nl != 0 && nl != 4
			&& stream->linecnt++ >= G_os_pagelength)
		{
			/* display the MORE prompt */
			out_more_prompt();
		}

		/*
		 *   Display the text.  Run through the text in pieces; each time the
		 *   attributes change, set attributes at the osifc level.
		 */
		for (i = 0, dst = buf ; txt[i] != '\0' ; ++i)
		{
			/* if the attribute is changing, notify osifc */
			if (attr != 0 && attr[i] != stream->os_attr)
			{
				/* flush the preceding text */
				if (dst != buf)
				{
					*dst = '\0';
					stream_print(stream, buf);
				}

				/* set the new attribute */
				os_set_text_attr(attr[i]);

				/* remember this as the last OS attribute */
				stream->os_attr = attr[i];

				/* start with a fresh buffer */
				dst = buf;
			}

			/* buffer this character */
			*dst++ = txt[i];
		}

		/* flush the last chunk of text */
		if (dst != buf)
		{
			*dst = '\0';
			stream_print(stream, buf);
		}
	}
}

/* ------------------------------------------------------------------------ */
/*
 *   Flush the current line to the display.  The 'nl' argument specifies
 *   what kind of flushing to do:
 *
 *   0: flush the current line but do not start a new line; more text will
 *   follow on the current line.  This is used, for example, to flush text
 *   after displaying a prompt and before waiting for user input.
 *
 *   1: flush the line and start a new line.
 *
 *   2: flush the line as though starting a new line, but don't add an
 *   actual newline character to the output, since the underlying OS
 *   display code will handle this.  Instead, add a space after the line.
 *   (This differs from mode 0 in that mode 0 shouldn't add anything at
 *   all after the line.)
 *
 *   3: "preview" mode.  Flush the line, but do not start a new line, and
 *   retain the current text in the buffer.  This is used for systems that
 *   handle the line wrapping in the underlying system code to flush a
 *   partially filled line that will need to be flushed again later.
 *
 *   4: same as mode 0, but used for internal buffer flushes only.  Do not
 *   involve the underlying OS layer in this type of flush - simply flush
 *   our buffers with no separation.
 */

/* flush a given output stream */
static void outflushn_stream(out_stream_info *stream, int nl)
{
	int i;

	/* null-terminate the current output line buffer */
	stream->linebuf[stream->linepos] = '\0';

	/* note the position of the last character to display */
	i = stream->linepos - 1;

	/* if we're adding anything, remove trailing spaces */
	if (nl != 0 && nl != 4)
	{
		/* look for last non-space character */
		for ( ; i >= 0 && outissp(stream->linebuf[i]) ; --i) ;
	}

	/* check the output mode */
	if (nl == 3)
	{
		/*
		 *   this is the special "preview" mode -- only display the part
		 *   that we haven't already previewed for this same line
		 */
		if (i + 1 > stream->preview)
		{
			/* write out the line */
			t_outline(stream, 0, &stream->linebuf[stream->preview],
					  &stream->attrbuf[stream->preview]);

			/* skip past the part we wrote */
			stream->preview += strlen(&stream->linebuf[stream->preview]);
		}
	}
	else
	{
		const char *suffix = nullptr; /* extra text to add after the flushed text */
		int   countnl = 0;               /* true if line counts for [more] paging */

		/* null-terminate the buffer at the current position */
		stream->linebuf[++i] = '\0';

		/* check the mode */
		switch(nl)
		{
		case 0:
		case 3:
		case 4:
			/* no newline - just flush out what we have with no suffix */
			suffix = 0;
			break;

		case 1:
			/*
			 *   Add a newline.  If there's nothing in the current line,
			 *   or we just wrote out a newline, do not add an extra
			 *   newline.  Keep all newlines in PRE mode.
			 */
			if (stream->linecol != 0 || !stream->just_did_nl
				|| stream->html_pre_level != 0)
			{
				/* add a newline after the text */
				suffix = "\n";

				/* count the line in the page size */
				countnl = 1;
			}
			else
			{
				/* don't add a newline */
				suffix = 0;
			}
			break;

		case 2:
			/*
			 *   we're going to depend on the underlying OS output layer
			 *   to do line breaking, so don't add a newline, but do add a
			 *   space, so that the underlying OS layer knows we have a
			 *   word break here
			 */
			suffix = " ";
			break;
		}

		/*
		 *   display the line, as long as we have something buffered to
		 *   display; even if we don't, display it if our column is
		 *   non-zero and we didn't just do a newline, since this must
		 *   mean that we've flushed a partial line and are just now doing
		 *   the newline
		 */
		if (stream->linebuf[stream->preview] != '\0'
			|| (stream->linecol != 0 && !stream->just_did_nl)
			|| stream->html_pre_level > 0)
		{
			/* write it out */
			t_outline(stream, countnl, &stream->linebuf[stream->preview],
					  &stream->attrbuf[stream->preview]);

			/* write the suffix, if any */
			if (suffix != 0)
				t_outline(stream, 0, suffix, 0);
		}

		/* generate an HTML line break if necessary */
		if (nl == 1 && stream->html_mode && stream->html_target)
			t_outline(stream, 0, "<BR HEIGHT=0>", 0);

		if (nl == 0)
		{
			/* we're not displaying a newline, so flush what we have */
			os_flush();
		}
		else
		{
			/* we displayed a newline, so reset the column position */
			stream->linecol = 0;
		}

		/* reset the line output buffer position */
		stream->linepos = stream->preview = 0;

		/*
		 *   If we just output a newline, note it.  If we didn't just
		 *   output a newline, but we did write out anything else, note
		 *   that we're no longer at the start of a line on the underlying
		 *   output device.
		 */
		if (nl == 1)
			stream->just_did_nl = TRUE;
		else if (stream->linebuf[stream->preview] != '\0')
			stream->just_did_nl = FALSE;
	}

	/*
	 *   If the osifc-level attributes don't match the current attributes,
	 *   bring the osifc layer up to date.  This is necessary in cases where
	 *   we set attributes immediately before asking for input - we
	 *   essentially need to flush the attributes without flushing any text.
	 */
	if (stream->cur_attr != stream->os_attr)
	{
		/* set the osifc attributes */
		os_set_text_attr(stream->cur_attr);

		/* remember the new attributes as the current osifc attributes */
		stream->os_attr = stream->cur_attr;
	}
}

/* ------------------------------------------------------------------------ */
/*
 *   Determine if we're showing output.  Returns true if output should be
 *   displayed, false if it should be suppressed.  We'll note the output
 *   for hidden display accounting as needed.
 */
static int out_is_hidden()
{
	/* check the output flag */
	if (!outflag)
	{
		/* trace the hidden output if desired */
		if (dbghid && !hidout)
			trchid();

		/* note the hidden output */
		hidout = 1;

		/*
		 *   unless we're showing hidden text in the debugger, we're
		 *   suppressing output, so return true
		 */
		if (!dbghid)
			return TRUE;
	}

	/* we're not suppressing output */
	return FALSE;
}

/* ------------------------------------------------------------------------ */
/*
 *   Display a blank line to the given stream
 */
static void outblank_stream(out_stream_info *stream)
{
	/* flush the stream */
	outflushn_stream(stream, 1);

	/* if generating for an HTML display target, add an HTML line break */
	if (stream->html_mode && stream->html_target)
		outstring_stream(stream, "<BR>");

	/* write out the newline */
	t_outline(stream, 1, "\n", 0);
}

/* ------------------------------------------------------------------------ */
/*
 *   Generate a tab for a "\t" sequence in the game text.
 *
 *   Standard (non-HTML) version: we'll generate enough spaces to take us
 *   to the next tab stop.
 *
 *   HTML version: if we're in native HTML mode, we'll just generate a
 *   <TAB MULTIPLE=4>; if we're not in HTML mode, we'll generate a hard
 *   tab character, which the HTML formatter will interpret as a <TAB
 *   MULTIPLE=4>.
 */
static void outtab_stream(out_stream_info *stream)
{
	/* check to see what the underlying system is expecting */
	if (stream->html_target)
	{
		/* the underlying system is HTML - check for HTML mode */
		if (stream->html_mode)
		{
			/* we're in HTML mode, so use the HTML <TAB> tag */
			outstring_stream(stream, "<TAB MULTIPLE=4>");
		}
		else
		{
			/* we're not in HTML mode, so generate a hard tab character */
			outchar_noxlat_stream(stream, QTAB);
		}
	}
	else
	{
		int maxcol;

		/*
		 *   We're not in HTML mode - expand the tab with spaces.  Figure
		 *   the maximum column: if we're doing our own line wrapping, never
		 *   go beyond the actual display width.
		 */
		maxcol = (stream->os_line_wrap ? OS_MAXWIDTH : G_os_linewidth);

		/* add the spaces */
		do
		{
			stream->attrbuf[stream->linepos] = stream->cur_attr;
			stream->linebuf[stream->linepos++] = ' ';
			++(stream->linecol);
		} while (((stream->linecol + 1) & 3) != 0
				 && stream->linecol < maxcol);
	}
}


/* ------------------------------------------------------------------------ */
/*
 *   Flush a line
 */
static void out_flushline(out_stream_info *stream, int padding)
{
	/*
	 *   check to see if we're using the underlying display layer's line
	 *   wrapping
	 */
	if (stream->os_line_wrap)
	{
		/*
		 *   In the HTML version, we don't need the normal *MORE*
		 *   processing, since the HTML layer will handle that.
		 *   Furthermore, we don't need to provide actual newline breaks
		 *   -- that happens after the HTML is parsed, so we don't have
		 *   enough information here to figure out actual line breaks.
		 *   So, we'll just flush out our buffer whenever it fills up, and
		 *   suppress newlines.
		 *
		 *   Similarly, if we have OS-level MORE processing, don't try to
		 *   figure out where the line breaks go -- just flush our buffer
		 *   without a trailing newline whenever the buffer is full, and
		 *   let the OS layer worry about formatting lines and paragraphs.
		 *
		 *   If we're using padding, use mode 2.  If we don't want padding
		 *   (which is the case if we completely fill up the buffer
		 *   without finding any word breaks), write out in mode 0, which
		 *   just flushes the buffer exactly like it is.
		 */
		outflushn_stream(stream, padding ? 2 : 4);
	}
	else
	{
		/*
		 *   Normal mode - we process the *MORE* prompt ourselves, and we
		 *   are responsible for figuring out where the actual line breaks
		 *   go.  Use outflush() to generate an actual newline whenever we
		 *   flush out our buffer.
		 */
		outflushn_stream(stream, 1);
	}
}


/* ------------------------------------------------------------------------ */
/*
 *   Write a character to an output stream without translation
 */
static void outchar_noxlat_stream(out_stream_info *stream, char c)
{
	int  i;
	int  qspace;

	/* check for the special quoted space character */
	if (c == QSPACE)
	{
		/* it's a quoted space - note it and convert it to a regular space */
		qspace = 1;
		c = ' ';
	}
	else if (c == QTAB)
	{
		/* it's a hard tab - convert it to an ordinary tab */
		c = '\t';
		qspace = 0;
	}
	else
	{
		/* translate any whitespace character to a regular space character */
		if (outissp(c))
			c = ' ';

		/* it's not a quoted space */
		qspace = 0;
	}

	/* check for the caps/nocaps flags */
	if ((stream->capsflag || stream->allcapsflag) && outisal(c))
	{
		/* capsflag is set, so capitalize this character */
		if (outislo(c))
			c = toupper(c);

		/* okay, we've capitalized something; clear flag */
		stream->capsflag = 0;
	}
	else if (stream->nocapsflag && outisal(c))
	{
		/* nocapsflag is set, so minisculize this character */
		if (outisup(c))
			c = tolower(c);

		/* clear the flag now that we've done the job */
		stream->nocapsflag = 0;
	}

	/* if in capture mode, simply capture the character */
	if (stream->capturing)
	{
		uchar *p;

		/* if we have a valid capture object, copy to it */
		if (stream->capture_obj != MCMONINV)
		{
			/* lock the object holding the captured text */
			p = mcmlck(stream->capture_ctx, stream->capture_obj);

			/* make sure the capture object is big enough */
			if (mcmobjsiz(stream->capture_ctx, stream->capture_obj)
				<= stream->capture_ofs)
			{
				/* expand the object by another 256 bytes */
				p = mcmrealo(stream->capture_ctx, stream->capture_obj,
							 (ushort)(stream->capture_ofs + 256));
			}

			/* add this character */
			*(p + stream->capture_ofs++) = c;

			/* unlock the capture object */
			mcmtch(stream->capture_ctx, stream->capture_obj);
			mcmunlck(stream->capture_ctx, stream->capture_obj);
		}

		/*
		 *   we're done - we don't want to actually display the character
		 *   while capturing
		 */
		return;
	}

	/* add the character to out output buffer, flushing as needed */
	if (stream->linecol + 1 < G_os_linewidth)
	{
		/*
		 *   there's room for this character, so add it to the buffer
		 */

		/* ignore non-quoted space at start of line outside of PRE */
		if (outissp(c) && c != '\t' && stream->linecol == 0 && !qspace
			&& stream->html_pre_level == 0)
			return;

		/* is this a non-quoted space not at the start of the line? */
		if (outissp(c) && c != '\t' && stream->linecol != 0 && !qspace
			&& stream->html_pre_level == 0)
		{
			int  pos1 = stream->linepos - 1;
			char p = stream->linebuf[pos1];     /* check previous character */

			/* ignore repeated spaces - collapse into a single space */
			if (outissp(p))
				return;

			/*
			 *   Certain punctuation requires a double space: a period, a
			 *   question mark, an exclamation mark, or a colon; or any of
			 *   these characters followed by any number of single and/or
			 *   double quotes.  First, scan back to before any quotes, if
			 *   are on one now, then check the preceding character; if
			 *   it's one of the punctuation marks requiring a double
			 *   space, add this space a second time.  (In addition to
			 *   scanning back past quotes, scan past parentheses,
			 *   brackets, and braces.)  Don't double the spacing if we're
			 *   not in the normal doublespace mode; some people may
			 *   prefer single spacing after punctuation, so we make this
			 *   a run-time option.
			 */
			if (doublespace)
			{
				/* find the previous relevant punctuation character */
				while (pos1 &&
					   (p == '"' || p == '\'' || p == ')' || p == ']'
						|| p == '}'))
				{
					p = stream->linebuf[--pos1];
				}
				if ( p == '.' || p == '?' || p == '!' || p == ':' )
				{
					/* a double-space is required after this character */
					stream->attrbuf[stream->linepos] = stream->cur_attr;
					stream->linebuf[stream->linepos++] = c;
					++(stream->linecol);
				}
			}
		}

		/* add this character to the buffer */
		stream->attrbuf[stream->linepos] = stream->cur_attr;
		stream->linebuf[stream->linepos++] = c;

		/* advance the output column position */
		++(stream->linecol);
		return;
	}

	/*
	 *   The line would overflow if this character were added.  Find the
	 *   most recent word break, and output the line up to the previous
	 *   word.  Note that if we're trying to output a space, we'll just
	 *   add it to the line buffer.  If the last character of the line
	 *   buffer is already a space, we won't do anything right now.
	 */
	if (outissp(c) && c != '\t' && !qspace)
	{
		/* this is a space, so we're at a word break */
		if (stream->linebuf[stream->linepos - 1] != ' ')
		{
			stream->attrbuf[stream->linepos] = stream->cur_attr;
			stream->linebuf[stream->linepos++] = ' ';
		}
		return;
	}

	/*
	 *   Find the most recent word break: look for a space or dash, starting
	 *   at the end of the line.
	 *
	 *   If we're about to write a hyphen, we want to skip all contiguous
	 *   hyphens, because we want to keep them together as a single
	 *   punctuation mark; then keep going in the normal manner, which will
	 *   keep the hyphens plus the word they're attached to together as a
	 *   single unit.  If spaces precede the sequence of hyphens, include
	 *   the prior word as well.
	 */
	i = stream->linepos - 1;
	if (c == '-')
	{
		/* skip any contiguous hyphens at the end of the line */
		for ( ; i >= 0 && stream->linebuf[i] == '-' ; --i) ;

		/* skip any spaces preceding the sequence of hyphens */
		for ( ; i >= 0 && outissp(stream->linebuf[i]) ; --i) ;
	}

	/*
	 *   Now find the preceding space.  If we're doing our own wrapping
	 *   (i.e., we're not using OS line wrapping), then look for the
	 *   nearest hyphen as well.
	 */
	for ( ; i >= 0 && !outissp(stream->linebuf[i])
		  && !(!stream->os_line_wrap && stream->linebuf[i] == '-') ; --i) ;

	/* check to see if we found a good place to break */
	if (i < 0)
	{
		/*
		 *   we didn't find any good place to break - flush the entire
		 *   line as-is, breaking arbitrarily in the middle of a word
		 */
		out_flushline(stream, FALSE);

		/*
		 *   we've completely cleared out the line buffer, so reset all of
		 *   the line buffer counters
		 */
		stream->linepos = 0;
		stream->linecol = 0;
		stream->linebuf[0] = '\0';
	}
	else
	{
		char brkchar;
		char tmpbuf[MAXWIDTH];
		int tmpattr[MAXWIDTH];
		size_t tmpcnt;

		/* remember the word-break character */
		brkchar = stream->linebuf[i];

		/* null-terminate the line buffer */
		stream->linebuf[stream->linepos] = '\0';

		/* the next line starts after the break - save a copy */
		tmpcnt = strlen(&stream->linebuf[i+1]);
		memcpy(tmpbuf, &stream->linebuf[i+1], tmpcnt + 1);
		memcpy(tmpattr, &stream->attrbuf[i+1], tmpcnt * sizeof(tmpattr[0]));

		/*
		 *   terminate the buffer at the space or after the hyphen,
		 *   depending on where we broke
		 */
		if (outissp(brkchar))
			stream->linebuf[i] = '\0';
		else
			stream->linebuf[i+1] = '\0';

		/* write out everything up to the word break */
		out_flushline(stream, TRUE);

		/* copy the next line into line buffer */
		memcpy(stream->linebuf, tmpbuf, tmpcnt + 1);
		memcpy(stream->attrbuf, tmpattr, tmpcnt * sizeof(tmpattr[0]));
		stream->linepos = tmpcnt;

		/*
		 *   figure what column we're now in - count all of the printable
		 *   characters in the new line
		 */
		for (stream->linecol = 0, i = 0 ; i < stream->linepos ; ++i)
		{
			/* if it's printable, count it */
			if (((unsigned char)stream->linebuf[i]) >= 26)
				++(stream->linecol);
		}
	}

	/* add the new character to buffer */
	stream->attrbuf[stream->linepos] = stream->cur_attr;
	stream->linebuf[stream->linepos++] = c;

	/* advance the column counter */
	++(stream->linecol);
}

/* ------------------------------------------------------------------------ */
/*
 *   Write out a character, translating to the local system character set
 *   from the game's internal character set.
 */
static void outchar_stream(out_stream_info *stream, char c)
{
	outchar_noxlat_stream(stream, cmap_i2n(c));
}

/*
 *   write out a string, translating to the local system character set
 */
static void outstring_stream(out_stream_info *stream, const char *s)
{
	/* write out each character in the string */
	for ( ; *s ; ++s)
		outchar_stream(stream, *s);
}

/*
 *   write out a string without translation
 */
static void outstring_noxlat_stream(out_stream_info *stream, char *s)
{
	for ( ; *s ; ++s)
		outchar_noxlat_stream(stream, *s);
}


/* ------------------------------------------------------------------------ */
/*
 *   Write out an HTML character value, translating to the local character
 *   set.
 */
static void outchar_html_stream(out_stream_info *stream,
								unsigned int htmlchar)
{
	amp_tbl_t *ampptr;

	/*
	 *   search for a mapping entry for this entity, in case it's defined
	 *   in an external mapping file
	 */
	for (ampptr = amp_tbl ;
		 ampptr < amp_tbl + sizeof(amp_tbl)/sizeof(amp_tbl[0]) ; ++ampptr)
	{
		/* if this is the one, stop looking */
		if (ampptr->html_cval == htmlchar)
			break;
	}

	/*
	 *   If we found a mapping table entry, and the entry has an expansion
	 *   from the external character mapping table file, use the external
	 *   expansion; otherwise, use the default expansion.
	 */
	if (ampptr >= amp_tbl + sizeof(amp_tbl)/sizeof(amp_tbl[0])
		|| ampptr->expan == 0)
	{
		char xlat_buf[50];

		/*
		 *   there's no external mapping table file expansion -- use the
		 *   default OS mapping routine
		 */
		os_xlat_html4(htmlchar, xlat_buf, sizeof(xlat_buf));
		outstring_noxlat_stream(stream, xlat_buf);
	}
	else
	{
		/*
		 *   use the explicit mapping from the mapping table file
		 */
		outstring_noxlat_stream(stream, ampptr->expan);
	}
}


/* ------------------------------------------------------------------------ */
/*
 *   Enter a recursion level.  Returns TRUE if the caller should proceed
 *   with the operation, FALSE if not.
 *
 *   If we're making a recursive call, thereby re-entering the formatter,
 *   and this stream is not the same as the enclosing stream, we want to
 *   ignore this call and suppress any output to this stream, so we'll
 *   return FALSE.
 */
static int out_push_stream(out_stream_info *stream)
{
	/*
	 *   if we're already in the formatter, and the new stream doesn't
	 *   match the enclosing recursion level's stream, tell the caller to
	 *   abort the operation
	 */
	if (G_recurse != 0 && G_cur_stream != stream)
		return FALSE;

	/* note the active stream */
	G_cur_stream = stream;

	/* count the entry */
	++G_recurse;

	/* tell the caller to proceed */
	return TRUE;
}

/*
 *   Leave a recursion level
 */
static void out_pop_stream()
{
	/* count the exit */
	--G_recurse;
}

/* ------------------------------------------------------------------------ */
/*
 *   nextout() returns the next character in a string, and updates the
 *   string pointer and remaining length.  Returns zero if no more
 *   characters are available in the string.
 */
/* static char nextout(char **s, uint *len); */
#define nextout(s, len) ((char)(*(len) == 0 ? 0 : (--(*(len)), *((*(s))++))))


/* ------------------------------------------------------------------------ */
/*
 *   Get the next character, writing the previous character to the given
 *   output stream if it's not null.
 */
static char nextout_copy(const char **s, size_t *slen,
						 char prv, out_stream_info *stream)
{
	/* if there's a stream, write the previous character to the stream */
	if (stream != 0)
		outchar_stream(stream, prv);

	/* return the next character */
	return nextout(s, slen);
}

/* ------------------------------------------------------------------------ */
/*
 *   Read an HTML tag, for our primitive mini-parser.  If 'stream' is not
 *   null, we'll copy each character we read to the output stream.  Returns
 *   the next character after the tag name.
 */
static char read_tag(char *dst, size_t dstlen, int *is_end_tag,
					 const char **s, size_t *slen, out_stream_info *stream)
{
	char c;

	/* skip the opening '<' */
	c = nextout_copy(s, slen, '<', stream);

	/* skip spaces */
	while (outissp(c))
		c = nextout_copy(s, slen, c, stream);

	/* note if this is a closing tag */
	if (c == '/' || c == '\\')
	{
		/* it's an end tag - note it and skip the slash */
		*is_end_tag = TRUE;
		c = nextout_copy(s, slen, c, stream);

		/* skip yet more spaces */
		while (outissp(c))
			c = nextout_copy(s, slen, c, stream);
	}
	else
		*is_end_tag = FALSE;

	/*
	 *   find the end of the tag name - the tag continues to the next space,
	 *   '>', or end of line
	 */
	for ( ; c != '\0' && !outissp(c) && c != '>' ;
		 c = nextout_copy(s, slen, c, stream))
	{
		/* add this to the tag buffer if it fits */
		if (dstlen > 1)
		{
			*dst++ = c;
			--dstlen;
		}
	}

	/* null-terminate the tag name */
	if (dstlen > 0)
		*dst = '\0';

	/* return the next character */
	return c;
}


/* ------------------------------------------------------------------------ */
/*
 *   display a string of a given length to a given stream
 */
static int outformatlen_stream(out_stream_info *stream,
							   const char *s, size_t slen)
{
	char     c;
	int      done = 0;
	char     fmsbuf[40];       /* space for constructing translation string */
	uint     fmslen;
	char    *f = 0;
	char    *f1;
	int      infmt = 0;

	/*
	 *   This routine can recurse because of format strings ("%xxx%"
	 *   sequences).  When we recurse, we want to ensure that the
	 *   recursion is directed to the original stream only.  So, note the
	 *   current stream statically in case we re-enter the formatter.
	 */
	if (!out_push_stream(stream))
		return 0;

	/* get the first character */
	c = nextout(&s, &slen);

	/* if we have anything to show, show it */
	while (c != '\0')
	{
		/* check if we're collecting translation string */
		if (infmt)
		{
			/*
			 *   if the string is too long for our buffer, or we've come
			 *   across a backslash (illegal in a format string), or we've
			 *   come across an HTML-significant character ('&' or '<') in
			 *   HTML mode, we must have a stray percent sign; dump the
			 *   whole string so far and act as though we have no format
			 *   string
			 */
			if (c == '\\'
				|| f == &fmsbuf[sizeof(fmsbuf)]
				|| (stream->html_mode && (c == '<' || c == '&')))
			{
				outchar_stream(stream, '%');
				for (f1 = fmsbuf ; f1 < f ; ++f1)
					outchar_stream(stream, *f1);
				infmt = 0;

				/* process this character again */
				continue;
			}
			else if (c == '%' && f == fmsbuf)       /* double percent sign? */
			{
				outchar_stream(stream, '%');       /* send out a single '%' */
				infmt = 0;       /* no longer processing translation string */
			}
			else if (c == '%')   /* found end of string? translate it if so */
			{
				uchar *fms;
				int    initcap = FALSE;
				int    allcaps = FALSE;
				char   fmsbuf_srch[sizeof(fmsbuf)];

				/* null-terminate the string */
				*f = '\0';

				/* check for an init cap */
				if (outisup(fmsbuf[0]))
				{
					/*
					 *   note the initial capital, so that we follow the
					 *   original capitalization in the substituted string
					 */
					initcap = TRUE;

					/*
					 *   if the second letter is capitalized as well,
					 *   capitalize the entire substituted string
					 */
					if (fmsbuf[1] != '\0' && outisup(fmsbuf[1]))
					{
						/* use all caps */
						allcaps = TRUE;
					}
				}

				/* convert the entire string to lower case for searching */
				strcpy(fmsbuf_srch, fmsbuf);
				os_strlwr(fmsbuf_srch);

				/* find the string in the format string table */
				fmslen = strlen(fmsbuf_srch);
				for (fms = fmsbase ; fms < fmstop ; )
				{
					uint propnum;
					uint len;

					/* get the information on this entry */
					propnum = osrp2(fms);
					len = osrp2(fms + 2) - 2;

					/* check for a match */
					if (len == fmslen &&
						!memcmp(fms + 4, fmsbuf_srch, (size_t)len))
					{
						int old_all_caps;

						/* note the current ALLCAPS mode */
						old_all_caps = stream->allcapsflag;

						/*
						 *   we have a match - set the appropriate
						 *   capitalization mode
						 */
						if (allcaps)
							outallcaps_stream(stream, TRUE);
						else if (initcap)
							outcaps_stream(stream);

						/*
						 *   evaluate the associated property to generate
						 *   the substitution text
						 */
						runppr(runctx, cmdActor, (prpnum)propnum, 0);

						/* turn off ALLCAPS mode */
						outallcaps_stream(stream, old_all_caps);

						/* no need to look any further */
						break;
					}

					/* move on to next formatstring if not yet found */
					fms += len + 4;
				}

				/* if we can't find it, dump the format string as-is */
				if (fms == fmstop)
				{
					outchar_stream(stream, '%');
					for (f1 = fmsbuf ; f1 < f ; ++f1)
						outchar_stream(stream, *f1);
					outchar_stream(stream, '%');
				}

				/* no longer reading format string */
				infmt = 0;
			}
			else
			{
				/* copy this character of the format string */
				*f++ = c;
			}

			/* move on to the next character and continue scanning */
			c = nextout(&s, &slen);
			continue;
		}

		/*
		 *   If we're parsing HTML here, and we're inside a tag, skip
		 *   characters until we reach the end of the tag.
		 */
		if (stream->html_mode_flag != HTML_MODE_NORMAL)
		{
			switch(stream->html_mode_flag)
			{
			case HTML_MODE_TAG:
				/*
				 *   keep skipping up to the closing '>', but note when we
				 *   enter any quoted section
				 */
				switch(c)
				{
				case '>':
					/* we've reached the end of the tag */
					stream->html_mode_flag = HTML_MODE_NORMAL;

					/* if we have a deferred <BR>, process it now */
					switch(stream->html_defer_br)
					{
					case HTML_DEFER_BR_NONE:
						/* no deferred <BR> */
						break;

					case HTML_DEFER_BR_FLUSH:
						outflushn_stream(stream, 1);
						break;

					case HTML_DEFER_BR_BLANK:
						outblank_stream(stream);
						break;
					}

					/* no more deferred <BR> pending */
					stream->html_defer_br = HTML_DEFER_BR_NONE;

					/* no more ALT attribute allowed */
					stream->html_allow_alt = FALSE;
					break;

				case '"':
					/* enter a double-quoted string */
					stream->html_mode_flag = HTML_MODE_DQUOTE;
					break;

				case '\'':
					/* enter a single-quoted string */
					stream->html_mode_flag = HTML_MODE_SQUOTE;
					break;

				default:
					/* if it's alphabetic, note the attribute name */
					if (outisal(c))
					{
						char attrname[128];
						char attrval[256];
						char *dst;

						/* gather up the attribute name */
						for (dst = attrname ;
							 dst + 1 < attrname + sizeof(attrname) ; )
						{
							/* store this character */
							*dst++ = c;

							/* get the next character */
							c = nextout(&s, &slen);

							/* if it's not alphanumeric, stop scanning */
							if (!outisal(c) && !outisdg(c))
								break;
						}

						/* null-terminate the result */
						*dst++ = '\0';

						/* gather the value if present */
						if (c == '=')
						{
							char qu;

							/* skip the '=' */
							c = nextout(&s, &slen);

							/* if we have a quote, so note */
							if (c == '"' || c == '\'')
							{
								/* remember the quote */
								qu = c;

								/* skip it */
								c = nextout(&s, &slen);
							}
							else
							{
								/* no quote */
								qu = 0;
							}

							/* read the value */
							for (dst = attrval ;
								 dst + 1 < attrval + sizeof(attrval) ; )
							{
								/* store this character */
								*dst++ = c;

								/* read the next one */
								c = nextout(&s, &slen);
								if (c == '\0')
								{
									/*
									 *   we've reached the end of the
									 *   string, and we're still inside
									 *   this attribute - abandon the
									 *   attribute but note that we're
									 *   inside a quoted string if
									 *   necessary
									 */
									if (qu == '"')
										stream->html_mode_flag =
											HTML_MODE_DQUOTE;
									else if (qu == '\'')
										stream->html_mode_flag =
											HTML_MODE_SQUOTE;
									else
										stream->html_mode_flag
											= HTML_MODE_TAG;

									/* stop scanning the string */
									break;
								}

								/*
								 *   if we're looking for a quote, check
								 *   for the closing quote; otherwise,
								 *   check for alphanumerics
								 */
								if (qu != 0)
								{
									/* if this is our quote, stop scanning */
									if (c == qu)
										break;
								}
								else
								{
									/* if it's non-alphanumeric, we're done */
									if (!outisal(c) && !outisdg(c))
										break;
								}
							}

							/* skip the closing quote, if necessary */
							if (qu != 0 && c == qu)
								c = nextout(&s, &slen);

							/* null-terminate the value string */
							*dst = '\0';
						}
						else
						{
							/* no value */
							attrval[0] = '\0';
						}

						/*
						 *   see if we recognize it, and it's meaningful
						 *   in the context of the current tag
						 */
						if (!scumm_stricmp(attrname, "height")
							&& stream->html_defer_br != HTML_DEFER_BR_NONE)
						{
							int ht;

							/*
							 *   If the height is zero, always treat this
							 *   as a non-blanking flush.  If it's one,
							 *   treat it as we originally planned to.  If
							 *   it's greater than one, add n blank lines.
							 */
							ht = atoi(attrval);
							if (ht == 0)
							{
								/* always use non-blanking flush */
								stream->html_defer_br = HTML_DEFER_BR_FLUSH;
							}
							else if (ht == 1)
							{
								/* keep original setting */
							}
							else
							{
								for ( ; ht > 0 ; --ht)
									outblank_stream(stream);
							}
						}
						else if (!scumm_stricmp(attrname, "alt")
								 && !stream->html_in_ignore
								 && stream->html_allow_alt)
						{
							/* write out the ALT string */
							outstring_stream(stream, attrval);
						}

						/*
						 *   since we already read the next character,
						 *   simply loop back immediately
						 */
						continue;
					}
					break;
				}
				break;

			case HTML_MODE_DQUOTE:
				/* if we've reached the closing quote, return to tag state */
				if (c == '"')
					stream->html_mode_flag = HTML_MODE_TAG;
				break;

			case HTML_MODE_SQUOTE:
				/* if we've reached the closing quote, return to tag state */
				if (c == '\'')
					stream->html_mode_flag = HTML_MODE_TAG;
				break;
			}

			/*
			 *   move on to the next character, and start over with the
			 *   new character
			 */
			c = nextout(&s, &slen);
			continue;
		}

		/*
		 *   If we're in a title, and this isn't the start of a new tag,
		 *   skip the character - we suppress all regular text output
		 *   inside a <TITLE> ... </TITLE> sequence.
		 */
		if (stream->html_in_ignore && c != '<')
		{
			/* check for entities */
			char cbuf[50];
			if (c == '&')
			{
				/* translate the entity */
				c = out_parse_entity(cbuf, sizeof(cbuf), &s, &slen);
			}
			else
			{
				/* it's an ordinary character - copy it out literally */
				cbuf[0] = c;
				cbuf[1] = '\0';

				/* get the next character */
				c = nextout(&s, &slen);
			}

			/*
			 *   if we're gathering a title, and there's room in the title
			 *   buffer for more (always leaving room for a null
			 *   terminator), add this to the title buffer
			 */
			if (stream->html_in_title)
			{
				char *cbp;
				for (cbp = cbuf ; *cbp != '\0' ; ++cbp)
				{
					/* if there's room, add it */
					if (stream->html_title_ptr + 1 <
						stream->html_title_buf
						+ sizeof(stream->html_title_buf))
						*stream->html_title_ptr++ = *cbp;
				}
			}

			/* don't display anything in an ignore section */
			continue;
		}

		if ( c == '%' )                              /* translation string? */
		{
			infmt = 1;
			f = fmsbuf;
		}
		else if ( c == '\\' )                       /* special escape code? */
		{
			c = nextout(&s, &slen);

			if (stream->capturing && c != '^' && c != 'v' && c != '\0')
			{
				outchar_stream(stream, '\\');
				outchar_stream(stream, c);

				/* keep the \- and also put out the next two chars */
				if (c == '-')
				{
					outchar_stream(stream, nextout(&s, &slen));
					outchar_stream(stream, nextout(&s, &slen));
				}
			}
			else
			{
				switch(c)
				{
				case 'H':                                /* HTML mode entry */
					/* turn on HTML mode in the renderer */
					switch(c = nextout(&s, &slen))
					{
					case '-':
						/* if we have an HTML target, notify it */
						if (stream->html_target)
						{
							/* flush its stream */
							outflushn_stream(stream, 0);

							/* tell the OS layer to switch to normal mode */
							out_end_html(stream);
						}

						/* switch to normal mode */
						stream->html_mode = FALSE;
						break;

					case '+':
					default:
						/* if we have an HTML target, notify it */
						if (stream->html_target)
						{
							/* flush the underlying stream */
							outflushn_stream(stream, 0);

							/* tell the OS layer to switch to HTML mode */
							out_start_html(stream);
						}

						/* switch to HTML mode */
						stream->html_mode = TRUE;

						/*
						 *   if the character wasn't a "+", it's not part
						 *   of the "\H" sequence, so display it normally
						 */
						if (c != '+' && c != 0)
							outchar_stream(stream, c);
						break;
					}

					/* this sequence doesn't result in any actual output */
					break;

				case 'n':                                       /* newline? */
					outflushn_stream(stream, 1);        /* yes, output line */
					break;

				case 't':                                           /* tab? */
					outtab_stream(stream);
					break;

				case 'b':                                    /* blank line? */
					outblank_stream(stream);
					break;

				case '\0':                               /* line ends here? */
					done = 1;
					break;

				case ' ':                                   /* quoted space */
					if (stream->html_target && stream->html_mode)
					{
						/*
						 *   we're generating for an HTML target and we're
						 *   in HTML mode - generate the HTML non-breaking
						 *   space
						 */
						outstring_stream(stream, "&nbsp;");
					}
					else
					{
						/*
						 *   we're not in HTML mode - generate our
						 *   internal quoted space character
						 */
						outchar_stream(stream, QSPACE);
					}
					break;

				case '^':                      /* capitalize next character */
					stream->capsflag = 1;
					stream->nocapsflag = 0;
					break;

				case 'v':
					stream->nocapsflag = 1;
					stream->capsflag = 0;
					break;

				case '(':
					/* generate HTML if in the appropriate mode */
					if (stream->html_mode && stream->html_target)
					{
						/* send HTML to the renderer */
						outstring_stream(stream, "<B>");
					}
					else
					{
						/* turn on the 'hilite' attribute */
						stream->cur_attr |= OS_ATTR_HILITE;
					}
					break;

				case ')':
					/* generate HTML if in the appropriate mode */
					if (stream->html_mode && stream->html_target)
					{
						/* send HTML to the renderer */
						outstring_stream(stream, "</B>");
					}
					else
					{
						/* turn off the 'hilite' attribute */
						stream->cur_attr &= ~OS_ATTR_HILITE;
					}
					break;

				case '-':
					outchar_stream(stream, nextout(&s, &slen));
					outchar_stream(stream, nextout(&s, &slen));
					break;

				default:                 /* just pass invalid escapes as-is */
					outchar_stream(stream, c);
					break;
				}
			}
		}
		else if (!stream->html_target
				 && stream->html_mode
				 && (c == '<' || c == '&'))
		{
			/*
			 *   We're in HTML mode, but the underlying target does not
			 *   accept HTML sequences.  It appears we're at the start of
			 *   an "&" entity or a tag sequence, so parse it, remove it,
			 *   and replace it (if possible) with a text-only equivalent.
			 */
			if (c == '<')
			{
				/* read the tag */
				char tagbuf[50];
				int is_end_tag;
				c = read_tag(tagbuf, sizeof(tagbuf), &is_end_tag,
							 &s, &slen, 0);

				/*
				 *   Check to see if we recognize the tag.  We only
				 *   recognize a few simple tags that map easily to
				 *   character mode.
				 */
				if (!scumm_stricmp(tagbuf, "br"))
				{
					/*
					 *   line break - if there's anything buffered up,
					 *   just flush the current line, otherwise write out
					 *   a blank line
					 */
					if (stream->html_in_ignore)
						/* suppress breaks in ignore mode */;
					else if (stream->linepos != 0)
						stream->html_defer_br = HTML_DEFER_BR_FLUSH;
					else
						stream->html_defer_br = HTML_DEFER_BR_BLANK;
				}
				else if (!scumm_stricmp(tagbuf, "b")
						 || !scumm_stricmp(tagbuf, "i")
						 || !scumm_stricmp(tagbuf, "em")
						 || !scumm_stricmp(tagbuf, "strong"))
				{
					int attr = 0;

					/* choose the attribute flag */
					switch (tagbuf[0])
					{
					case 'b':
					case 'B':
						attr = OS_ATTR_BOLD;
						break;

					case 'i':
					case 'I':
						attr = OS_ATTR_ITALIC;
						break;

					case 'e':
					case 'E':
						attr = OS_ATTR_EM;
						break;

					case 's':
					case 'S':
						attr = OS_ATTR_STRONG;
						break;
					}

					/* bold on/off - send out appropriate os-layer code */
					if (stream->html_in_ignore)
					{
						/* suppress any change in 'ignore' mode */
					}
					else if (!is_end_tag)
					{
						/* turn on the selected attribute */
						stream->cur_attr |= attr;
					}
					else
					{
						/* turn off the selected attribute */
						stream->cur_attr &= ~attr;
					}
				}
				else if (!scumm_stricmp(tagbuf, "p"))
				{
					/* paragraph - send out a blank line */
					if (!stream->html_in_ignore)
						outblank_stream(stream);
				}
				else if (!scumm_stricmp(tagbuf, "tab"))
				{
					/* tab - send out a \t */
					if (!stream->html_in_ignore)
						outtab_stream(stream);
				}
				else if (!scumm_stricmp(tagbuf, "img") || !scumm_stricmp(tagbuf, "sound"))
				{
					/* IMG and SOUND - allow ALT attributes */
					stream->html_allow_alt = TRUE;
				}
				else if (!scumm_stricmp(tagbuf, "hr"))
				{
					int rem;

					if (!stream->html_in_ignore)
					{
						/* start a new line */
						outflushn_stream(stream, 1);

						/* write out underscores to the display width */
						for (rem = G_os_linewidth - 1 ; rem > 0 ; )
						{
							char dashbuf[100];
							int cur;

							/* do as much as we can on this pass */
							cur = rem;
							if ((size_t)cur > sizeof(dashbuf) - 1)
								cur = sizeof(dashbuf) - 1;

							/* do a buffer-full of dashes */
							memset(dashbuf, '_', cur);
							dashbuf[cur] = '\0';
							outstring_stream(stream, dashbuf);

							/* deduct this from the total */
							rem -= cur;
						}

						/* put a blank line after the underscores */
						outblank_stream(stream);
					}
				}
				else if (!scumm_stricmp(tagbuf, "q"))
				{
					unsigned int htmlchar;

					if (!stream->html_in_ignore)
					{
						/* if it's an open quote, increment the level */
						if (!is_end_tag)
							++(stream->html_quote_level);

						/* add the open quote */
						htmlchar =
							(!is_end_tag
							 ? ((stream->html_quote_level & 1) == 1
								? 8220 : 8216)
							 : ((stream->html_quote_level & 1) == 1
								? 8221 : 8217));

						/*
						 *   write out the HTML character, translated to
						 *   the local character set
						 */
						outchar_html_stream(stream, htmlchar);

						/* if it's a close quote, decrement the level */
						if (is_end_tag)
							--(stream->html_quote_level);
					}
				}
				else if (!scumm_stricmp(tagbuf, "title"))
				{
					/*
					 *   Turn ignore mode on or off as appropriate, and
					 *   turn on or off title mode as well.
					 */
					if (is_end_tag)
					{
						/*
						 *   note that we're leaving an ignore section and
						 *   a title section
						 */
						--(stream->html_in_ignore);
						--(stream->html_in_title);

						/*
						 *   if we're no longer in a title, call the OS
						 *   layer to tell it the title string, in case it
						 *   wants to change the window title or otherwise
						 *   make use of the title
						 */
						if (stream->html_in_title == 0)
						{
							/* null-terminate the title string */
							*stream->html_title_ptr = '\0';

							/* tell the OS about the title */
							os_set_title(stream->html_title_buf);
						}
					}
					else
					{
						/*
						 *   if we aren't already in a title, set up to
						 *   capture the title into the title buffer
						 */
						if (!stream->html_in_title)
							stream->html_title_ptr = stream->html_title_buf;

						/*
						 *   note that we're in a title and in an ignore
						 *   section, since nothing within gets displayed
						 */
						++(stream->html_in_ignore);
						++(stream->html_in_title);
					}
				}
				else if (!scumm_stricmp(tagbuf, "aboutbox"))
				{
					/* turn ignore mode on or off as appropriate */
					if (is_end_tag)
						--(stream->html_in_ignore);
					else
						++(stream->html_in_ignore);
				}
				else if (!scumm_stricmp(tagbuf, "pre"))
				{
					/* count the nesting level if starting PRE mode */
					if (!is_end_tag)
						stream->html_pre_level += 1;

					/* surround the PRE block with line breaks */
					outblank_stream(stream);

					/* count the nesting level if ending PRE mode */
					if (is_end_tag && stream->html_pre_level != 0)
						stream->html_pre_level -= 1;
				}

				/* suppress everything up to the next '>' */
				stream->html_mode_flag = HTML_MODE_TAG;

				/*
				 *   continue with the current character; since we're in
				 *   html tag mode, we'll skip everything until we get to
				 *   the closing '>'
				 */
				continue;
			}
			else if (c == '&')
			{
				/* parse it */
				char  xlat_buf[50];
				c = out_parse_entity(xlat_buf, sizeof(xlat_buf), &s, &slen);

				/* write it out (we've already translated it) */
				outstring_noxlat_stream(stream, xlat_buf);

				/* proceed with the next character */
				continue;
			}
		}
		else if (stream->html_target && stream->html_mode && c == '<')
		{
			/*
			 *   We're in HTML mode, and we have an underlying HTML target.
			 *   We don't need to do much HTML interpretation at this level.
			 *   However, we do need to keep track of when we're in a PRE
			 *   block, so that we can pass whitespaces and newlines through
			 *   to the underlying HTML engine without filtering when we're
			 *   in preformatted text.
			 */
			char tagbuf[50];
			int is_end_tag;
			c = read_tag(tagbuf, sizeof(tagbuf), &is_end_tag,
						 &s, &slen, stream);

			/* check for special tags */
			if (!scumm_stricmp(tagbuf, "pre"))
			{
				/* count the nesting level */
				if (!is_end_tag)
					stream->html_pre_level += 1;
				else if (is_end_tag && stream->html_pre_level != 0)
					stream->html_pre_level -= 1;
			}

			/* copy the last character after the tag to the stream */
			outchar_stream(stream, c);
		}
		else
		{
			/* normal character */
			outchar_stream(stream, c);
		}

		/* move on to the next character, unless we're finished */
		if (done)
			c = '\0';
		else
			c = nextout(&s, &slen);
	}

	/* if we ended up inside what looked like a format string, dump string */
	if (infmt)
	{
		outchar_stream(stream, '%');
		for (f1 = fmsbuf ; f1 < f ; ++f1)
			outchar_stream(stream, *f1);
	}

	/* exit a recursion level */
	out_pop_stream();

	/* success */
	return 0;
}

/* ------------------------------------------------------------------------ */
/*
 *   Parse an HTML entity markup
 */
static char out_parse_entity(char *outbuf, size_t outbuf_size, const char **sp, size_t *slenp) {
	char  ampbuf[10];
	char *dst;
	const char *orig_s;
	size_t orig_slen;
	const amp_tbl_t *ampptr;
	size_t lo, hi, cur;
	char  c;

	/*
	 *   remember where the part after the '&' begins, so we can come back
	 *   here later if necessary
	 */
	orig_s = *sp;
	orig_slen = *slenp;

	/* get the character after the ampersand */
	c = nextout(sp, slenp);

	/* if it's numeric, parse the number */
	if (c == '#')
	{
		uint val;

		/* skip the '#' */
		c = nextout(sp, slenp);

		/* check for hex */
		if (c == 'x' || c == 'X')
		{
			/* skip the 'x' */
			c = nextout(sp, slenp);

			/* read the hex number */
			for (val = 0 ; Common::isXDigit((uchar)c) ; c = nextout(sp, slenp))
			{
				/* accumulate the current digit into the value */
				val *= 16;
				if (outisdg(c))
					val += c - '0';
				else if (c >= 'a' && c <= 'f')
					val += c - 'a' + 10;
				else
					val += c - 'A' + 10;
			}
		}
		else
		{
			/* read the number */
			for (val = 0 ; outisdg(c) ; c = nextout(sp, slenp))
			{
				/* accumulate the current digit into the value */
				val *= 10;
				val += c - '0';
			}
		}

		/* if we found a ';' at the end, skip it */
		if (c == ';')
			c = nextout(sp, slenp);

		/* translate the character into the output buffer */
		os_xlat_html4(val, outbuf, outbuf_size);

		/* we're done with this character */
		return c;
	}

	/*
	 *   Parse the sequence after the '&'.  Parse up to the closing
	 *   semicolon, or any non-alphanumeric, or until we fill up the buffer.
	 */
	for (dst = ampbuf ;
		 c != '\0' && (outisdg(c) || outisal(c))
			 && dst < ampbuf + sizeof(ampbuf) - 1 ;
		 *dst++ = c, c = nextout(sp, slenp)) ;

	/* null-terminate the name */
	*dst = '\0';

	/* do a binary search for the name */
	lo = 0;
	hi = sizeof(amp_tbl)/sizeof(amp_tbl[0]) - 1;
	for (;;)
	{
		int diff;

		/* if we've converged, look no further */
		if (lo > hi || lo >= sizeof(amp_tbl)/sizeof(amp_tbl[0]))
		{
			ampptr = 0;
			break;
		}

		/* split the difference */
		cur = lo + (hi - lo)/2;
		ampptr = &amp_tbl[cur];

		/* see where we are relative to the target item */
		diff = strcmp(ampptr->cname, ampbuf);
		if (diff == 0)
		{
			/* this is it */
			break;
		}
		else if (diff > 0)
		{
			/* make sure we don't go off the end */
			if (cur == hi && cur == 0)
			{
				/* we've failed to find it */
				ampptr = 0;
				break;
			}

			/* this one is too high - check the lower half */
			hi = (cur == hi ? hi - 1 : cur);
		}
		else
		{
			/* this one is too low - check the upper half */
			lo = (cur == lo ? lo + 1 : cur);
		}
	}

	/* skip to the appropriate next character */
	if (c == ';')
	{
		/* name ended with semicolon - skip the semicolon */
		c = nextout(sp, slenp);
	}
	else if (ampptr != 0)
	{
		int skipcnt;

		/* found the name - skip its exact length */
		skipcnt = strlen(ampptr->cname);
		for (*sp = orig_s, *slenp = orig_slen ; skipcnt != 0 ;
			 c = nextout(sp, slenp), --skipcnt) ;
	}

	/* if we found the entry, write out the character */
	if (ampptr != 0)
	{
		/*
		 *   if this one has an external mapping table entry, use the mapping
		 *   table entry; otherwise, use the default OS routine mapping
		 */
		if (ampptr->expan != 0)
		{
			/*
			 *   we have an explicit expansion from the mapping table file -
			 *   use it
			 */
			size_t copylen = strlen(ampptr->expan);
			if (copylen > outbuf_size - 1)
				copylen = outbuf_size - 1;

			memcpy(outbuf, ampptr->expan, copylen);
			outbuf[copylen] = '\0';
		}
		else
		{
			/*
			 *   there's no mapping table expansion - use the default OS code
			 *   expansion
			 */
			os_xlat_html4(ampptr->html_cval, outbuf, outbuf_size);
		}
	}
	else
	{
		/*
		 *   didn't find it - output the '&' literally, then back up and
		 *   output the entire sequence following
		 */
		*sp = orig_s;
		*slenp = orig_slen;
		c = nextout(sp, slenp);

		/* fill in the '&' return value */
		outbuf[0] = '&';
		outbuf[1] = '\0';
	}

	/* return the next character */
	return c;
}



/* ------------------------------------------------------------------------ */
/*
 *   Initialize the output formatter
 */
void out_init()
{
	/* not yet hiding output */
	outflag = 1;
	outcnt = 0;
	hidout = 0;

	/* initialize the standard display stream */
	out_init_std(&G_std_disp);

	/* initialize the log file stream */
	out_init_log(&G_log_disp);
}


/* ------------------------------------------------------------------------ */
/*
 *   initialize the property translation table
 */
void tiosetfmt(tiocxdef *ctx, runcxdef *rctx, uchar *fbase, uint flen)
{
	VARUSED(ctx);
	fmsbase = fbase;
	fmstop = fbase + flen;
	runctx = rctx;
}


/* ------------------------------------------------------------------------ */
/*
 *   Map an HTML entity to a local character value.  The character table
 *   reader will call this routine during initialization if it finds HTML
 *   entities in the mapping table file.  We'll remember these mappings
 *   for use in translating HTML entities to the local character set.
 *
 *   Note that the standard run-time can only display a single character
 *   set, so every HTML entity that we display must be mapped to the
 *   single active native character set.
 */
void tio_set_html_expansion(unsigned int html_char_val,
							const char *expansion, size_t expansion_len)
{
	amp_tbl_t *p;

	/* find the character value */
	for (p = amp_tbl ;
		 p < amp_tbl + sizeof(amp_tbl)/sizeof(amp_tbl[0]) ; ++p)
	{
		/* if this is the one, store it */
		if (p->html_cval == html_char_val)
		{
			/* allocate space for it */
			p->expan = (char *)osmalloc(expansion_len + 1);

			/* save it */
			memcpy(p->expan, expansion, expansion_len);
			p->expan[expansion_len] = '\0';

			/* no need to look any further */
			return;
		}
	}
}


/* ------------------------------------------------------------------------ */
/*
 *   Write out a c-style (null-terminated) string.
 */
int outformat(const char *s) {
	return outformatlen(s, strlen(s));
}


/* ------------------------------------------------------------------------ */
/*
 *   This routine sends out a string, one character at a time (via outchar).
 *   Escape codes ('\n', and so forth) are handled here.
 */
int outformatlen(const char *s, uint slen) {
	char     c;
	uint     orig_slen;
	const char *orig_s;
	int      ret;
	int      called_filter;

	/* presume we'll return success */
	ret = 0;

	/* presume we won't call the filter function */
	called_filter = FALSE;

	/* if there's a user filter function to invoke, call it */
	if (G_user_filter != MCMONINV)
	{
		/* push the string */
		runpstr(runctx, s, slen, 1);

		/* call the filter */
		runfn(runctx, G_user_filter, 1);

		/*
		 *   note that we called the filter, so that we'll remove the
		 *   result of the filter from the stack before we return
		 */
		called_filter = TRUE;

		/* if the result is a string, use it in place of the original text */
		if (runtostyp(runctx) == DAT_SSTRING)
		{
			runsdef val;
			uchar *p;

			/* pop the value */
			runpop(runctx, &val);

			/*
			 *   get the text from the string, and use it as a replacement
			 *   for the original string
			 */
			p = val.runsv.runsvstr;
			slen = osrp2(p) - 2;
			s = (char *)(p + 2);

			/*
			 *   push the string back onto the stack - this will ensure
			 *   that the string stays referenced while we're working, so
			 *   that the garbage collector won't delete it
			 */
			runrepush(runctx, &val);
		}
	}

	/* remember the original string, before we scan the first character */
	orig_s = s;
	orig_slen = slen;

	/* get the first character to display */
	c = nextout(&s, &slen);

	/* if the string is non-empty, note that we've displayed something */
	if (c != 0)
		outcnt = 1;

	/* check to see if we're hiding output */
	if (out_is_hidden())
		goto done;

	/* if the debugger is showing watchpoints, suppress all output */
	if (outwxflag)
		goto done;

	/* display the string */
	ret = outformatlen_stream(&G_std_disp, orig_s, orig_slen);

	/* if there's a log file, write to the log file as well */
	if (logfp != 0)
	{
		outformatlen_stream(&G_log_disp, orig_s, orig_slen);
		osfflush(logfp);
	}

done:
	/* if we called the filter, remove the result from the stack */
	if (called_filter)
		rundisc(runctx);

	/* return the result from displaying to the screen */
	return ret;
}

/* ------------------------------------------------------------------------ */
/*
 *   Display a blank line
 */
void outblank()
{
	/* note that we've displayed something */
	outcnt = 1;

	/* check to see if we're hiding output */
	if (out_is_hidden())
		return;

	/* generate the newline to the standard display */
	outblank_stream(&G_std_disp);

	/* if we're logging, generate the newline to the log file as well */
	if (logfp != 0)
	{
		outblank_stream(&G_log_disp);
		osfflush(logfp);
	}
}


/* ------------------------------------------------------------------------ */
/*
 *   outcaps() - sets an internal flag which makes the next letter output
 *   a capital, whether it came in that way or not.  Set the same state in
 *   both formatters (standard and log).
 */
void outcaps(void)
{
	outcaps_stream(&G_std_disp);
	outcaps_stream(&G_log_disp);
}

/*
 *   outnocaps() - sets the next letter to a miniscule, whether it came in
 *   that way or not.
 */
void outnocaps(void)
{
	outnocaps_stream(&G_std_disp);
	outnocaps_stream(&G_log_disp);
}

/* ------------------------------------------------------------------------ */
/*
 *   Open a log file
 */
int tiologopn(tiocxdef *ctx, char *fn)
{
	/* if there's an old log file, close it */
	if (tiologcls(ctx))
		return 1;

	/* save the filename for later */
	strcpy(logfname, fn);

	/* open the new file */
	logfp = osfopwt(fn, OSFTLOG);

	/*
	 *   Reset the log file's output formatter state, since we're opening
	 *   a new file.
	 */
	out_init_log(&G_log_disp);

	/*
	 *   Set the log file's HTML source mode flag to the same value as is
	 *   currently being used in the main display stream, so that it will
	 *   interpret source markups the same way that the display stream is
	 *   going to.
	 */
	G_log_disp.html_mode = G_std_disp.html_mode;

	/* return 0 on success, non-zero on failure */
	return (logfp == 0);
}

/*
 *   Close the log file
 */
int tiologcls(tiocxdef *ctx)
{
	/* if we have a file, close it */
	if (logfp != 0)
	{
		/* close the handle */
		osfcls(logfp);

		/* set the system file type to "log file" */
		os_settype(logfname, OSFTLOG);

		/* forget about our log file handle */
		logfp = 0;
	}

	/* success */
	return 0;
}

/* ------------------------------------------------------------------------ */
/*
 *   Write text explicitly to the log file.  This can be used to add
 *   special text (such as prompt text) that would normally be suppressed
 *   from the log file.  When more mode is turned off, we don't
 *   automatically copy text to the log file; any text that the caller
 *   knows should be in the log file during times when more mode is turned
 *   off can be explicitly added with this function.
 *
 *   If nl is true, we'll add a newline at the end of this text.  The
 *   caller should not include any newlines in the text being displayed
 *   here.
 */
void out_logfile_print(const char *txt, int nl)
{
	/* if there's no log file, there's nothing to do */
	if (logfp == 0)
		return;

	/* add the text */
	os_fprintz(logfp, txt);

	/* add a newline if desired */
	if (nl)
	{
		/* add a normal newline */
		os_fprintz(logfp, "\n");

		/* if the logfile is an html target, write an HTML line break */
		if (G_log_disp.html_target && G_log_disp.html_mode)
			os_fprintz(logfp, "<BR HEIGHT=0>\n");
	}

	/* flush the output */
	osfflush(logfp);
}

/* ------------------------------------------------------------------------ */
/*
 *   Set the current MORE mode
 */
int setmore(int state)
{
	int oldstate = G_os_moremode;

	G_os_moremode = state;
	return oldstate;
}

/* ------------------------------------------------------------------------ */
/*
 *   Run the MORE prompt.  If the output layer takes responsibility for
 *   pagination issues (i.e., USE_MORE is defined), we'll simply display
 *   the prompt and wait for input.  Otherwise, the OS layer controls the
 *   MORE prompt, so we'll call the OS-layer function to display the
 *   prompt.
 */
void out_more_prompt()
{
#ifdef USE_MORE
	/*
	 *   USE_MORE defined - we take responsibility for pagination.  Show
	 *   our default MORE prompt and wait for a keystroke.
	 */

	int done;
	int next_page = FALSE;

	/* display the "MORE" prompt */
	os_printz("[More]");
	os_flush();

	/* wait for an acceptable keystroke */
	for (done = FALSE ; !done ; )
	{
		os_event_info_t evt;

		/* get an event */
		switch(os_get_event(0, FALSE, &evt))
		{
		case OS_EVT_KEY:
			switch(evt.key[0])
			{
			case ' ':
				/* stop waiting, show one page */
				done = TRUE;
				next_page = TRUE;
				break;

			case '\r':
			case '\n':
				/* stop waiting, show one line */
				done = TRUE;
				next_page = FALSE;
				break;

			default:
				/* ignore any other keystrokes */
				break;
			}
			break;

		case OS_EVT_EOF:
			/* end of file - there's nothing to wait for now */
			done = TRUE;
			next_page = TRUE;

			/* don't use more prompts any more, as the user can't respond */
			G_os_moremode = FALSE;
			break;

		default:
			/* ignore other events */
			break;
		}
	}

	/*
	 *   Remove the prompt from the screen by backing up and overwriting
	 *   it with spaces.  (Note that this assumes that we're running in
	 *   some kind of terminal or character mode with a fixed-pitch font;
	 *   if that's not the case, the OS layer should be taking
	 *   responsibility for pagination anyway, so this code shouldn't be
	 *   in use in the first place.)
	 */
	os_printz("\r      \r");

	/*
	 *   if they pressed the space key, it means that we should show an
	 *   entire new page, so reset the line count to zero; otherwise,
	 *   we'll want to display another MORE prompt at the very next line,
	 *   so leave the line count alone
	 */
	if (next_page)
		G_std_disp.linecnt = 0;

#else /* USE_MORE */

	/*
	 *   USE_MORE is undefined - this means that the OS layer is taking
	 *   all responsibility for pagination.  We must ask the OS layer to
	 *   display the MORE prompt, because we can't make any assumptions
	 *   about what the prompt looks like.
	 */

	os_more_prompt();

#endif /* USE_MORE */
}

/* ------------------------------------------------------------------------ */
/*
 *   reset output
 */
void outreset(void)
{
	G_std_disp.linecnt = 0;
}

/* ------------------------------------------------------------------------ */
/*
 *   Determine if HTML mode is active.  Returns true if so, false if not.
 *   Note that this merely indicates whether an "\H+" sequence is
 *   currently active -- this will return true after an "\H+" sequence,
 *   even on text-only interpreters.
 */
int tio_is_html_mode()
{
	/* return the current HTML mode flag for the standard display stream */
	return G_std_disp.html_mode;
}


/* ------------------------------------------------------------------------ */
/*
 *   Capture routines.  Capture affects only the standard display output
 *   stream; there's no need to capture information redundantly in the log
 *   file stream.
 */

/*
 *   Begin/end capturing
 */
void tiocapture(tiocxdef *tioctx, mcmcxdef *memctx, int flag)
{
	if (flag)
	{
		/* create a new object if necessary */
		if (G_std_disp.capture_obj == MCMONINV)
		{
			mcmalo(memctx, 256, &G_std_disp.capture_obj);
			mcmunlck(memctx, G_std_disp.capture_obj);
		}

		/* remember the memory context */
		G_std_disp.capture_ctx = memctx;
	}

	/*
	 *   remember capture status in the standard output stream as well as
	 *   the log stream
	 */
	G_std_disp.capturing = flag;
	G_log_disp.capturing = flag;
}

/* clear all captured output */
void tioclrcapture(tiocxdef *tioctx)
{
	G_std_disp.capture_ofs = 0;
}

/* clear captured output back to a given size */
void tiopopcapture(tiocxdef *tioctx, uint orig_size)
{
	G_std_disp.capture_ofs = orig_size;
}

/* get the object handle of the captured output */
mcmon tiogetcapture(tiocxdef *ctx)
{
	return G_std_disp.capture_obj;
}

/* get the amount of text captured */
uint tiocapturesize(tiocxdef *ctx)
{
	return G_std_disp.capture_ofs;
}

/* ------------------------------------------------------------------------ */
/*
 *   set the current actor
 */
void tiosetactor(tiocxdef *ctx, objnum actor)
{
	VARUSED(ctx);
	cmdActor = actor;
}

/*
 *   get the current actor
 */
objnum tiogetactor(tiocxdef *ctx)
{
	VARUSED(ctx);
	return cmdActor;
}

/* ------------------------------------------------------------------------ */
/*
 *   Flush the output line.  We'll write to both the standard display and
 *   the log file, as needed.
 */
void outflushn(int nl)
{
	/* flush the display stream */
	outflushn_stream(&G_std_disp, nl);

	/* flush the log stream, if we have an open log file */
	if (logfp != 0)
	{
		outflushn_stream(&G_log_disp, nl);
		osfflush(logfp);
	}
}

/*
 *   flush the current line, and start a new line
 */
void outflush(void)
{
	/* use the common flushing routine in mode 1 (regular newline) */
	outflushn(1);
}

/* ------------------------------------------------------------------------ */
/*
 *   Hidden text routines
 */

/*
 *   outhide - hide output in the standard display stream
 */
void outhide(void)
{
	outflag = 0;
	outcnt = 0;
	hidout = 0;
}

/*
 *   Check output status.  Indicate whether output is currently hidden,
 *   and whether any hidden output has occurred.
 */
void outstat(int *hidden, int *output_occurred)
{
	*hidden = !outflag;
	*output_occurred = outcnt;
}

/* set the flag to indicate that output has occurred */
void outsethidden(void)
{
	outcnt = 1;
	hidout = 1;
}

/*
 *   outshow() - turns output back on, and returns TRUE (1) if any output
 *   has occurred since the last outshow(), FALSE (0) otherwise.
 */
int outshow(void)
{
	/* turn output back on */
	outflag = 1;

	/* if we're debugging, note the end of hidden output */
	if (dbghid && hidout)
	{
		hidout = 0;
		trcsho();
	}

	/* return the flag indicating whether hidden output occurred */
	return outcnt;
}

/* ------------------------------------------------------------------------ */
/*
 *   start/end watchpoint evaluation - suppress all dstring output
 */
void outwx(int flag)
{
	outwxflag = flag;
}


/* ------------------------------------------------------------------------ */
/*
 *   Set the user filter function.  Setting this to MCMONINV clears the
 *   filter.
 */
void out_set_filter(objnum filter_fn)
{
	/* remember the filter function */
	G_user_filter = filter_fn;
}

/* ------------------------------------------------------------------------ */
/*
 *   Set the double-space mode
 */
void out_set_doublespace(int dbl)
{
	/* remember the new setting */
	doublespace = dbl;
}

int tio_askfile(const char *prompt, char *reply, int replen, int prompt_type, os_filetype_t file_type) {
	// let the OS layer handle it
	return os_askfile(prompt, reply, replen, prompt_type, file_type);
}

int tio_input_dialog(int icon_id, const char *prompt, int standard_button_set,
	const char **buttons, int button_count,
	int default_index, int cancel_index) {
	// call the OS implementation
	return os_input_dialog(icon_id, prompt, standard_button_set,
		buttons, button_count,
		default_index, cancel_index);
}

void outfmt(tiocxdef *ctx, uchar *txt) {
	uint len;

	VARUSED(ctx);

	/* read the length prefix */
	len = osrp2(txt) - 2;
	txt += 2;

	/* write out the string */
	tioputslen(ctx, (char *)txt, len);
}

} // End of namespace TADS2
} // End of namespace TADS
} // End of namespace Glk