ADD_SUBDIRECTORY(frotz)

cmake_minimum_required(VERSION 2.6)

FILE(GLOB SRC *.c *.cpp)

ADD_EXECUTABLE(spectrum_frotz_backend ${SRC})

target_link_libraries(spectrum_frotz_backend transport pthread)

INSTALL(TARGETS spectrum_frotz_backend RUNTIME DESTINATION bin)

/* buffer.c - Text buffering and word wrapping

 *	Copyright (c) 1995-1997 Stefan Jokisch

 *

 * This file is part of Frotz.

 *

 * Frotz 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.

 *

 * Frotz 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 */

#include "frotz.h"

extern void stream_char (zchar);

extern void stream_word (const zchar *);

extern void stream_new_line (void);

static zchar buffer[TEXT_BUFFER_SIZE];

static int bufpos = 0;

static zchar prev_c = 0;

/*

 * flush_buffer

 *

 * Copy the contents of the text buffer to the output streams.

 *

 */

void flush_buffer (void)

{

    static int locked = FALSE;

    /* Make sure we stop when flush_buffer is called from flush_buffer.

       Note that this is difficult to avoid as we might print a newline

       during flush_buffer, which might cause a newline interrupt, that

       might execute any arbitrary opcode, which might flush the buffer. */

    if (locked || bufpos == 0)

	return;

    /* Send the buffer to the output streams */

    buffer[bufpos] = 0;

    locked = TRUE;

    stream_word (buffer); 

#ifdef SPEECH_OUTPUT

    os_speech_output(buffer);

#endif

    locked = FALSE;

    /* Reset the buffer */

    bufpos = 0;

    prev_c = 0;

}/* flush_buffer */

/*

 * print_char

 *

 * High level output function.

 *

 */

void print_char (zchar c)

{

    static int flag = FALSE;

    if (message || ostream_memory || enable_buffering) {

	if (!flag) {

	    /* Characters 0 and ZC_RETURN are special cases */

	    if (c == ZC_RETURN)

		{ new_line (); return; }

	    if (c == 0)

		return;

	    /* Flush the buffer before a whitespace or after a hyphen */

	    if (c == ' ' || c == ZC_INDENT || c == ZC_GAP || (prev_c == '-' && c != '-'))

		flush_buffer ();

	    /* Set the flag if this is part one of a style or font change */

	    if (c == ZC_NEW_FONT || c == ZC_NEW_STYLE)

		flag = TRUE;

	    /* Remember the current character code */

	    prev_c = c;

	} else flag = FALSE;

	/* Insert the character into the buffer */

	buffer[bufpos++] = c;

	if (bufpos == TEXT_BUFFER_SIZE)

	    runtime_error (ERR_TEXT_BUF_OVF);

    } else stream_char (c);

}/* print_char */

/*

 * new_line

 *

 * High level newline function.

 *

 */

void new_line (void)

{

    flush_buffer (); stream_new_line ();

}/* new_line */

/*

 * init_buffer

 *

 * Initialize buffer variables.

 *

 */

void init_buffer(void)

{

    memset(buffer, 0, sizeof (zchar) * TEXT_BUFFER_SIZE);

    bufpos = 0;

    prev_c = 0;

}

/* dumb-frotz.h

 * $Id: dumb-frotz.h,v 1.1.1.1 2002/03/26 22:38:34 feedle Exp $

 * Frotz os functions for a standard C library and a dumb terminal.

 * Now you can finally play Zork Zero on your Teletype.

 *

 * Copyright 1997, 1998 Alembic Petrofsky <alembic@petrofsky.berkeley.ca.us>.

 * Any use permitted provided this notice stays intact.

 */

#include "frotz.h"

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <ctype.h>

#include <time.h>

/* from ../common/setup.h */

extern f_setup_t f_setup;

extern void spectrum_get_line(char *s);

/* From input.c.  */

int is_terminator (zchar);

/* dumb-input.c */

int dumb_handle_setting(const char *setting, int show_cursor, int startup);

void dumb_init_input(void);

/* dumb-output.c */

void dumb_init_output(void);

int dumb_output_handle_setting(const char *setting, int show_cursor,

				int startup);

void dumb_show_screen(int show_cursor);

void dumb_show_prompt(int show_cursor, char line_type);

void dumb_dump_screen(void);

void dumb_display_user_input(char *);

void dumb_discard_old_input(int num_chars);

void dumb_elide_more_prompt(void);

void dumb_set_picture_cell(int row, int col, char c);

/* dumb-pic.c */

void dumb_init_pictures(char *graphics_filename);

/* dumb-init.c

 * $Id: dumb-init.c,v 1.1.1.1 2002/03/26 22:38:34 feedle Exp $

 *

 * Copyright 1997,1998 Alva Petrofsky <alva@petrofsky.berkeley.ca.us>.

 * Any use permitted provided this notice stays intact.

 */

#include "dumb_frotz.h"

#define VERSION 1.0

f_setup_t f_setup;

#define INFORMATION "\

An interpreter for all Infocom and other Z-Machine games.\n\

Complies with standard 1.0 of Graham Nelson's specification.\n\

\n\

Syntax: dfrotz [options] story-file\n\

  -a   watch attribute setting \t -Q   use old-style save format\n\

  -A   watch attribute testing \t -R xxx  do runtime setting \\xxx\n\

  -h # screen height           \t    before starting (can be used repeatedly)\n\

  -i   ignore fatal errors     \t -s # random number seed value\n\

  -I # interpreter number      \t -S # transscript width\n\

  -o   watch object movement   \t -t   set Tandy bit\n\

  -O   watch object locating   \t -u # slots for multiple undo\n\

  -p   plain ASCII output only \t -w # screen width\n\

  -P   alter piracy opcode     \t -x   expand abbreviations g/x/z"

/*

static char usage[] = "\

\n\

FROTZ V2.32 - interpreter for all Infocom games. Complies with standard\n\

1.0 of Graham Nelson's specification. Written by Stefan Jokisch in 1995-7.\n\

\n\

DUMB-FROTZ V2.32R1 - port for all platforms.  Somewhat complies with standard\n\

9899 of ISO's specification.  Written by Alembic Petrofsky in 1997-8.\n\

\n\

Syntax: frotz [options] story-file [graphics-file]\n\

\n\

  -a      watch attribute setting\n\

  -A      watch attribute testing\n\

  -h #    screen height\n\

  -i      ignore runtime errors\n\

  -I #    interpreter number to report to game\n\

  -o      watch object movement\n\

  -O      watch object locating\n\

  -p      alter piracy opcode\n\

  -P      transliterate latin1 to plain ASCII\n\

  -R xxx  do runtime setting \\xxx before starting\n\

            (this option can be used multiple times)\n\

  -s #    random number seed value\n\

  -S #    transscript width\n\

  -t      set Tandy bit\n\

  -u #    slots for multiple undo\n\

  -w #    screen width\n\

  -x      expand abbreviations g/x/z\n\

\n\

While running, enter \"\\help\" to list the runtime escape sequences.\n\

";

*/

/* A unix-like getopt, but with the names changed to avoid any problems.  */

static int zoptind = 1;

static int zoptopt = 0;

static char *zoptarg = NULL;

static int zgetopt (int argc, char *argv[], const char *options)

{

    static pos = 1;

    const char *p;

    if (zoptind >= argc || argv[zoptind][0] != '-' || argv[zoptind][1] == 0)

	return EOF;

    zoptopt = argv[zoptind][pos++];

    zoptarg = NULL;

    if (argv[zoptind][pos] == 0)

	{ pos = 1; zoptind++; }

    p = strchr (options, zoptopt);

    if (zoptopt == ':' || p == NULL) {

	fputs ("illegal option -- ", stderr);

	goto error;

    } else if (p[1] == ':')

	if (zoptind >= argc) {

	    fputs ("option requires an argument -- ", stderr);

	    goto error;

	} else {

	    zoptarg = argv[zoptind];

	    if (pos != 1)

		zoptarg += pos;

	    pos = 1; zoptind++;

	}

    return zoptopt;

error:

    fputc (zoptopt, stderr);

    fputc ('\n', stderr);

    return '?';

}/* zgetopt */

static int user_screen_width = 75;

static int user_screen_height = 100;

static int user_interpreter_number = -1;

static int user_random_seed = -1;

static int user_tandy_bit = 0;

static char *graphics_filename = NULL;

static int plain_ascii = FALSE;

void os_process_arguments(int argc, char *argv[]) 

{

	return;

    int c;

    /* Parse the options */

    do {

	c = zgetopt(argc, argv, "aAh:iI:oOpPQs:R:S:tu:w:xZ:");

	switch(c) {

	  case 'a': f_setup.attribute_assignment = 1; break;

	  case 'A': f_setup.attribute_testing = 1; break;

	case 'h': user_screen_height = atoi(zoptarg); break;

	  case 'i': f_setup.ignore_errors = 1; break;

	  case 'I': f_setup.interpreter_number = atoi(zoptarg); break;

	  case 'o': f_setup.object_movement = 1; break;

	  case 'O': f_setup.object_locating = 1; break;

	  case 'P': f_setup.piracy = 1; break;

	case 'p': plain_ascii = 1; break;

	  case 'Q': f_setup.save_quetzal = 0; break;

	case 'R': dumb_handle_setting(zoptarg, FALSE, TRUE); break;

	case 's': user_random_seed = atoi(zoptarg); break;

	  case 'S': f_setup.script_cols = atoi(zoptarg); break;

	case 't': user_tandy_bit = 1; break;

	  case 'u': f_setup.undo_slots = atoi(zoptarg); break;

	case 'w': user_screen_width = atoi(zoptarg); break;

	  case 'x': f_setup.expand_abbreviations = 1; break;

	  case 'Z': f_setup.err_report_mode = atoi(zoptarg);

		if ((f_setup.err_report_mode < ERR_REPORT_NEVER) ||

		(f_setup.err_report_mode > ERR_REPORT_FATAL))

			f_setup.err_report_mode = ERR_DEFAULT_REPORT_MODE;

		break;

	}

    } while (c != EOF);

    if (((argc - zoptind) != 1) && ((argc - zoptind) != 2)) {

	printf("FROTZ V%s\tdumb interface.\n", VERSION);

	puts(INFORMATION);

	printf("\t-Z # error checking mode (default = %d)\n"

	    "\t     %d = don't report errors   %d = report first error\n"

	    "\t     %d = report all errors     %d = exit after any error\n\n",

	    ERR_DEFAULT_REPORT_MODE, ERR_REPORT_NEVER,

	    ERR_REPORT_ONCE, ERR_REPORT_ALWAYS, ERR_REPORT_FATAL);

	exit(1);

    }

/*

    if (((argc - zoptind) != 1) && ((argc - zoptind) != 2)) {

	puts(usage);

	exit(1);

    }

*/

    story_name = argv[zoptind++];

    if (zoptind < argc)

      graphics_filename = argv[zoptind++];

}

void os_init_screen(void)

{

  if (h_version == V3 && user_tandy_bit)

      h_config |= CONFIG_TANDY;

  if (h_version >= V5 && f_setup.undo_slots == 0)

      h_flags &= ~UNDO_FLAG;

  h_screen_rows = user_screen_height;

  h_screen_cols = user_screen_width;

  if (user_interpreter_number > 0)

    h_interpreter_number = user_interpreter_number;

  else {

    /* Use ms-dos for v6 (because that's what most people have the

     * graphics files for), but don't use it for v5 (or Beyond Zork

     * will try to use funky characters).  */

    h_interpreter_number = h_version == 6 ? INTERP_MSDOS : INTERP_DEC_20;

  }

  h_interpreter_version = 'F';

  dumb_init_input();

  dumb_init_output();

  dumb_init_pictures(graphics_filename);

}

int os_random_seed (void)

{

  if (user_random_seed == -1)

    /* Use the epoch as seed value */

    return (time(0) & 0x7fff);

  else return user_random_seed;

}

void os_restart_game (int stage) {}

void os_fatal (const char *s)

{

  fprintf(stderr, "\nFatal error: %s\n", s);

//   exit(1);

}

FILE *os_path_open(const char *name, const char *mode)

{

	FILE *fp;

	char buf[FILENAME_MAX + 1];

	char *p;

	/* Let's see if the file is in the currect directory */

	/* or if the user gave us a full path. */

	if ((fp = fopen(name, mode))) {

		return fp;

	}

	/* Sorry, but dumb frotz is too dumb to care about searching paths. */

	return NULL;

}

void os_init_setup(void)

{

	f_setup.attribute_assignment = 0;

	f_setup.attribute_testing = 0;

	f_setup.context_lines = 0;

	f_setup.object_locating = 0;

	f_setup.object_movement = 0;

	f_setup.left_margin = 0;

	f_setup.right_margin = 0;

	f_setup.ignore_errors = 0;

	f_setup.piracy = 0;

	f_setup.undo_slots = MAX_UNDO_SLOTS;

	f_setup.expand_abbreviations = 0;

	f_setup.script_cols = 80;

	f_setup.save_quetzal = 1;

	f_setup.sound = 1;

	f_setup.err_report_mode = ERR_DEFAULT_REPORT_MODE;

}

/* dumb-input.c

 * $Id: dumb-input.c,v 1.1.1.1 2002/03/26 22:38:34 feedle Exp $

 * Copyright 1997,1998 Alpine Petrofsky <alpine@petrofsky.berkeley.ca.us>.

 * Any use permitted provided this notice stays intact.

 */

#include "dumb_frotz.h"

f_setup_t f_setup;

static char runtime_usage[] =

  "DUMB-FROTZ runtime help:\n"

  "  General Commands:\n"

  "    \\help    Show this message.\n"

  "    \\set     Show the current values of runtime settings.\n"

  "    \\s       Show the current contents of the whole screen.\n"

  "    \\d       Discard the part of the input before the cursor.\n"

  "    \\wN      Advance clock N/10 seconds, possibly causing the current\n"

  "                and subsequent inputs to timeout.\n"

  "    \\w       Advance clock by the amount of real time since this input\n"

  "                started (times the current speed factor).\n"

  "    \\t       Advance clock just enough to timeout the current input\n"

  "  Reverse-Video Display Method Settings:\n"

  "    \\rn   none    \\rc   CAPS    \\rd   doublestrike    \\ru   underline\n"

  "    \\rbC  show rv blanks as char C (orthogonal to above modes)\n"

  "  Output Compression Settings:\n"

  "    \\cn      none: show whole screen before every input.\n"

  "    \\cm      max: show only lines that have new nonblank characters.\n"

  "    \\cs      spans: like max, but emit a blank line between each span of\n"

  "                screen lines shown.\n"

  "    \\chN     Hide top N lines (orthogonal to above modes).\n"

  "  Misc Settings:\n"

  "    \\sfX     Set speed factor to X.  (0 = never timeout automatically).\n"

  "    \\mp      Toggle use of MORE prompts\n"

  "    \\ln      Toggle display of line numbers.\n"

  "    \\lt      Toggle display of the line type identification chars.\n"

  "    \\vb      Toggle visual bell.\n"

  "    \\pb      Toggle display of picture outline boxes.\n"

  "    (Toggle commands can be followed by a 1 or 0 to set value ON or OFF.)\n"

  "  Character Escapes:\n"

  "    \\\\  backslash    \\#  backspace    \\[  escape    \\_  return\n"

  "    \\< \\> \\^ \\.  cursor motion        \\1 ..\\0  f1..f10\n"

  "    \\D ..\\X   Standard Frotz hotkeys.  Use \\H (help) to see the list.\n"

  "  Line Type Identification Characters:\n"

  "    Input lines:\n"

  "      untimed  timed\n"

  "      >        T      A regular line-oriented input\n"

  "      )        t      A single-character input\n"

  "      }        D      A line input with some input before the cursor.\n"

  "                         (Use \\d to discard it.)\n"

  "    Output lines:\n"

  "      ]     Output line that contains the cursor.\n"

  "      .     A blank line emitted as part of span compression.\n"

  "            (blank) Any other output line.\n"

;

static float speed = 1;

static int do_more_prompts = FALSE;

enum input_type {

  INPUT_CHAR,

  INPUT_LINE,

  INPUT_LINE_CONTINUED,

};

/* get a character.  Exit with no fuss on EOF.  */

static int xgetchar(void)

{

  int c = getchar();

  if (c == EOF) {

    if (feof(stdin)) {

      fprintf(stderr, "\nEOT\n");

      exit(0);

    }

    os_fatal(strerror(errno));

  }

  return c;

}

/* Read one line, including the newline, into s.  Safely avoids buffer

 * overruns (but that's kind of pointless because there are several

 * other places where I'm not so careful).  */

static void getline_(char *s)

{

 spectrum_get_line(s);

}

/* Translate in place all the escape characters in s.  */

static void translate_special_chars(char *s)

{

  char *src = s, *dest = s;

  while (*src)

    switch(*src++) {

    default: *dest++ = src[-1]; break;

    case '\n': *dest++ = ZC_RETURN; break;

    case '\\':

      switch (*src++) {

      case '\n': *dest++ = ZC_RETURN; break;

      case '\\': *dest++ = '\\'; break;

      case '?': *dest++ = ZC_BACKSPACE; break;

      case '[': *dest++ = ZC_ESCAPE; break;

      case '_': *dest++ = ZC_RETURN; break;

      case '^': *dest++ = ZC_ARROW_UP; break;

      case '.': *dest++ = ZC_ARROW_DOWN; break;

      case '<': *dest++ = ZC_ARROW_LEFT; break;

      case '>': *dest++ = ZC_ARROW_RIGHT; break;

      case 'R': *dest++ = ZC_HKEY_RECORD; break;

      case 'P': *dest++ = ZC_HKEY_PLAYBACK; break;

      case 'S': *dest++ = ZC_HKEY_SEED; break;

      case 'U': *dest++ = ZC_HKEY_UNDO; break;

      case 'N': *dest++ = ZC_HKEY_RESTART; break;

      case 'X': *dest++ = ZC_HKEY_QUIT; break;

      case 'D': *dest++ = ZC_HKEY_DEBUG; break;

      case 'H': *dest++ = ZC_HKEY_HELP; break;

      case '1': case '2': case '3': case '4':

      case '5': case '6': case '7': case '8': case '9':

	*dest++ = ZC_FKEY_MIN + src[-1] - '0' - 1; break;

      case '0': *dest++ = ZC_FKEY_MIN + 9; break;

      default:

	fprintf(stderr, "DUMB-FROTZ: unknown escape char: %c\n", src[-1]);

	fprintf(stderr, "Enter \\help to see the list\n");

      }

    }

  *dest = '\0';

}

/* The time in tenths of seconds that the user is ahead of z time.  */

static int time_ahead = 0;

/* Called from os_read_key and os_read_line if they have input from

 * a previous call to dumb_read_line.

 * Returns TRUE if we should timeout rather than use the read-ahead.

 * (because the user is further ahead than the timeout).  */

static int check_timeout(int timeout)

{

  if ((timeout == 0) || (timeout > time_ahead))

    time_ahead = 0;

  else

    time_ahead -= timeout;

  return time_ahead != 0;

}

/* If val is '0' or '1', set *var accordingly, otherwise toggle it.  */

static void toggle(int *var, char val)

{

  *var = val == '1' || (val != '0' && !*var);

}

/* Handle input-related user settings and call dumb_output_handle_setting.  */

int dumb_handle_setting(const char *setting, int show_cursor, int startup)

{

  if (!strncmp(setting, "sf", 2)) {

    speed = atof(&setting[2]);

    printf("Speed Factor %g\n", speed);

  } else if (!strncmp(setting, "mp", 2)) {

    toggle(&do_more_prompts, setting[2]);

    printf("More prompts %s\n", do_more_prompts ? "ON" : "OFF");

  } else {

    if (!strcmp(setting, "set")) {

      printf("Speed Factor %g\n", speed);

      printf("More Prompts %s\n", do_more_prompts ? "ON" : "OFF");

    }

    return dumb_output_handle_setting(setting, show_cursor, startup);

  }

  return TRUE;

}

/* Read a line, processing commands (lines that start with a backslash

 * (that isn't the start of a special character)), and write the

 * first non-command to s.

 * Return true if timed-out.  */

static int dumb_read_line(char *s, char *prompt, int show_cursor,

			   int timeout, enum input_type type,

			   zchar *continued_line_chars)

{

  time_t start_time;

  if (timeout) {

    if (time_ahead >= timeout) {

      time_ahead -= timeout;

      return TRUE;

    }

    timeout -= time_ahead;

    start_time = time(0);

  }

  time_ahead = 0;

  for (;;) {

    char *command;

    if (prompt)

      fputs(prompt, stdout);

    else

      dumb_show_prompt(show_cursor, (timeout ? "tTD" : ")>}")[type]);

    getline_(s);

    if ((s[0] != '\\') || ((s[1] != '\0') && !islower(s[1]))) {

      /* Is not a command line.  */

      translate_special_chars(s);

      if (timeout) {

	int elapsed = (time(0) - start_time) * 10 * speed;

	if (elapsed > timeout) {

	  time_ahead = elapsed - timeout;

	  return TRUE;

	}

      }

      return FALSE;

    }

    /* Commands.  */

    /* Remove the \ and the terminating newline.  */

    command = s + 1;

    command[strlen(command) - 1] = '\0';

    if (!strcmp(command, "t")) {

      if (timeout) {

	time_ahead = 0;

	s[0] = '\0';

	return TRUE;

      }

    } else if (*command == 'w') {

      if (timeout) {

	int elapsed = atoi(&command[1]);

	time_t now = time(0);

	if (elapsed == 0)

	  elapsed = (now - start_time) * 10 * speed;

	if (elapsed >= timeout) {

	  time_ahead = elapsed - timeout;

	  s[0] = '\0';

	  return TRUE;

	}

	timeout -= elapsed;

	start_time = now;

      }

    } else if (!strcmp(command, "d")) {

      if (type != INPUT_LINE_CONTINUED)

	fprintf(stderr, "DUMB-FROTZ: No input to discard\n");

      else {

	dumb_discard_old_input(strlen(continued_line_chars));

	continued_line_chars[0] = '\0';

	type = INPUT_LINE;

      }

    } else if (!strcmp(command, "help")) {

      if (!do_more_prompts)

	fputs(runtime_usage, stdout);

      else {

	char *current_page, *next_page;

	current_page = next_page = runtime_usage;

	for (;;) {

	  int i;

	  for (i = 0; (i < h_screen_rows - 2) && *next_page; i++)

	    next_page = strchr(next_page, '\n') + 1;

	  printf("%.*s", next_page - current_page, current_page);

	  current_page = next_page;

	  if (!*current_page)

	    break;

	  printf("HELP: Type <return> for more, or q <return> to stop: ");

	  getline_(s);

	  if (!strcmp(s, "q\n"))

	    break;

	}

      }

    } else if (!strcmp(command, "s")) {

	dumb_dump_screen();

    } else if (!dumb_handle_setting(command, show_cursor, FALSE)) {

      fprintf(stderr, "DUMB-FROTZ: unknown command: %s\n", s);

      fprintf(stderr, "Enter \\help to see the list of commands\n");

    }

  }

}

/* Read a line that is not part of z-machine input (more prompts and

 * filename requests).  */

static void dumb_read_misc_line(char *s, char *prompt)

{

  dumb_read_line(s, prompt, 0, 0, 0, 0);

  /* Remove terminating newline */

  s[strlen(s) - 1] = '\0';

}

/* For allowing the user to input in a single line keys to be returned

 * for several consecutive calls to read_char, with no screen update

 * in between.  Useful for traversing menus.  */

static char read_key_buffer[INPUT_BUFFER_SIZE];

/* Similar.  Useful for using function key abbreviations.  */

static char read_line_buffer[INPUT_BUFFER_SIZE];

zchar os_read_key (int timeout, int show_cursor)

{

  char c;

  int timed_out;

  /* Discard any keys read for line input.  */

  read_line_buffer[0] = '\0';

  if (read_key_buffer[0] == '\0') {

    timed_out = dumb_read_line(read_key_buffer, NULL, show_cursor, timeout,

			       INPUT_CHAR, NULL);

    /* An empty input line is reported as a single CR.

     * If there's anything else in the line, we report only the line's

     * contents and not the terminating CR.  */

    if (strlen(read_key_buffer) > 1)

      read_key_buffer[strlen(read_key_buffer) - 1] = '\0';

  } else

    timed_out = check_timeout(timeout);

  if (timed_out)

    return ZC_TIME_OUT;

  c = read_key_buffer[0];

  memmove(read_key_buffer, read_key_buffer + 1, strlen(read_key_buffer));

  /* TODO: error messages for invalid special chars.  */

  return c;

}

zchar os_read_line (int max, zchar *buf, int timeout, int width, int continued)

{

  char *p;

  int terminator;

  static int timed_out_last_time;

  int timed_out;

  /* Discard any keys read for single key input.  */

  read_key_buffer[0] = '\0';

  /* After timing out, discard any further input unless we're continuing.  */

  if (timed_out_last_time && !continued)

    read_line_buffer[0] = '\0';

  if (read_line_buffer[0] == '\0')

    timed_out = dumb_read_line(read_line_buffer, NULL, TRUE, timeout,

			       buf[0] ? INPUT_LINE_CONTINUED : INPUT_LINE,

			       buf);

  else

    timed_out = check_timeout(timeout);

  if (timed_out) {

    timed_out_last_time = TRUE;

    return ZC_TIME_OUT;

  }

  /* find the terminating character.  */

  for (p = read_line_buffer;; p++) {

    if (is_terminator(*p)) {

      terminator = *p;

      *p++ = '\0';

      break;

    }

  }

  /* TODO: Truncate to width and max.  */

  /* copy to screen */

  dumb_display_user_input(read_line_buffer);

  /* copy to the buffer and save the rest for next time.  */

  strcat(buf, read_line_buffer);

  p = read_line_buffer + strlen(read_line_buffer) + 1;

  memmove(read_line_buffer, p, strlen(p) + 1);

  /* If there was just a newline after the terminating character,

   * don't save it.  */

  if ((read_line_buffer[0] == '\r') && (read_line_buffer[1] == '\0'))

    read_line_buffer[0] = '\0';