* tads2/osifc.h.  We don't need to implement them all, as most of them

 * are provided by tads2/osnoui.c and tads2/osgen3.c.

 *

 * This file implements the "portable" subset of these functions;

 * functions that depend upon curses/ncurses are defined in oscurses.cc.

 */

#include "common.h"

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>

#include <sys/stat.h>

#ifdef HAVE_LANGINFO_CODESET

#include <langinfo.h>

#endif

#include "os.h"

#ifdef RUNTIME

// We utilize the Tads 3 Unicode character mapping facility even for

// Tads 2 (only in the interpreter).

#include "charmap.h"

// Need access to command line options: globalApp->options. Only at

// runtime - compiler uses different mechanism for command line

// options.

#include "frobtadsapp.h"

#endif // RUNTIME

/* Service routine.

 * Try to bring returned by system charset name to a name of one of

 * the encodings in cmaplib.t3r.  The proper way to do it is to

 * maintain an external database of charset aliases, which user can

 * edit.  But this adds unnecessary complexity, which we really don't

 * need.  So, the "database" is internal.

 *

 * TODO: Restore previous bahavior when we fix out curses interface.

 * For now, we always return "us-ascii".

 */

static const char*

get_charset_alias( const char* charset )

{

	const char* p;

	const char* c;

	// Special case.

	if (!stricmp(charset, "ANSI_X3.4-1968")) return "us-ascii";

	// If it's in ru_RU.KOI8-R form, try to extract charset part

	// (everything after last point).

	// Find the last point in the charset name.

	for (p = charset, c = charset ; *p != '\0' ; ++p) {

		if (*p == '.') c = p + 1;

	}

	// '.' was the last symbol in charset name?

	if (*c == '\0') c = charset;

	if (!stricmp(c, "KOI8-R")) return "koi8-r";

	if (!stricmp(c, "ISO-8859-1"))  return "iso1";

	if (!stricmp(c, "ISO-8859-2"))  return "iso2";

	if (!stricmp(c, "ISO-8859-3"))  return "iso3";

	if (!stricmp(c, "ISO-8859-4"))  return "iso4";

	if (!stricmp(c, "ISO-8859-5"))  return "iso5";

	if (!stricmp(c, "ISO-8859-6"))  return "iso6";

	if (!stricmp(c, "ISO-8859-7"))  return "iso7";

	if (!stricmp(c, "ISO-8859-8"))  return "iso8";

	if (!stricmp(c, "ISO-8859-9"))  return "iso9";

	if (!stricmp(c, "ISO-8859-10")) return "iso10";

	if (!stricmp(c, "8859-1"))      return "iso1";

	if (!stricmp(c, "8859-2"))      return "iso2";

	if (!stricmp(c, "8859-3"))      return "iso3";

	if (!stricmp(c, "8859-4"))      return "iso4";

	if (!stricmp(c, "8859-5"))      return "iso5";

	if (!stricmp(c, "8859-6"))      return "iso6";

	if (!stricmp(c, "8859-7"))      return "iso7";

	if (!stricmp(c, "8859-8"))      return "iso8";

	if (!stricmp(c, "8859-9"))      return "iso9";

	if (!stricmp(c, "8859-10"))     return "iso10";

	if (!stricmp(c, "CP1250"))  return "cp1250";

	if (!stricmp(c, "CP-1250")) return "cp1250";

	if (!stricmp(c, "CP_1250")) return "cp1250";

	if (!stricmp(c, "CP1251"))  return "cp1251";

	if (!stricmp(c, "CP-1251")) return "cp1251";

	if (!stricmp(c, "CP_1251")) return "cp1251";

	if (!stricmp(c, "CP1252"))  return "cp1252";

	if (!stricmp(c, "CP-1252")) return "cp1252";

	if (!stricmp(c, "CP_1252")) return "cp1252";

	if (!stricmp(c, "CP1253"))  return "cp1253";

	if (!stricmp(c, "CP-1253")) return "cp1253";

	if (!stricmp(c, "CP_1253")) return "cp1253";

	if (!stricmp(c, "CP1254"))  return "cp1254";

	if (!stricmp(c, "CP-1254")) return "cp1254";

	if (!stricmp(c, "CP_1254")) return "cp1254";

	if (!stricmp(c, "CP1255"))  return "cp1255";

	if (!stricmp(c, "CP-1255")) return "cp1255";

	if (!stricmp(c, "CP_1255")) return "cp1255";

	if (!stricmp(c, "CP1256"))  return "cp1256";

	if (!stricmp(c, "CP-1256")) return "cp1256";

	if (!stricmp(c, "CP_1256")) return "cp1256";

	if (!stricmp(c, "CP1257"))  return "cp1257";

	if (!stricmp(c, "CP-1257")) return "cp1257";

	if (!stricmp(c, "CP_1257")) return "cp1257";

	if (!stricmp(c, "CP1258"))  return "cp1258";

	if (!stricmp(c, "CP-1258")) return "cp1258";

	if (!stricmp(c, "CP_1258")) return "cp1258";

	if (!stricmp(c, "CP437"))  return "cp437";

	if (!stricmp(c, "CP-437")) return "cp437";

	if (!stricmp(c, "CP_437")) return "cp437";

	if (!stricmp(c, "PC437"))  return "cp437";

	if (!stricmp(c, "PC-437")) return "cp437";

	if (!stricmp(c, "PC_437")) return "cp437";

	if (!stricmp(c, "CP737"))  return "cp737";

	if (!stricmp(c, "CP-737")) return "cp737";

	if (!stricmp(c, "CP_737")) return "cp737";

	if (!stricmp(c, "PC737"))  return "cp737";

	if (!stricmp(c, "PC-737")) return "cp737";

	if (!stricmp(c, "PC_737")) return "cp737";

	if (!stricmp(c, "CP775"))  return "cp775";

	if (!stricmp(c, "CP-775")) return "cp775";

	if (!stricmp(c, "CP_775")) return "cp775";

	if (!stricmp(c, "PC775"))  return "cp775";

	if (!stricmp(c, "PC-775")) return "cp775";

	if (!stricmp(c, "PC_775")) return "cp775";

	if (!stricmp(c, "CP850"))  return "cp850";

	if (!stricmp(c, "CP-850")) return "cp850";

	if (!stricmp(c, "CP_850")) return "cp850";

	if (!stricmp(c, "PC850"))  return "cp850";

	if (!stricmp(c, "PC-850")) return "cp850";

	if (!stricmp(c, "PC_850")) return "cp850";

	if (!stricmp(c, "CP852"))  return "cp852";

	if (!stricmp(c, "CP-852")) return "cp852";

	if (!stricmp(c, "CP_852")) return "cp852";

	if (!stricmp(c, "PC852"))  return "cp852";

	if (!stricmp(c, "PC-852")) return "cp852";

	if (!stricmp(c, "PC_852")) return "cp852";

	if (!stricmp(c, "CP855"))  return "cp855";

	if (!stricmp(c, "CP-855")) return "cp855";

	if (!stricmp(c, "CP_855")) return "cp855";

	if (!stricmp(c, "PC855"))  return "cp855";

	if (!stricmp(c, "PC-855")) return "cp855";

	if (!stricmp(c, "PC_855")) return "cp855";

	if (!stricmp(c, "CP857"))  return "cp857";

	if (!stricmp(c, "CP-857")) return "cp857";

	if (!stricmp(c, "CP_857")) return "cp857";

	if (!stricmp(c, "PC857"))  return "cp857";

	if (!stricmp(c, "PC-857")) return "cp857";

	if (!stricmp(c, "PC_857")) return "cp857";

	if (!stricmp(c, "CP860"))  return "cp860";

	if (!stricmp(c, "CP-860")) return "cp860";

	if (!stricmp(c, "CP_860")) return "cp860";

	if (!stricmp(c, "PC860"))  return "cp860";

	if (!stricmp(c, "PC-860")) return "cp860";

	if (!stricmp(c, "PC_860")) return "cp860";

	if (!stricmp(c, "CP861"))  return "cp861";

	if (!stricmp(c, "CP-861")) return "cp861";

	if (!stricmp(c, "CP_861")) return "cp861";

	if (!stricmp(c, "PC861"))  return "cp861";

	if (!stricmp(c, "PC-861")) return "cp861";

	if (!stricmp(c, "PC_861")) return "cp861";

	if (!stricmp(c, "CP862"))  return "cp862";

	if (!stricmp(c, "CP-862")) return "cp862";

	if (!stricmp(c, "CP_862")) return "cp862";

	if (!stricmp(c, "PC862"))  return "cp862";

	if (!stricmp(c, "PC-862")) return "cp862";

	if (!stricmp(c, "PC_862")) return "cp862";

	if (!stricmp(c, "CP863"))  return "cp863";

	if (!stricmp(c, "CP-863")) return "cp863";

	if (!stricmp(c, "CP_863")) return "cp863";

	if (!stricmp(c, "PC863"))  return "cp863";

	if (!stricmp(c, "PC-863")) return "cp863";

	if (!stricmp(c, "PC_863")) return "cp863";

	if (!stricmp(c, "CP864"))  return "cp864";

	if (!stricmp(c, "CP-864")) return "cp864";

	if (!stricmp(c, "CP_864")) return "cp864";

	if (!stricmp(c, "PC864"))  return "cp864";

	if (!stricmp(c, "PC-864")) return "cp864";

	if (!stricmp(c, "PC_864")) return "cp864";

	if (!stricmp(c, "CP865"))  return "cp865";

	if (!stricmp(c, "CP-865")) return "cp865";

	if (!stricmp(c, "CP_865")) return "cp865";

	if (!stricmp(c, "PC865"))  return "cp865";

	if (!stricmp(c, "PC-865")) return "cp865";

	if (!stricmp(c, "PC_865")) return "cp865";

	if (!stricmp(c, "CP866"))  return "cp866";

	if (!stricmp(c, "CP-866")) return "cp866";

	if (!stricmp(c, "CP_866")) return "cp866";

	if (!stricmp(c, "PC866"))  return "cp866";

	if (!stricmp(c, "PC-866")) return "cp866";

	if (!stricmp(c, "PC_866")) return "cp866";

	if (!stricmp(c, "CP869"))  return "cp869";

	if (!stricmp(c, "CP-869")) return "cp869";

	if (!stricmp(c, "CP_869")) return "cp869";

	if (!stricmp(c, "PC869"))  return "cp869";

	if (!stricmp(c, "PC-869")) return "cp869";

	if (!stricmp(c, "PC_869")) return "cp869";

	if (!stricmp(c, "CP874"))  return "cp874";

	if (!stricmp(c, "CP-874")) return "cp874";

	if (!stricmp(c, "CP_874")) return "cp874";

	if (!stricmp(c, "PC874"))  return "cp874";

	if (!stricmp(c, "PC-874")) return "cp874";

	if (!stricmp(c, "PC_874")) return "cp874";

	// There are Mac OS Roman, Central European, Cyrillic, Greek,

	// Icelandic and Turkish charmaps in cmaplib.t3r. But what codes

	// system supposed to return?

	// Unrecognized.

	return charset;

}

/* Open text file for reading and writing.

 */

osfildef*

osfoprwt( const char* fname, os_filetype_t )

{

//	assert(fname != 0);

	// Try opening the file in read/write mode.

	osfildef* fp = fopen(fname, "r+");

	// If opening the file failed, it probably means that it doesn't

	// exist.  In that case, create a new file in read/write mode.

	if (fp == 0) fp = fopen(fname, "w+");

	return fp;

}

/* Open binary file for reading/writing.

 */

osfildef*

osfoprwb( const char* fname, os_filetype_t )

{

//	assert(fname != 0);

	osfildef* fp = fopen(fname, "r+b");

	if (fp == 0) fp = fopen(fname, "w+b");

	return fp;

}

/* Convert string to all-lowercase.

 */

char*

os_strlwr( char* s )

{

//	assert(s != 0);

	for (int i = 0; s[i] != '\0'; ++i) {

		s[i] = tolower(s[i]);

	}

	return s;

}

/* Seek to the resource file embedded in the current executable file.

 *

 * We don't support this (and probably never will).

 */

osfildef*

os_exeseek( const char*, const char* )

{

	return static_cast(osfildef*)(0);

}

/* Create and open a temporary file.

 */

osfildef*

os_create_tempfile( const char* fname, char* buf )

{

	if (fname != 0 and fname[0] != '\0') {

		// A filename has been specified; use it.

		return fopen(fname, "w+b");

	}

	//ASSERT(buf != 0);

	// No filename needed; create a nameless tempfile.

	buf[0] = '\0';

	return tmpfile();

}

/* Delete a temporary file created with os_create_tempfile().

 */

int

osfdel_temp( const char* fname )

{

	//ASSERT(fname != 0);

	if (fname[0] == '\0' or remove(fname) == 0) {

		// Either it was a nameless temp-file and has been

		// already deleted by the system, or deleting it

		// succeeded.  In either case, the operation was

		// successful.

		return 0;

	}

	// It was not a nameless tempfile and remove() failed.

	return 1;

}

/* Get the temporary file path.

 *

 * tads2/osnoui.c defines a DOS version of this routine when MSDOS is

 * defined.

 */

#ifndef MSDOS

void

os_get_tmp_path( char* buf )

{

	// Try the usual env. variable first.

	const char* tmpDir = getenv("TMPDIR");

	// If no such variable exists, try P_tmpdir (if defined in

	// <stdio.h>).

#ifdef P_tmpdir

	if (tmpDir == 0 or tmpDir[0] == '\0') {

		tmpDir = P_tmpdir;

	}

#endif

	// If we still lack a path, use "/tmp".

	if (tmpDir == 0 or tmpDir[0] == '\0') {

		tmpDir = "/tmp";

	}

	// If the directory doesn't exist or is not a directory, don't

	// provide anything at all (which means that the current

	// directory will be used).

	struct stat inf;

	int statRet = stat(tmpDir, &inf);

	if (statRet != 0 or (inf.st_mode & S_IFMT) != S_IFDIR) {

		buf[0] = '\0';

		return;

	}

	strcpy(buf, tmpDir);

	// Append a slash if necessary.

	size_t len = strlen(buf);

	if (buf[len - 1] != '/') {

		buf[len] = '/';

		buf[len + 1] = '\0';

	}

}

#endif // not MSDOS

/* Get a suitable seed for a random number generator.

 *

 * We don't just use the system-clock, but build a number as random as

 * the mechanisms of the standard C-library allow.  This is somewhat of

 * an overkill, but it's simple enough so here goes.  Someone has to

 * write a nuclear war simulator in TADS to test this thoroughly.

 */

void

os_rand( long* val )

{

	//assert(val != 0);

	// Use the current time as the first seed.

	srand(static_cast(unsigned int)(time(0)));

	// Create the final seed by generating a random number using

	// high-order bits, because on some systems the low-order bits

	// aren't very random.

	*val = 1 + static_cast(long)(static_cast(long double)(65535) * rand() / (RAND_MAX + 1.0));

}

/* Get the current system high-precision timer.

 *

 * We provide four (4) implementations of this function:

 *

 *   1. clock_gettime() is available

 *   2. gettimeofday() is available

 *   3. ftime() is available

 *   4. Neither is available - fall back to time()

 *

 * Note that HAVE_CLOCK_GETTIME, HAVE_GETTIMEOFDAY and HAVE_FTIME are

 * mutually exclusive; if one of them is defined, the others aren't.  No

 * need for #else here.

 *

 * Although not required by the TADS VM, these implementations will

 * always return 0 on the first call.

 */

#ifdef HAVE_CLOCK_GETTIME

// The system has the clock_gettime() function.

long

os_get_sys_clock_ms( void )

{

	// We need to remember the exact time this function has been

	// called for the first time, and use that time as our

	// zero-point.  On each call, we simply return the difference

	// in milliseconds between the current time and our zero point.

	static struct timespec zeroPoint;

	// Did we get the zero point yet?

	static bool initialized = false;

	// Not all systems provide a monotonic clock; check if it's

	// available before falling back to the global system-clock.  A

	// monotonic clock is guaranteed not to change while the system

	// is running, so we prefer it over the global clock.

	static const clockid_t clockType =

#ifdef HAVE_CLOCK_MONOTONIC

		CLOCK_MONOTONIC;

#else

		CLOCK_REALTIME;

#endif

	// We must get the current time in each call.

	struct timespec currTime;

	// Initialize our zero-point, if not already done so.

	if (not initialized) {

		clock_gettime(clockType, &zeroPoint);

		initialized = true;

	}

	// Get the current time.

	clock_gettime(clockType, &currTime);

	// Note that tv_nsec contains *nano*seconds, not milliseconds,

	// so we need to convert it; a millisec is 1.000.000 nanosecs.

	return (currTime.tv_sec - zeroPoint.tv_sec) * 1000

	     + (currTime.tv_nsec - zeroPoint.tv_nsec) / 1000000;

}

#endif // HAVE_CLOCK_GETTIME

#ifdef HAVE_GETTIMEOFDAY

// The system has the gettimeofday() function.

long

os_get_sys_clock_ms( void )

{

	static struct timeval zeroPoint;

	static bool initialized = false;

	// gettimeofday() needs the timezone as a second argument.  This

	// is obsolete today, but we don't care anyway; we just pass

	// something.

	struct timezone bogus = {0, 0};

	struct timeval currTime;

	if (not initialized) {

		gettimeofday(&zeroPoint, &bogus);

		initialized = true;

	}

	gettimeofday(&currTime, &bogus);

	// 'tv_usec' contains *micro*seconds, not milliseconds.  A

	// millisec is 1.000 microsecs.

	return (currTime.tv_sec - zeroPoint.tv_sec) * 1000 + (currTime.tv_usec - zeroPoint.tv_usec) / 1000;

}

#endif // HAVE_GETTIMEOFDAY

#ifdef HAVE_FTIME

// The system has the ftime() function.  ftime() is in <sys/timeb.h>.

#include <sys/timeb.h>

long

os_get_sys_clock_ms( void )

{

	static timeb zeroPoint;

	static bool initialized = false;

	struct timeb currTime;

	if (not initialized) {

		ftime(&zeroPoint);

		initialized = true;

	}

	ftime(&currTime);

	return (currTime.time - zeroPoint.time) * 1000 + (currTime.millitm - zeroPoint.millitm);

}

#endif // HAVE_FTIME

#ifndef HAVE_CLOCK_GETTIME

#ifndef HAVE_GETTIMEOFDAY

#ifndef HAVE_FTIME

// Use the standard time() function from the C library.  We lose

// millisecond-precision, but that's the best we can do with time().

long

os_get_sys_clock_ms( void )

{

	static time_t zeroPoint = time(0);

	return (time(0) - zeroPoint) * 1000;

}

#endif

#endif

#endif

/* Get filename from startup parameter, if possible.

 *

 * TODO: Find out what this is supposed to do.

 */

int

os_paramfile( char* )

{

	return 0;

}

/* Get a special directory path.

 *

 * If env. variables exist, they always override the compile-time

 * defaults.

 *

 * We ignore the argv parameter, since on Unix binaries aren't stored

 * together with data on disk.

 */

void

os_get_special_path( char* buf, size_t buflen, const char*, int id )

{

	const char* res;

	switch (id) {

	  case OS_GSP_T3_RES:

		res = getenv("T3_RESDIR");

		if (res == 0 or res[0] == '\0') {

			res = T3_RES_DIR;

		}

		break;

	  case OS_GSP_T3_INC:

		res = getenv("T3_INCDIR");

		if (res == 0 or res[0] == '\0') {

			res = T3_INC_DIR;

		}

		break;

	  case OS_GSP_T3_LIB:

		res = getenv("T3_LIBDIR");

		if (res == 0 or res[0] == '\0') {

			res = T3_LIB_DIR;

		}

		break;

	  case OS_GSP_T3_USER_LIBS:

		// There's no compile-time default for user libs.

		res = getenv("T3_USERLIBDIR");

		break;

	  default:

		// TODO: We could print a warning here to inform the

		// user that we're outdated.

		res = 0;

	}

	if (res != 0) {

		// Only use the detected path if it exists and is a

		// directory.

		struct stat inf;

		int statRet = stat(res, &inf);

		if (statRet == 0 and (inf.st_mode & S_IFMT) == S_IFDIR) {

			strncpy(buf, res, buflen - 1);

			return;

		}

	}

	// Indicate failure.

	buf[0] = '\0';

}

/* Generate a filename for a character-set mapping file.

 *

 * Follow DOS convention: start with the current local charset

 * identifier, then the internal ID, and the suffix ".tcp".  No path

 * prefix, which means look in current directory.  This is what we

 * want, because mapping files are supposed to be distributed with a

 * game, not with the interpreter.

 */

void

os_gen_charmap_filename( char* filename, char* internal_id, char* /*argv0*/ )

{

	char mapname[32];

	os_get_charmap(mapname, OS_CHARMAP_DISPLAY);

	// Theoretically, we can get mapname so long that with 4-letter

	// internal id and 4-letter extension '.tcp' it will be longer

	// than OSFNMAX. Highly unlikely, but...

	size_t len = strlen(mapname);

	if (len > OSFNMAX - 9) len = OSFNMAX - 9;

	memcpy(filename, mapname, len);

	strcat(filename, internal_id);

	strcat(filename, ".tcp");

}

/* Receive notification that a character mapping file has been loaded.

 */

void

os_advise_load_charmap( char* /*id*/, char* /*ldesc*/, char* /*sysinfo*/ )

{

}

/* Get the full filename (including directory path) to the executable

 * file, given the argv[0] parameter passed into the main program.

 *

 * On Unix, you can't tell what the executable's name is by just looking

 * at argv, so we always indicate failure.  No big deal though; this

 * information is only used when the interpreter's executable is bundled

 * with a game, and we don't support this at all.

 */

int

os_get_exe_filename( char*, size_t, const char* )

{

	return false;

}

/* Generate the name of the character set mapping table for Unicode

 * characters to and from the given local character set.

 */

void

os_get_charmap( char* mapname, int charmap_id )

{

	const char* charset = 0;  // Character set name.

#ifdef RUNTIME

	// If there was a command line option, it takes precedence.

	// User knows better, so do not try to modify his setting.

	if (globalApp->options.characterSet[0] != '\0') {

		// One charset for all.

		strncpy(mapname, globalApp->options.characterSet, 32);

		return;

	}

#endif

	// There is absolutely no robust way to determine the local

	// character set.  Roughly speaking, we have three options:

	//

	// Use nl_langinfo() function.  Not always available.

	//

	// Use setlocale(LC_CTYPE, NULL).  This only works if user set

	// locale which is actually installed on the machine, or else

	// it will return NULL.  But we don't need locale, we just need

	// to know what the user wants.

	//

	// Manually look up environment variables LC_ALL, LC_CTYPE and

	// LANG.

	//

	// However, not a single one will provide us with a reliable

	// name of local character set.  There is no standard way to

	// name charsets.  For a single set we can get almost anything:

	// Windows-1251, Win-1251, CP1251, CP-1251, ru_RU.CP1251,

	// ru_RU.CP-1251, ru_RU.CP_1251...  And the only way is to

	// maintain a database of aliases.

#if HAVE_LANGINFO_CODESET

	charset = nl_langinfo(CODESET);

#else

	charset = getenv("LC_CTYPE");

	if (charset == 0 or charset[0] == '\0') {

		charset = getenv("LC_ALL");

		if (charset == 0 or charset[0] == '\0') {

			charset = getenv("LANG");

		}

	}

#endif

	if (charset == 0) {

		strcpy(mapname, "us-ascii");

	} else {

		strcpy(mapname, get_charset_alias(charset));

	}

	return;

}

/* Translate a character from the HTML 4 Unicode character set to the

 * current character set used for display.

 *

 * Note that this function is used only by Tads 2.  Tads 3 does mappings

 * automatically.

 *

 * We omit this implementation when not compiling the interpreter (in

 * which case os_xlat_html4 will have been defined as an empty macro in

 * osfrobtads.h).  We do this because we don't want to introduce any

 * TADS 3 dependencies upon the TADS 2 compiler, which should compile

 * regardless of whether the TADS 3 sources are available or not.

 */

#ifndef os_xlat_html4

void

os_xlat_html4( unsigned int html4_char, char* result, size_t result_buf_len )

{

	// HTML 4 characters are Unicode.  Tads 3 provides just the

	// right mapper: Unicode to ASCII.  We make it static in order

	// not to create a mapper on each call and save CPU cycles.

	static CCharmapToLocalASCII mapper;

	result[mapper.map_char(html4_char, result, result_buf_len)] = '\0';

}

#endif

/* =====================================================================

 *

 * The functions defined below are not needed by the interpreter, or

 * have a curses-specific implementation and are therefore only used

 * when building the compiler (the compiler doesn't use curses, just

 * plain stdio).

 */

#ifndef RUNTIME

/* Wait for a character to become available from the keyboard.

 */

void

os_waitc( void )

{

	getchar();

}

/* Read a character from the keyboard.

 */

int

os_getc( void )

{

	return getchar();

}

/* Read a character from the keyboard and return the low-level,

 * untranslated key code whenever possible.

 */

int

os_getc_raw( void )

{

	return getchar();

}

/* Check for user break.

 *

 * We only provide a dummy here; we might do something more useful in

 * the future though.

 */

int

os_break( void )

{

	return false;

}

/* Yield CPU.

 *

 * We don't need this.  It's only useful for Windows 3.x and maybe pre-X Mac OS

 * and other systems with brain damaged multitasking.

 */

int

os_yield( void )

{

	return false;

}

/* Sleep for a while.

 *

 * The compiler doesn't need this.

 */

void

os_sleep_ms( long )

{

}