path: root/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, char *s);
static void outchar_noxlat_stream(out_stream_info *stream, char c);
static char out_parse_entity(char *outbuf, size_t outbuf_size,
                             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
    {
        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, 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(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,
                     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,
                               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;
                    
                    /* 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,
                             char **sp, size_t *slenp)
{
    char  ampbuf[10];
    char *dst;
    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(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(char *s, uint slen)
{
    char     c;
    uint     orig_slen;
    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(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