path: root/src/parsec/con_main.cpp

/*
 * PARSEC - Console Main Module
 *
 * $Author: uberlinuxguy $ - $Date: 2004/09/26 03:43:34 $
 *
 * Orginally written by:
 *   Copyright (c) Markus Hadwiger     <msh@parsec.org>   1996-2000
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */ 

// C library
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// compilation flags/debug support
#include "config.h"
#include "debug.h"

// general definitions
#include "general.h"
#include "gd_heads.h"
#include "objstruc.h"

// global externals
#include "globals.h"

// subsystem headers
#include "inp_defs.h"

// drawing subsystem
#include "d_bmap.h"
#include "d_font.h"

// local module header
#include "con_main.h"

// proprietary module headers
#include "con_act.h"
#include "con_arg.h"
#include "con_aux.h"
#include "con_com.h"
#include "con_conf.h"
#include "con_ext.h"
#include "con_info.h"
#include "con_int.h"
#include "con_kmap.h"
#include "con_list.h"
#include "con_rc.h"
#include "con_std.h"
#include "con_tab.h"
#include "con_vald.h"
#include "e_color.h"
#include "e_demo.h"
#include "e_draw.h"
#include "g_supp.h"
#include "h_cockpt.h"
#include "h_strmap.h"
#include "keycodes.h"
#include "m_main.h"
#include "sys_path.h"
#include "sys_swap.h"


// flags
#define PROCESS_STARTUP_SCRIPT				// execute startup (boot) script
#define FORCE_CONSOLE_LOGIN					// have to login to exec commands
#define LOSE_KEYBOARD_FOCUS_ON_SLIDEUP		// console loses focus on slide up


// echo commands in startup script
#define ECHO_STARTUP_SCRIPT			TRUE	// echo+history for startup script

// speed of console sliding
#define CONSOLE_SLIDE_SPEED 		3		// less is faster

// miscellaneous defines
#define CONSOLE_MIN_ENTER_LENGTH	4		// lower bound for entry area
#define CURSOR_BLINK_SPEED			0x100	// in reference frames
#define CONSOLE_CAPTION_HEIGHT		2		// caption plus one empty line
#define CONSOLE_MAX_BACK_LINES		128		// number of lines to scroll back


// macros can be disabled to prevent overriding of internal commands
static int disable_macros			= FALSE;

// flag whether script compilation in progress
PUBLIC int compile_script			= FALSE;

// filepointer for compilation output
PUBLIC FILE *compile_fp				= NULL;

// echo commands executed from file (script)
PUBLIC int EchoExternalCommands		= FALSE;

// enter script commands into history list
PUBLIC int HistoryForBatchEntry		= TRUE;

// startup script file names (normal boot/demo boot)
PUBLIC char boot_script_name[]		= "boot" CON_FILE_EXTENSION;
static char demo_script_name[]		= "demo" CON_FILE_EXTENSION;

// various string constants
PUBLIC char con_prompt[]			= "::";
PUBLIC char ok_prompt[] 			= "ok.";
PUBLIC char press_space[]			= "- press space -";
PUBLIC char too_many_args[] 		= "too many arguments.";
PUBLIC char arg_missing[]			= "argument missing.";
PUBLIC char invalid_arg[]			= "invalid argument.";
PUBLIC char range_error[]			= "range error.";
PUBLIC char unknown_command[]		= "unknown command.";
PUBLIC char unknown_script[]		= "unknown command script.";
PUBLIC char cmd_not_compilable[]	= "command cannot be compiled.";
PUBLIC char line_separator[]		= "----------------------------------";
static char console_login_passwd[]	= "argument.";
static char recursive_compilation[]	= "recursive compilation... rather not.";
static char compile_open_failed[]	= "cannot open output file.";

PUBLIC int	press_space_curs_x		= strlen( press_space ) - PROMPT_SIZE;

static char console_caption[]		= "parsec command console";
static char console_ready[] 		= "console ready...";

static char auxflag_array_name[]	= ".aux";
static char auxdata_array_name[]	= ".auxd";

static char insert_cursor[]			= "_";	// will be a underline cursor
static char overwrite_cursor[]		= "^";	// will be a block cursor

static char console_lock_done[]		= "console is now locked.";
static char console_unlock_done[]	= "console is now unlocked.";
static char console_is_locked[]		= "console locked.";

// generic string paste area
#define PASTE_STR_LEN 255
static char paste_str[ PASTE_STR_LEN + 1 ];

#if ( PASTE_STR_LEN < MAX_CONSOLE_LINE_LENGTH )
	#error "CON_MAIN::paste_str too short!"
#endif

// console geometry
PRIVATE int console_frameofs_x = 4;
PRIVATE int console_frameofs_y = 0;
PRIVATE int console_frame_left = 8;
PRIVATE int console_frame_top  = 5;

// current console contents
PUBLIC char con_lines[ NUM_CONSOLE_LINES ][ MAX_CONSOLE_LINE_LENGTH + 1 ];

// temporary line from which actual drawing will be done
static char draw_line[ MAX_CONSOLE_LINE_LENGTH + 1 ];

// temporary line for current command (from console input line or file)
static char command_line[ MAX_CONSOLE_LINE_LENGTH + 1 ];

// history buffer (most recent commands history)
static char history_list[ NUM_HISTORY_LINES ][ MAX_CONSOLE_LINE_LENGTH + 1 ];

static int history_add	= 0;	// new entry will be placed here
static int history_scan = 0;	// current scroll position in list

static int insert_mode	= TRUE;	// default mode: insert

PUBLIC int con_back_view= 0;	// number of lines to view back in console

PUBLIC int con_content	= 1;	// valid lines in console buffer
PUBLIC int con_bottom	= 0;	// current line in console buffer (0..)

static int last_con_content;	// old state
static int last_con_bottom;		// (used in lists to overwrite space prompt)

static int cursor_state = CURSOR_BLINK_SPEED;
PUBLIC int cursor_x		= 0;	// current cursor position (0==behind prompt)

static int edit_ofs_x	= 0;	// x offset for viewing the edit line
static int edit_max_x	= MAX_CONSOLE_LINE_LENGTH - PROMPT_SIZE;

int  con_in_talk_mode	= true;
int  con_talk_line		= 0;	// line just below separator in talk mode
char talk_escape_char	= '/';	// escape char for command input in talk mode

int con_non_interactive	= 0;	// CON_AddMessage() instead of CON_AddLine()

int con_logged_in		= 1;	// user logged in
int con_login_mode		= 0;	// login mode (must not display console input)
int con_no_login_check	= 0;	// used by keymapped commands

int ConsoleEnterLength	= 23;	// length of console line (excl. prompt+cursor)
int ConsoleTextX		= 3;	// x-pos of console in char-multiples
int ConsoleTextY		= 7;	// y-pos of console in char-multiples

// execute init only once
int console_init_done	= FALSE;

// scratchpad for path with current working directory prepended
static char curworkdir_path[ PATH_MAX + 1 ];


// completely erase (fill with zero-bytes) all console lines ------------------
//
void ClearConScreen()
{
	// clear all lines and make them valid
	memset( con_lines, 0, sizeof( con_lines ) );
	con_content = NUM_CONSOLE_LINES;

	// reset back-viewing
	con_back_view = 0;
}


// completely erase (fill with zero-bytes) an entire console line -------------
//
void EraseConLine( int line )
{
	ASSERT( ( line >= 0 ) && ( line < NUM_CONSOLE_LINES ) );
	memset( con_lines[ line ], 0, MAX_CONSOLE_LINE_LENGTH + 1 );
}


// fill current line with separator chars -------------------------------------
//
void CreateSeparatorLine( int line )
{
	ASSERT( ( line >= 0 ) && ( line < NUM_CONSOLE_LINES ) );
	memset( con_lines[ line ], '-', MAX_CONSOLE_LINE_LENGTH );
	con_lines[ line ][ MAX_CONSOLE_LINE_LENGTH ] = 0;
}


// return path with current workdir prepended if it starts with "./" ----------
//
char *SubstCurWorkDir( char *path )
{
	ASSERT( path != NULL );

	//NOTE:
	// a copy of the path is returned even if it
	// has not been altered to achieve the exact
	// same semantics as in case of modification.

	//NOTE:
	// this function recognizes ".:" as alternative specifier for
	// the workdir in order to allow MacOS path specifications in
	// console script paths.

	if ( ( strncmp( path, "./", 2 ) == 0 ) ||
		 ( strncmp( path, ".:", 2 ) == 0 ) ) {

		if ( AUX_FORCE_WORKDIR_TO_CURRENT ) {

			// just skip first two chars
			strncpy( curworkdir_path, path + 2, PATH_MAX );
			curworkdir_path[ PATH_MAX ] = 0;

		} else {

			// substitute current working directory for "."
			strcpy( curworkdir_path, CurWorkDir );
			int cwdlen = strlen( CurWorkDir );
			strncpy( curworkdir_path + cwdlen, path + 1, PATH_MAX - cwdlen );
			curworkdir_path[ PATH_MAX ] = 0;
		}

	} else {

		// just copy over unmodified path
		strncpy( curworkdir_path, path, PATH_MAX );
		curworkdir_path[ PATH_MAX ] = 0;
	}

	// convert path to system format
	path = SYSs_ProcessPathString( curworkdir_path );
	if ( path != curworkdir_path ) {
		strncpy( curworkdir_path, path, PATH_MAX );
		curworkdir_path[ PATH_MAX ] = 0;
	}

	// strip path if flag set
	char *substpath = curworkdir_path;
	if ( AUX_FORCE_FILEPATH_TO_CURRENT )
		substpath = SYSs_StripPath( curworkdir_path );

	return substpath;
}


// exec startup script (usually boot.con, but also boot scripts of mods) ------
//
void ExecStartupScript( int echo )
{
	// exec startup command script
	char *startupscript = NULL;

	// start normal or mod boot scripts
	if ( mod_numnames > 0 ) {

		ASSERT( mod_names[ 0 ] != NULL );

		// if mod doesn't override our own packages, execute our boot.con too
		if ( !mod_override ) {
			startupscript = PlayDemo ? demo_script_name : boot_script_name;
			ExecConsoleFile( startupscript, echo );
		}

		// afterwards, exec <modname>/boot.con for each registered mod
		for ( int curmod = 0; curmod < mod_numnames; curmod++ ) {

			ASSERT( mod_names[ curmod ] != NULL );
			startupscript = (char *) ALLOCMEM(
				strlen( mod_names[ curmod ] ) + 1 + strlen( boot_script_name ) );
			if ( startupscript == NULL ) {
				OUTOFMEM( 0 );
			}
			strcpy( startupscript, mod_names[ curmod ] );
			strcat( startupscript, "/" );
			strcat( startupscript, boot_script_name );

			// must be done to ensure the file can be found independently of
			// whether it is read from a package or from a real directory
			char *path = SYSs_ProcessPathString( startupscript );

			ExecConsoleFile( path, echo );

			FREEMEM( startupscript );
			startupscript = NULL;
		}

	} else {

		// if no mod is active, we just exec boot.con
		startupscript = PlayDemo ? demo_script_name : boot_script_name;
		ExecConsoleFile( startupscript, echo );
	}
}


// init memory needed for console ---------------------------------------------
//
void InitConsole()
{
	ASSERT( !console_init_done );

	if ( !console_init_done ) {

		// erase console contents
		int lid = 0;
		for ( lid = 0; lid < NUM_CONSOLE_LINES; lid++ ) {
			EraseConLine( lid );
		}

		// erase history buffer
		for ( lid = 0; lid < NUM_HISTORY_LINES; lid++ ) {
			history_list[ lid ][ 0 ] = '\0';
		}

		// insert startup message into top line
		strcpy( con_lines[ 0 ], console_ready );

		// make startup message valid
		con_content = 1;
		con_bottom  = 0;

#ifdef PROCESS_STARTUP_SCRIPT

		// build list of external commands
		BuildExternalCommandList();

		// exec boot.con (also for registered mods)
		ExecStartupScript( ECHO_STARTUP_SCRIPT );

#endif // PROCESS_STARTUP_SCRIPT

		// insert initial prompt
		CON_AddLine( con_prompt );

		//CAVEAT:
		// this has to stay last, because CON_EXT::ExecConsoleFile()
		// uses it to determine whether it has been called from here.
		console_init_done = TRUE;
	}
}


// make sure no demo is playing when console is inited/reinited/killed --------
//
PRIVATE
void KillDemoReplay()
{
	// make sure we call demo stop instead of full clear
	int oldclearflag = AUX_DISABLE_CLEARDEMO_ON_REPSTOP;
	AUX_DISABLE_CLEARDEMO_ON_REPSTOP = 1;

	// make sure no demo is playing
	DEMO_StopReplay();

	// restore previous flag state
	AUX_DISABLE_CLEARDEMO_ON_REPSTOP = oldclearflag;
}


// (re)init file pointers used by console -------------------------------------
//
void InitConsoleFileHandling()
{
	// make sure no demo is playing
	KillDemoReplay();

	if ( log_commands ) {
		fclose( log_fp );
		log_commands = 0;
	}

	if ( RecordingActive ) {
		fclose( RecordingFp );
		RecordingActive = 0;
		RemoteRecSessionId++;
	}
}


// kill resources used by console ---------------------------------------------
//
void KillConsole()
{
	if ( console_init_done ) {
		console_init_done = FALSE;

		InitConsoleFileHandling();
	}
}


// flush keyboard buffer for console ------------------------------------------
//
void FlushConsoleBuffer()
{
	// Not needed
}


// add new message to console (preserve current input) ------------------------
//
void CON_AddMessage( const char *text )
{
	ASSERT( text != NULL );
	ASSERT( strlen( text ) <= MAX_CONSOLE_LINE_LENGTH );

	//NOTE:
	// this function saves the current console
	// line, then overwrites it with the supplied
	// text, starts a new line and re-outputs the
	// old text there. this is useful to display
	// messages in the console without destroying
	// the current input.

	// intermediate console line storage
	static char con_save[ MAX_CONSOLE_LINE_LENGTH + 1 ];

	// save input line and cursor pos
	int curspos = cursor_x;
	strcpy( con_save, con_lines[ con_bottom ] );

	// output supplied message
	EraseConLine( con_bottom );
	strcpy( con_lines[ con_bottom ], text );

	// save old state
	last_con_bottom  = con_bottom;
	last_con_content = con_content;

	// increase bottom pointer
	con_bottom = ( con_bottom + 1 ) & NUM_CONSOLE_LINES_MASK;
	if ( con_content < NUM_CONSOLE_LINES ) {
		con_content++;
	}

	// restore input line
	EraseConLine( con_bottom );
	strcpy( con_lines[ con_bottom ], con_save );

	// restore cursor pos
	cursor_x = curspos;
}


// flag whether next CON_AddLine() should overwrite the current line ----------
//
static int skip_next_nl = FALSE;


// add new line to console ----------------------------------------------------
//
void CON_AddLine( const char *text )
{
	ASSERT( text != NULL );
	ASSERT( strlen( text ) <= MAX_CONSOLE_LINE_LENGTH );

	//NOTE:
	// if console commands are executed in non-interactive mode
	// (i.e., after at least one ac.wait command has been executed),
	// CON_AddMessage() must be used instead of CON_AddLine() to
	// ensure correct line-feeds in the console.

	// allow mapping to CON_AddMessage()
	if ( con_non_interactive ) {
		CON_AddMessage( text );
		return;
	}

	//NOTE:
	// this function preserves the current console
	// line as it is, starts a new line and outputs
	// the supplied text in that line. the console
	// cursor is reset to the first column.

	// increase bottom pointer if not disabled
	if ( !skip_next_nl ) {

		// save old state
		last_con_bottom  = con_bottom;
		last_con_content = con_content;

		con_bottom = ( con_bottom + 1 ) & NUM_CONSOLE_LINES_MASK;
		if ( con_content < NUM_CONSOLE_LINES ) {
			con_content++;
		}
	}

	// clear flag
	skip_next_nl = FALSE;

	// output supplied line
	EraseConLine( con_bottom );
	strcpy( con_lines[ con_bottom ], text );

	// set cursor to first column
	cursor_x = 0;
}


// add line feed in console ---------------------------------------------------
//
void CON_AddLineFeed()
{
	// force line feed
	skip_next_nl = FALSE;
	CON_AddLine( con_prompt );
}


// set flag to disable next line feed in CON_AddLine() ------------------------
//
void CON_DisableLineFeed()
{
	// set flag
	skip_next_nl = TRUE;
}


// set flag to not eat next line feed in CON_AddLine() ------------------------
//
void CON_EnableLineFeed()
{
	// clear flag
	skip_next_nl = FALSE;
}


// delete current console line ------------------------------------------------
//
void CON_DelLine()
{
	EraseConLine( con_bottom );
}


// return pointer to current console line -------------------------------------
//
char *CON_GetLine()
{
	return con_lines[ con_bottom ];
}


// print prompt for list continuation -----------------------------------------
//
void CON_ListCtdPrompt()
{
	CON_AddLine( press_space );
	cursor_x = press_space_curs_x;

	// ensure proper view alignment
	edit_ofs_x = ( cursor_x > ConsoleEnterLength ) ?
		( cursor_x - ConsoleEnterLength ) : 0;
}


// print prompt after list has ended ------------------------------------------
//
void CON_ListEndPrompt()
{
	await_keypress = FALSE;
	com_cont_func  = NULL;

	if ( con_in_talk_mode ) {

		// restore talkmode prompt
		CON_AddLineFeed();
		CreateSeparatorLine( con_bottom );
		CON_AddLineFeed();
		con_talk_line = con_bottom;

	} else {

		// restore standard prompt
		CON_AddLine( con_prompt );
	}
}


// maximum console extents structure ------------------------------------------
//
struct maxconext_s {

	int	c_x,  c_y;
	int	c_w,  c_h;
	int	c_pw, c_ph;
};


// calculate current maximum console extents according to resolution ----------
//
PRIVATE
void GetMaxConExtents( maxconext_s *exs )
{
	int bordx;
	int bordy;
	int linedist;

	int chrwidth = CharsetInfo[ HUD_CHARSETNO ].width;

	console_frameofs_x = 4;
	console_frameofs_y = 0;
	console_frame_left = 8;
	console_frame_top  = 5;
	bordx = 3;
	bordy = 4;
	linedist = CharsetInfo[ HUD_CHARSETNO ].height + 2;

	exs->c_x  = ConsoleTextX - 1;
	exs->c_y  = ConsoleTextY - 1;
	exs->c_w  = Screen_Width / chrwidth - bordx;
	exs->c_h  = Screen_Height / linedist - bordy;
	exs->c_pw = ConsoleEnterLength + 3;
	exs->c_ph = ConsoleHeight;
}


// check geometric extents of console window ----------------------------------
//
void CheckConExtents()
{
	// only if video mode geometry known
	if ( TextModeActive )
		return;

	// get extent bounds
	maxconext_s exs;
	GetMaxConExtents( &exs );

	// check width
	if ( exs.c_x < exs.c_w / 2 ) {

		//NOTE:
		// if console window starts in left half of screen,
		// resize it to a valid width by adjusting the
		// window's width and leave x-position as selected
		// by the user.

		if ( exs.c_x + exs.c_pw > exs.c_w ) {
			exs.c_pw = exs.c_w - exs.c_x;
			if ( exs.c_pw - 3 < int_commands[ CONINFOINDX_CONWIDTH ].bmin ) {
				exs.c_x  = int_commands[ CONINFOINDX_CONWINX ].bmin - 1;
				exs.c_pw = exs.c_w - exs.c_x;
			}
		}
	} else {

		//NOTE:
		// if console window starts in right half of screen,
		// resize it to a valid width by adjusting the
		// window's x-position and leave its width as
		// selected by the user.

		if ( exs.c_x + exs.c_pw > exs.c_w ) {
			exs.c_x = exs.c_w - exs.c_pw;
			if ( exs.c_x + 1 < int_commands[ CONINFOINDX_CONWINX ].bmin ) {
				exs.c_x  = int_commands[ CONINFOINDX_CONWINX ].bmin - 1;
				exs.c_pw = exs.c_w - exs.c_x;
			}
		}
	}

	// check height
	if ( exs.c_y < exs.c_h / 2 ) {

		//NOTE:
		// if console window starts in upper half of screen,
		// resize it to a valid height by adjusting the
		// window's height and leave y-position as selected
		// by the user.

		if ( exs.c_y + exs.c_ph > exs.c_h ) {
			exs.c_ph = exs.c_h - exs.c_y;
			if ( exs.c_ph < int_commands[ CONINFOINDX_CONHEIGHT ].bmin ) {
				exs.c_y  = int_commands[ CONINFOINDX_CONWINY ].bmin - 1;
				exs.c_ph = exs.c_h - exs.c_y;
			}
		}

	} else {

		//NOTE:
		// if console window starts in lower half of screen,
		// resize it to a valid height by adjusting the
		// window's y-position and leave its height as
		// selected by the user.

		if ( exs.c_y + exs.c_ph > exs.c_h ) {
			exs.c_y = exs.c_h - exs.c_ph;
			if ( exs.c_y + 1 < int_commands[ CONINFOINDX_CONWINY ].bmin ) {
				exs.c_y  = int_commands[ CONINFOINDX_CONWINY ].bmin - 1;
				exs.c_ph = exs.c_h - exs.c_y;
			}
		}
	}

	// set new position and size
	ConsoleTextX		= exs.c_x + 1;
	ConsoleTextY		= exs.c_y + 1;
	ConsoleEnterLength	= exs.c_pw - 3;
	ConsoleHeight		= exs.c_ph;

	int_commands[ CONINFOINDX_CONWIDTH ].bmax	= min( exs.c_w - exs.c_x - 3, MAX_CONSOLE_LINE_LENGTH - 3 );
	int_commands[ CONINFOINDX_CONHEIGHT ].bmax	= min( exs.c_h - exs.c_y, NUM_CONSOLE_LINES );
	int_commands[ CONINFOINDX_CONWINX ].bmax	= exs.c_w - exs.c_pw + 1;
	int_commands[ CONINFOINDX_CONWINY ].bmax	= exs.c_h - exs.c_ph + 1;
}


// check commands with single integer argument/query --------------------------
//
PRIVATE
int ExecGetSetInteger( const char *scan )
{
	ASSERT( scan != NULL );

	ConsoleHeight -= 2;

	for ( int icom = 0; icom < num_int_commands; icom++ ) {

		ASSERT( int_commands[ icom ].command != NULL );
		ASSERT( int_commands[ icom ].intref != NULL );

		// need fetch function for int vars that need to be
		// made current before they contain the correct value
		if ( int_commands[ icom ].fetch != NULL )
			*int_commands[ icom ].intref = (*int_commands[ icom ].fetch)();

		if ( CheckSetIntArgBounded( int_print_base, scan,
									(char * ) int_commands[ icom ].command,
									int_commands[ icom ].intref,
									int_commands[ icom ].bmin,
									int_commands[ icom ].bmax,
									int_commands[ icom ].realize ) ) {
			ConsoleHeight += 2;
			return TRUE;
		}
	}

	ConsoleHeight += 2;

	return FALSE;
}


// temporary storage in which user can alter their name -----------------------
//
static char temp_playername[ MAX_PLAYER_NAME + 1 ];


// exec command with a single optional parameter ------------------------------
//
PRIVATE
void ExecGetSetCommand( char *command )
{
	ASSERT( command != NULL );

	// split off first token (command specifier)
	const char *scan = strtok( command, " " );

	// make correct name querying possible
	strcpy( temp_playername, LocalPlayerName );

	// check different commands
	if ( scan != NULL ) {

		if ( ExecGetSetInteger( scan ) )
			{}

		else if ( CheckSetObjTypeProperty( int_print_base, scan ) )
			{}

		else if ( CheckSetObjClassProperty( int_print_base, scan ) )
			{}

		else if ( CheckSetObjInstanceProperty( int_print_base, scan ) )
			{}

		else if ( CheckTypeInfo( scan ) )
			{}

		else if ( CheckClassInfo( scan ) )
			{}

		else if ( CheckInstanceInfo( scan ) )
			{}

		else if ( CheckKeyMappingEcho( (char *) scan ) )
			{}

		else if ( CheckKeyMappingSilent( (char *) scan ) )
			{}

		else if ( CheckSetIntArray( int_print_base, (char *) scan, auxflag_array_name, AuxEnabling, MAX_AUX_ENABLING ) )
			{}

		else if ( CheckSetIntArray( int_print_base, (char *) scan, auxdata_array_name, AuxData, MAX_AUX_DATA ) )
			{}

		else if ( CheckSetStrArgument( TRUE, (char *) scan, (char *) CMSTR( CM_NAME ), temp_playername, MAX_PLAYER_NAME ) )
			CheckPlayerName( temp_playername );

		else if ( CheckColorConfig( (char *) scan ) )
			{}

		else if ( CheckConfigCommand( (char *) scan ) )
			{}

		else
			CON_AddLine( unknown_command );

	} else {

		CON_AddLine( ok_prompt );
	}
}


// key table for compile command ----------------------------------------------
//
key_value_s compile_key_value[] = {

	{ "title",		NULL,	KEYVALFLAG_PARENTHESIZE		},
	{ "desc",		NULL,	KEYVALFLAG_PARENTHESIZE		},
	{ "author",		NULL,	KEYVALFLAG_PARENTHESIZE		},

	{ NULL,			NULL,	KEYVALFLAG_NONE				},
};

enum {

	KEY_COMPILE_TITLE,
	KEY_COMPILE_DESC,
	KEY_COMPILE_AUTHOR
};


// write demo header if at least one info field specified ---------------------
//
PRIVATE
void WriteDemoHeader( char *title, char *desc, char *author )
{
	if ( ( title == NULL ) && ( desc == NULL ) && ( author == NULL ) ) {
		return;
	}

	ASSERT( strlen( DEM_SIGNATURE ) == 6 );

	DemHeader hdr;
	strcpy( hdr.signature, DEM_SIGNATURE );
	hdr.version = REQUIRED_DEM_VERSION;

	dword headersize = sizeof( DemHeader );

	headersize += ( title  != NULL ) ? strlen( title )  + 2 : 0;
	headersize += ( desc   != NULL ) ? strlen( desc )   + 2 : 0;
	headersize += ( author != NULL ) ? strlen( author ) + 2 : 0;

	hdr.headersize = headersize;

	SYS_SwapDemHeader( &hdr );

	// write fixed-size part of header
	fwrite( &hdr, sizeof( hdr ), 1, compile_fp );

	// write title
	byte demokey = 0;
	if ( title != NULL ) {
		demokey = DEMO_KEY_TITLE;
		fwrite( &demokey, sizeof( demokey ), 1, compile_fp );
		fwrite( title, strlen( title ) + 1, 1, compile_fp );
	}

	// write description
	if ( desc != NULL ) {
		demokey = DEMO_KEY_DESCRIPTION;
		fwrite( &demokey, sizeof( demokey ), 1, compile_fp );
		fwrite( desc, strlen( desc ) + 1, 1, compile_fp );
	}

	// write author
	if ( author != NULL ) {
		demokey = DEMO_KEY_AUTHOR;
		fwrite( &demokey, sizeof( demokey ), 1, compile_fp );
		fwrite( author, strlen( author ) + 1, 1, compile_fp );
	}
}


// check compile command and compile script if valid --------------------------
//
PRIVATE
void CompileCommand( char *command )
{
	ASSERT( command != NULL );

	// check for compile command in script to compile
	if ( compile_script ) {
		CON_AddLine( recursive_compilation );
		return;
	}

	// skip command string
	command += CMLEN( CM_COMPILE );

	// check if there is a space between command and argument
	if ( ( *command != ' ' ) && ( *command != 0 ) ) {
		CON_AddLine( unknown_command );
		return;
	}

	// split off argument (name of command script)
	char *scan = strtok( command, " " );
	if ( scan == NULL ) {
		CON_AddLine( arg_missing );
		return;
	}

	// scan out all values to keys
	if ( !ScanKeyValuePairs( compile_key_value, NULL ) )
		return;

	// get demo information strings (not mandatory, might be NULL)
	char *title  = compile_key_value[ KEY_COMPILE_TITLE ].value;
	char *desc   = compile_key_value[ KEY_COMPILE_DESC ].value;
	char *author = compile_key_value[ KEY_COMPILE_AUTHOR ].value;

	// check if command name is valid
	int extcom = CheckExternalCommand( scan );

	if ( extcom > 0 ) {

		// open output file
		strcpy( paste_str, scan );
		strcat( paste_str, CON_FILE_COMPILED_EXTENSION );
		compile_fp = fopen( paste_str, "wb" );

		if ( compile_fp != NULL ) {

			// write header if at least one info field specified
			WriteDemoHeader( title, desc, author );

			// compile script
			compile_script = TRUE;
			CallExternalCommand( extcom - 1, FALSE );
			compile_script = FALSE;

			// close output file
			if ( compile_fp != NULL ) {
				// if no error occurred write eof marker and close file
				int endmarker = 0;
				fwrite( &endmarker, sizeof( endmarker ), 1, compile_fp );
				fclose( compile_fp );
			}

		} else {
			// filepointer for output invalid
			CON_AddLine( compile_open_failed );
		}

	} else {
		// name of script is not in internal table
		CON_AddLine( unknown_script );
	}
}


// execute command that cannot be compiled ------------------------------------
//
void ExecNonCompilableCommand( char *command )
{
	ASSERT( command != NULL );

	//NOTE:
	// this function is mainly used by ExecConsoleCommand().
	// apart from that it is only used by AcExecCommandString()
	// to execute a command supplied as string in a demo.

	// this is first in order to allow user overriding
	// of all non-compilable commands
	if ( CheckCmdsUserDefined( command ) ) {

	// check commands having no parameters
	} else if ( CheckCmdsNoParam( command ) ) {

	// check commands that do their own parameter parsing
	} else if ( CheckCmdsCustomString( command ) ) {

	} else {

		ExecGetSetCommand( command );
	}
}


// add console line to history list -------------------------------------------
//
INLINE
void AddLineToHistory( char *command )
{
	ASSERT( command != NULL );
	ASSERT( strlen( command ) <= MAX_CONSOLE_LINE_LENGTH );

	// store command in current history position, advance in
	// list, and clear history scrolling
	strcpy( history_list[ history_add ], command );
	history_add  = ( history_add + 1 ) & NUM_HISTORY_LINES_MASK;
	history_scan = history_add;

	// clear next two positions in history ring-buffer
	// (this has to be done in order to make scrolling
	// in both directions work properly)
	// this is where entries start to get reused if there
	// is not enough space in the history list
	*( history_list[ history_add ] ) = 0;
	*( history_list[ ( history_add + 1 ) & NUM_HISTORY_LINES_MASK ] ) = 0;
}


// check for console login state and login/logout commands --------------------
//
PRIVATE
int CheckConsoleLogin( char *command )
{
	ASSERT( command != NULL );

	// used by keymapped commands
	if ( con_no_login_check ) {
		return TRUE;
	}

	// avoid preempting startup script
	if ( console_init_done ) {

		if ( con_login_mode ) {
			con_login_mode = 0;

			// check for password
			if ( strcmp( command, console_login_passwd ) == 0 ) {
				con_logged_in = 1;
				CON_AddLine( console_unlock_done );
			}
			// erase password to prevent it from being displayed
			for ( int spos = 0; spos < ConsoleEnterLength; spos++ ) {
				if ( command[ spos ] == 0 )
					break;
				command[ spos ] = '*';
			}
			return FALSE;
		}

		if ( con_logged_in ) {

			if ( strcmp( command, CMSTR( CM_LOGOUT ) ) == 0 ) {
				con_logged_in = 0;
				CON_AddLine( console_lock_done );
				return FALSE;
			}

		} else {

			if ( strcmp( command, CMSTR( CM_LOGIN ) ) == 0 ) {
				con_login_mode = 1;
				return FALSE;
			}

			CON_AddLine( console_is_locked );
			return FALSE;
		}
	}

	return TRUE;
}


// exec console command (this is the main command dispatcher) -----------------
//
void ExecConsoleCommand( char *command, int echo )
{
	//NOTE:
	// this function may be called recursively from within
	// functions called by CON_EXT::CallExternalCommand()
	// to allow execution of command scripts.

	ASSERT( command != NULL );
	ASSERT( ( echo == FALSE ) || ( echo == TRUE ) );

#ifdef FORCE_CONSOLE_LOGIN

	// check login state and login/logout commands
	if ( !CheckConsoleLogin( command ) ) {
		return;
	}

#endif // FORCE_CONSOLE_LOGIN

	// fetch console line as command
	strncpy( command_line, command, MAX_CONSOLE_LINE_LENGTH );
	command_line[ MAX_CONSOLE_LINE_LENGTH ] = 0;
	command = command_line;

	// eat leading whitespace
	for ( ; *command; command++ ) {
		if ( *command != ' ' ) {
			break;
		}
	}

	// early out for empty lines
	if ( *command == 0 ) {
		if ( echo ) {
			CON_AddLine( ok_prompt );
		}
		return;
	}

	if ( echo ) {
		// add command to history list only if echo is on
		AddLineToHistory( command );
	}

	// temp for extcom id
	int extcom;

	if ( strcmp( command, CMSTR( CM_NOMACROS ) ) == 0 ) {

		// disable calls to CallExternalCommand()
		disable_macros = TRUE;

	} else if ( strcmp( command, CMSTR( CM_ENABLEMACROS ) ) == 0 ) {

		// enable calls to CallExternalCommand()
		disable_macros = FALSE;

	} else if ( strncmp( command, CMSTR( CM_COMPILE ), CMLEN( CM_COMPILE ) ) == 0 ) {

		CompileCommand( command );

	} else if ( strncmp( command, ACMSTR( ACM_SIGNATURE ), ACMLEN( ACM_SIGNATURE ) ) == 0 ) {

		// check/exec commands with "ac." prefix
		ActionCommand( command );

	} else if ( !disable_macros && ( extcom = CheckExternalCommand( command ) ) ) {

		// execute command script
		CallExternalCommand( extcom - 1, echo ? EchoExternalCommands : FALSE );

	} else if ( !compile_script ) {

		// check/exec all other commands
		ExecNonCompilableCommand( command );

	} else {

		// error if compilation in progress and non-compilable command found
		CON_AddLine( cmd_not_compilable );
	}
}


// handle console input in talk mode ------------------------------------------
//
PRIVATE
void HandleTalkMode()
{
	if ( con_in_talk_mode ) {

		if ( con_lines[ con_bottom ][ PROMPT_SIZE ] == talk_escape_char ) {

			// remove '/' escape char from input
			strcpy( paste_str, con_lines[ con_bottom ] + PROMPT_SIZE + 1 );

		} else {

			// prepend "say " to input
			strcpy( paste_str, CMSTR( CM_SAY ) );
			paste_str[ CMLEN( CM_SAY ) ] = ' ';
			strncpy( paste_str + CMLEN( CM_SAY ) + 1,
					 con_lines[ con_bottom ] + PROMPT_SIZE,
					 MAX_CONSOLE_LINE_LENGTH - PROMPT_SIZE - CMLEN( CM_SAY ) - 1 );
			paste_str[ MAX_CONSOLE_LINE_LENGTH - PROMPT_SIZE ] = 0;
		}

		// set bottom to line just below separator in order to
		// overwrite previous output. the current input is also
		// copied into this line
		con_bottom = con_talk_line;
		strcpy( con_lines[ con_bottom ] + PROMPT_SIZE, paste_str );

		// ensure the input line gets overwritten by the first console
		// output the command produces. if the command outputs nothing
		// the terminating prompt will overwrite the former input line
		CON_DisableLineFeed();
	}
}


// <enter> key pressed in console ---------------------------------------------
//
PRIVATE
void EnterConsoleCommand()
{
	// handle input in talkmode
	HandleTalkMode();

	// insert command into script if currently open
	if ( !InsertCommandLog( con_lines[ con_bottom ] + PROMPT_SIZE ) ) {

		// execute current linecontent
		ExecConsoleCommand( con_lines[ con_bottom ] + PROMPT_SIZE, TRUE );

		if ( await_keypress ) {
			// listcommand: print listmode prompt
			CON_ListCtdPrompt();
		} else {
			// normal command: print standard prompt
			CON_AddLine( con_prompt );
		}

	} else {

		// command was not executed, but only
		// written to an output script

		if ( HistoryForBatchEntry )
			AddLineToHistory( con_lines[ con_bottom ] + PROMPT_SIZE );
		CON_AddLine( con_prompt );
	}
}


// fetch history list entry into current console line -------------------------
//
PRIVATE
void FetchHistoryEntry( int entryid )
{
	EraseConLine( con_bottom );
	strcpy( con_lines[ con_bottom ], con_prompt );

	if ( con_in_talk_mode ) {

		// handle talkmode
		if ( ( strncmp( history_list[ entryid ], CMSTR( CM_SAY ), CMLEN( CM_SAY ) ) == 0 ) &&
			 ( history_list[ entryid ][ CMLEN( CM_SAY ) ] == ' ' ) ) {

			// strip "say " in order to produce correct talkmode input
			strcpy( con_lines[ con_bottom ] + PROMPT_SIZE, history_list[ entryid ] + CMLEN( CM_SAY ) + 1 );

		} else {

			// prepend '/' escape char in order to produce correct talkmode input
			con_lines[ con_bottom ][ PROMPT_SIZE ] = talk_escape_char;
			strncpy( con_lines[ con_bottom ] + PROMPT_SIZE + 1,
					 history_list[ entryid ],
					 MAX_CONSOLE_LINE_LENGTH - PROMPT_SIZE - 1 );
			con_lines[ con_bottom ][ MAX_CONSOLE_LINE_LENGTH ] = 0;
		}

	} else {

		// use history line as is
		strcpy( con_lines[ con_bottom ] + PROMPT_SIZE, history_list[ entryid ] );
	}

	// set cursor behind end of command
	cursor_x = strlen( con_lines[ con_bottom ] + PROMPT_SIZE );

	// ensure proper view alignment
	edit_ofs_x = ( cursor_x > ConsoleEnterLength ) ?
		( cursor_x - ConsoleEnterLength ) : 0;
}


// handle text input in console window (ASCII only for now) -------------------
//
void CON_HandleTextInput(const char character)
{
	if (await_keypress && com_cont_func)
		return;

	// don't write console open/close key
	if (character == '`' || character == '~')
		return;

	int curlinelen = strlen( con_lines[ con_bottom ] + PROMPT_SIZE );

	// typeable characters
	if ( ( character & CON_ASCII_MASK ) && (character <= CON_ASCII_MASK) && (cursor_x < edit_max_x ) ) {
		if ( insert_mode && ( cursor_x < curlinelen ) ) {
			if ( curlinelen < edit_max_x ) {
				strcpy( paste_str, con_lines[ con_bottom ] + PROMPT_SIZE + cursor_x );
				strcpy( con_lines[ con_bottom ] + PROMPT_SIZE + cursor_x + 1, paste_str );
				con_lines[ con_bottom ][ PROMPT_SIZE + cursor_x++ ] = (byte) character;
			}
		} else {
			con_lines[ con_bottom ][ PROMPT_SIZE + cursor_x++ ] = (byte) character;
		}
	}
}


// handle keypresses in console window ----------------------------------------
//
void CON_HandleKeyPress(dword key)
{
	int curlinelen = strlen( con_lines[ con_bottom ] + PROMPT_SIZE );

	if ( await_keypress && com_cont_func ) {

		// <space> or <enter> continues listing
		if ( ( key == CKC_SPACE ) || ( key == CKC_ENTER ) ) {

			EraseConLine( con_bottom );
			strcpy( con_lines[ con_bottom ], con_prompt );
			// ensure wait prompt gets overwritten
			con_bottom  = last_con_bottom;
			con_content = last_con_content;
			cursor_x    = 0;
			com_cont_func();

		// <escape> returns to command prompt immediately
		} else if ( key == CKC_ESCAPE ) {

			await_keypress = FALSE;
			com_cont_func  = NULL;
			if ( con_in_talk_mode ) {
				// restore talkmode prompt
				CreateSeparatorLine( con_bottom );
				CON_AddLineFeed();
				con_talk_line = con_bottom;
			} else {
				// restore standard prompt
				EraseConLine( con_bottom );
				strcpy( con_lines[ con_bottom ], con_prompt );
			}
			cursor_x = 0;
		}

	} else if ( key == CKC_ESCAPE ||
				key == CKC_CURSORUP ||
				key == CKC_CURSORDOWN ||
				key == CKC_CURSORLEFT ||
				key == CKC_CURSORRIGHT ||
				key == CKC_HOME ||
				key == CKC_END ||
				key == CKC_PAGEUP ||
				key == CKC_PAGEDOWN ||
				key == CKC_INSERT ||
				key == CKC_DELETE ||
				key == CKC_TAB ||
				key == CKC_ENTER ||
				key == CKC_BACKSPACE ) {

		// control keys (CKC_xx)
		switch ( key ) {

		// <escape>: erase entire command line
		case CKC_ESCAPE:
			EraseConLine( con_bottom );
			strcpy( con_lines[ con_bottom ], con_prompt );
			history_scan  = history_add;
			cursor_x      = 0;
			con_back_view = 0;
			return;
			break;

		// <cursor-up>: scroll one line up in history buffer
		case CKC_CURSORUP:
			if ( !con_logged_in )
				break;
			if ( *( history_list[ ( history_scan - 1 ) & NUM_HISTORY_LINES_MASK ] ) != 0 ) {
				history_scan = ( history_scan - 1 ) & NUM_HISTORY_LINES_MASK;
				FetchHistoryEntry( history_scan );
			}
			break;

		// <cursor-down>: scroll one line down in history buffer
		case CKC_CURSORDOWN:
			if ( !con_logged_in )
				break;
			if ( *( history_list[ ( history_scan + 1 ) & NUM_HISTORY_LINES_MASK ] ) != 0 ) {
				history_scan = ( history_scan + 1 ) & NUM_HISTORY_LINES_MASK;
				FetchHistoryEntry( history_scan );
			}
			break;

		// <cursor-left>: set cursor one position left
		case CKC_CURSORLEFT:
			if ( cursor_x > 0 )
				cursor_x--;
			break;

		// <cursor-right>: set cursor one position right
		case CKC_CURSORRIGHT:
			if ( cursor_x < curlinelen )
				cursor_x++;
			break;
/*
		// <shift + cursor-up>: view one line backward
		case CKC_CURSORUP_SHIFTED:
			if ( !con_logged_in || con_in_talk_mode )
				break;
			if ( con_back_view < CONSOLE_MAX_BACK_LINES )
				con_back_view++;
			break;

		// <shift + cursor-down>: view one line forward
		case CKC_CURSORDOWN_SHIFTED:
			if ( !con_logged_in || con_in_talk_mode )
				break;
			if ( con_back_view > 0 )
				con_back_view--;
			break;

		// <shift + cursor-left>: set cursor one word to the left
		case CKC_CURSORLEFT_SHIFTED:
			while ( ( cursor_x > 0 ) &&
					!isalnum( con_lines[ con_bottom ][ PROMPT_SIZE + cursor_x - 1 ] ) )
				cursor_x--;
			while ( ( cursor_x > 0 ) &&
					isalnum( con_lines[ con_bottom ][ PROMPT_SIZE + cursor_x - 1 ] ) )
				cursor_x--;
			break;

		// <shift + cursor-right>: set cursor one word to the right
		case CKC_CURSORRIGHT_SHIFTED:
			while ( ( cursor_x < curlinelen ) &&
					isalnum( con_lines[ con_bottom ][ PROMPT_SIZE + cursor_x ] ) )
				cursor_x++;
			while ( ( cursor_x < curlinelen ) &&
					!isalnum( con_lines[ con_bottom ][ PROMPT_SIZE + cursor_x ] ) )
				cursor_x++;
			break;
*/
		// <home>: set cursor to first column
		case CKC_HOME:
			cursor_x = 0;
			break;

		// <end>: set cursor behind last column
		case CKC_END:
			cursor_x = curlinelen;
			break;

		// <page-up>: view one page backward
		case CKC_PAGEUP:
			if ( !con_logged_in )
				break;
			if ( cur_vis_conlines <= 0 )
				break;
			if ( con_back_view < CONSOLE_MAX_BACK_LINES )
				con_back_view += cur_vis_conlines;
			if ( con_back_view > CONSOLE_MAX_BACK_LINES )
				con_back_view = CONSOLE_MAX_BACK_LINES;
			break;

		// <page-down>: view one page forward
		case CKC_PAGEDOWN:
			if ( !con_logged_in )
				break;
			if ( cur_vis_conlines <= 0 )
				break;
			if ( con_back_view > 0 )
				con_back_view -= cur_vis_conlines;
			if ( con_back_view < 0 )
				con_back_view = 0;
			break;

		// <insert>: toggle insert mode
		case CKC_INSERT:
			insert_mode = !insert_mode;
			break;

		// <del>: delete and shift left
		case CKC_DELETE:
			if ( cursor_x < curlinelen ) {
				strcpy( paste_str, con_lines[ con_bottom ] + PROMPT_SIZE + cursor_x + 1 );
				strcpy( con_lines[ con_bottom ] + PROMPT_SIZE + cursor_x, paste_str );
			}
			break;

		// <tab>: find completion for current input
		case CKC_TAB:
			if ( !con_logged_in )
				break;
			CompleteCommand();
			break;

		// <enter>: execute current line
		case CKC_ENTER:
			EnterConsoleCommand();
			break;

		// <backspace>: step left and shift righthand side left
		case CKC_BACKSPACE:
			if ( cursor_x > 0 ) {
				if ( cursor_x == curlinelen ) {
					cursor_x--;
					con_lines[ con_bottom ][ PROMPT_SIZE + cursor_x ] = 0;
				} else {
					cursor_x--;
					strcpy( paste_str, con_lines[ con_bottom ] + PROMPT_SIZE + cursor_x + 1 );
					strcpy( con_lines[ con_bottom ] + PROMPT_SIZE + cursor_x, paste_str );
				}
			}
			break;
		}
	}

	if (key == CKC_ENTER || key == CKC_ESCAPE) {
		// hide QuickSay console if the main console isn't open
		if (KeybFlags->ConEnabled && KeybFlags->ConActive && cur_vis_conlines <= 0)
			SetQuicksayConsole(FALSE);
	}
}


//NOTE:
// this declaration is in global scope because of the extern "C".
// only gcc needs the otherwise redundant curly braces, however.


// set quicksay console state -------------------------------------------------
//
void SetQuicksayConsole( int enable )
{
	if ( enable ) {

		KeybFlags->ConEnabled = TRUE;
		KeybFlags->ConActive  = TRUE;

	} else {
		// FIXME: unintentionally disables main console input in some situations
		KeybFlags->ConEnabled  = FALSE;
	}
}


// draw quicksay console ------------------------------------------------------
//
int QuicksayConsole()
{
	// check whether main console has turned quicksay off
	if ( !KeybFlags->ConEnabled || !KeybFlags->ConActive ) {
		return FALSE;
	}

	// ensure proper edit line viewing window
	if ( cursor_x < edit_ofs_x ) {
		edit_ofs_x = cursor_x;
	} else if ( cursor_x > edit_ofs_x + ConsoleEnterLength ) {
		edit_ofs_x = cursor_x - ConsoleEnterLength;
	}

	D_SetWStrContext( CharsetInfo[ HUD_CHARSETNO ].charsetpointer,
					  CharsetInfo[ HUD_CHARSETNO ].geompointer,
					  NULL,
					  CharsetInfo[ HUD_CHARSETNO ].width,
					  CharsetInfo[ HUD_CHARSETNO ].height );

	// determine chars to draw
	if ( edit_ofs_x == 0 ) {
		memcpy( draw_line, con_lines[ con_bottom ], ConsoleEnterLength + PROMPT_SIZE );
		draw_line[ ConsoleEnterLength + PROMPT_SIZE ] = 0;
	} else {
		memcpy( draw_line, con_lines[ con_bottom ], PROMPT_SIZE );
		draw_line[ PROMPT_SIZE - 1 ] = '<';
		memcpy( draw_line + PROMPT_SIZE, con_lines[ con_bottom ] + PROMPT_SIZE + edit_ofs_x, ConsoleEnterLength );
		draw_line[ ConsoleEnterLength + PROMPT_SIZE ] = 0;
	}

	int xpos = ConsoleTextX * CharsetInfo[ HUD_CHARSETNO ].width + console_frameofs_x;
	int ypos = 130;

	// draw background bar
	int barwidth  = ( ConsoleEnterLength + PROMPT_SIZE + 1 ) * CharsetInfo[ HUD_CHARSETNO ].width + 6;
	int barheight = CharsetInfo[ HUD_CHARSETNO ].height + 4;
	D_DrawTrRect( xpos - 3, ypos - 2, barwidth, barheight, TRTAB_PANELBACK );

	// draw line contents
	D_WriteTrString( draw_line, xpos, ypos, TRTAB_PANELTEXT );

	// maintain blinking of cursor if not done by main console
	if ( ConsoleSliding == 0 ) {
		cursor_state += CurScreenRefFrames;
	}

	// draw cursor
	if ( cursor_state & CURSOR_BLINK_SPEED ) {

		xpos  = ConsoleTextX + cursor_x - edit_ofs_x + PROMPT_SIZE;
		xpos *= CharsetInfo[ HUD_CHARSETNO ].width;
		xpos += console_frameofs_x;

		char *cursorstr = insert_mode ? insert_cursor : overwrite_cursor;
		D_WriteTrString( cursorstr, xpos, ypos, TRTAB_PANELTEXT );
	}

	// allow caller to check for disabling
	return KeybFlags->ConActive;
}


// draw console window --------------------------------------------------------
//
PRIVATE
void DrawConsole( int numlines )
{
	ASSERT( numlines >= 0 );

	if ( numlines > NUM_CONSOLE_LINES )
		numlines = NUM_CONSOLE_LINES;
	if ( ConsoleEnterLength < CONSOLE_MIN_ENTER_LENGTH )
		ConsoleEnterLength = CONSOLE_MIN_ENTER_LENGTH;

	// disable back-viewing if console not fully open
	if ( ConsoleSliding != ( ConsoleHeight << CONSOLE_SLIDE_SPEED ) ) {
		con_back_view = 0;
	}

	// set font spacing according to resolution
	int chrwidth = CharsetInfo[ HUD_CHARSETNO ].width;
	int linedist = CharsetInfo[ HUD_CHARSETNO ].height + 2;

	// determine whether translucency should be used
	int translucent = VID_TRANSLUCENCY_SUPPORTED;

	// draw console background
	int px = ConsoleTextX * chrwidth - console_frame_left;
	int py = ConsoleTextY * linedist - console_frame_top;
	int pw = ( ConsoleEnterLength + PROMPT_SIZE + 1 ) * chrwidth + ( console_frame_left * 2 );
	int ph = numlines * linedist + ( console_frame_top * 2 );

	if ( translucent ) {
		D_DrawTrRect( px + console_frameofs_x, py + console_frameofs_y,
					  pw, ph, TRTAB_PANELBACK );

		DRAW_PanelDecorations( px + console_frameofs_x, py + console_frameofs_y, pw, ph );
	}

	// return if caption invisible
	if ( numlines < 1 ) {
		return;
	}

	D_SetWStrContext( CharsetInfo[ HUD_CHARSETNO ].charsetpointer,
					  CharsetInfo[ HUD_CHARSETNO ].geompointer,
					  NULL,
					  CharsetInfo[ HUD_CHARSETNO ].width,
					  CharsetInfo[ HUD_CHARSETNO ].height );


	// display caption if console wide enough
	if ( (dword)ConsoleEnterLength >= strlen( console_caption ) - PROMPT_SIZE - 1 ) {
		D_WriteTrString( console_caption,
			  ConsoleTextX * chrwidth + console_frameofs_x,
			  ConsoleTextY * linedist + console_frameofs_y,
			  TRTAB_PANELTEXT );
	}

	// maintain blinking of cursor
	cursor_state += CurScreenRefFrames;

	int lineno    = 0;
	int numtodraw = numlines - CONSOLE_CAPTION_HEIGHT;

	// return if content invisible
	if ( numtodraw < 1 ) {
		return;
	}

	// calc content line to start with and number of lines to display
	if ( con_content < numtodraw ) {
		numtodraw     = con_content;
		con_back_view = 0;
	} else {
		lineno = ( con_bottom - numtodraw + 1 ) & NUM_CONSOLE_LINES_MASK;
		// allow viewing of past pages/lines
		if ( con_back_view > 0 ) {
			int backnum = con_content - numtodraw;
			if ( backnum < con_back_view )
				con_back_view = backnum;
			lineno = ( lineno - con_back_view ) & NUM_CONSOLE_LINES_MASK;
		}
	}

	// ensure proper edit line viewing window
	if ( cursor_x < edit_ofs_x ) {
		edit_ofs_x = cursor_x;
	} else if ( cursor_x > edit_ofs_x + ConsoleEnterLength ) {
		edit_ofs_x = cursor_x - ConsoleEnterLength;
	}

	int drawx = console_frameofs_x + ( ConsoleTextX ) * chrwidth;
	int drawy = console_frameofs_y + ( ConsoleTextY + CONSOLE_CAPTION_HEIGHT ) * linedist;

	// draw console content lines (except bottom)
	for ( int lct = numtodraw - 1; lct > 0; lct-- ) {

		memcpy( draw_line, con_lines[ lineno ], ConsoleEnterLength + PROMPT_SIZE );
		draw_line[ ConsoleEnterLength + PROMPT_SIZE ] = 0;

		D_WriteTrString( draw_line, drawx, drawy, TRTAB_PANELTEXT );

		drawy += linedist;
		lineno = ( lineno + 1 ) & NUM_CONSOLE_LINES_MASK;
	}

	// draw bottom console line
	if ( ( edit_ofs_x == 0 ) || ( con_back_view > 0 ) ) {
		memcpy( draw_line, con_lines[ lineno ], ConsoleEnterLength + PROMPT_SIZE );
		draw_line[ ConsoleEnterLength + PROMPT_SIZE ] = 0;
	} else {
		memcpy( draw_line, con_lines[ lineno ], PROMPT_SIZE );
		draw_line[ PROMPT_SIZE - 1 ] = '<';
		memcpy( draw_line + PROMPT_SIZE, con_lines[ lineno ] + PROMPT_SIZE + edit_ofs_x, ConsoleEnterLength );
		draw_line[ ConsoleEnterLength + PROMPT_SIZE ] = 0;
	}

#ifdef FORCE_CONSOLE_LOGIN

	// hide bottom line during login mode
	if ( con_login_mode ) {
		for ( int spos = 0; spos < ConsoleEnterLength; spos++ ) {
			if ( draw_line[ spos + PROMPT_SIZE ] == 0 )
				break;
			draw_line[ spos + PROMPT_SIZE ] = '*';
		}
	}

#endif // FORCE_CONSOLE_LOGIN

	D_WriteTrString( draw_line, drawx, drawy, TRTAB_PANELTEXT );

	// cursor only if no back-viewing
	if ( con_back_view == 0 ) {

		// draw cursor
		if ( !KeybFlags->ConActive || ( cursor_state & CURSOR_BLINK_SPEED ) ) {

			// determine type of cursor (insert/overwrite)
			char *cursorstr = insert_mode ? insert_cursor : overwrite_cursor;

			int curcursorline = numtodraw + CONSOLE_CAPTION_HEIGHT - 1;

			drawx = ConsoleTextX + cursor_x - edit_ofs_x + PROMPT_SIZE;
			drawy = ConsoleTextY + curcursorline;

			drawx = console_frameofs_x + drawx * chrwidth;
			drawy = console_frameofs_y + drawy * linedist;

			D_WriteTrString( cursorstr, drawx, drawy, TRTAB_PANELTEXT );
		}
	}
}


// main console function: process keyboard input and draw console window ------
//
PRIVATE
void ConsoleMain( int numlines )
{
	ASSERT( numlines >= 0 );

	// set number of currently visible console lines
	// (negative values allowed!)
	cur_vis_conlines = numlines - CONSOLE_CAPTION_HEIGHT;

	// draw console
	DrawConsole( numlines );
}


// control console sliding ----------------------------------------------------
//
void ConsoleControl()
{
	//NOTE:
	// this function is called from within the gameloop.
	// (G_MAIN::GameLoop().)

	//NOTE:
	// ( ConsoleSliding == 0 ) means the console
	// is currently not visible.

	if ( ConsoleSliding != 0 ) {

		int concurheight = ConsoleHeight;
		int conslidemax  = ConsoleHeight << CONSOLE_SLIDE_SPEED;

		if ( ConsoleSliding < 0 ) {

			if ( ConsoleSliding < -CurScreenRefFrames ) {

				// slide console up
				ConsoleSliding += CurScreenRefFrames;

			} else {

				// console is fully up: disable it
				ConsoleSliding		  = 0;
				KeybFlags->ConEnabled = FALSE;
			}

			// derive current height from ConsoleSliding
			concurheight = ( -ConsoleSliding ) >> CONSOLE_SLIDE_SPEED;

		} else if ( ConsoleSliding != conslidemax ) {

			//NOTE:
			// if the console is open (and not in the process
			// of being closed) its size should be conslidemax.
			// if this is not the case try to reach this goal by
			// sliding up or down, respectively.

			if ( ConsoleSliding < conslidemax ) {

				// try to reach conslidemax by sliding down
				ConsoleSliding += CurScreenRefFrames;

				// guard against overshoot
				if ( ConsoleSliding > conslidemax )
					ConsoleSliding = conslidemax;

			} else {

				// try to reach conslidemax by sliding up
				ConsoleSliding -= CurScreenRefFrames;

				// guard against overshoot
				if ( ConsoleSliding < conslidemax )
					ConsoleSliding = conslidemax;

				// get extent bounds
				maxconext_s exs;
				GetMaxConExtents( &exs );

				// ensure console height is not invalid while
				// sliding up and trying to reach its valid end-height
				int curheight = ConsoleSliding >> CONSOLE_SLIDE_SPEED;
				if ( exs.c_y + curheight > exs.c_h ) {
					curheight      = exs.c_h - exs.c_y;
					ConsoleSliding = curheight << CONSOLE_SLIDE_SPEED;
				}
			}

			// derive current height from ConsoleSliding
			concurheight = ConsoleSliding >> CONSOLE_SLIDE_SPEED;
		}

		// draw console
		ConsoleMain( concurheight );
	}
}


// toggle console on/off (slide down and up, respectively) --------------------
//
void ToggleConsole()
{
	//NOTE:
	// this function is called from within the gameloop
	// if the console toggle key has been pressed.
	// (G_MAIN::SpecialKeyFunctions().)

	//NOTE:
	// ( ConsoleSliding == 0 ) means the console
	// is currently not visible. otherwise it will
	// either be negative (sliding up) or positive
	// (sliding down or currently at full size).

	// slide console down if currently off
	if ( ConsoleSliding == 0 ) {

		KeybFlags->ConEnabled = TRUE;
		HelpActive	   		  = FALSE;
		ConsoleSliding		  = 1;

		//NOTE:
		// after ConsoleSliding has been set to 1
		// it will be increased by ConsoleControl()
		// until it reaches full height. there
		// it will stay until the console is closed
		// or ConsoleHeight is altered to change
		// the console's height. (whereafter
		// ConsoleControl() will once again try to
		// achieve ( ConsoleSliding == ConsoleHeight*fac )
		// by sliding up or down, as needed.

		// hide certain screen elements
		SlideOutFloatingMenu();
		FadeOutCockpit();
		MAP_FadeOutStarmap();

		// ensure no dangling keys in
		// console's keyboard buffer
		FlushConsoleBuffer();

	} else {

		// invert direction of sliding
		ConsoleSliding = -ConsoleSliding;

#ifdef LOSE_KEYBOARD_FOCUS_ON_SLIDEUP

		// console loses focus if sliding up
		KeybFlags->ConEnabled = ( ConsoleSliding > 0 );

#endif // LOSE_KEYBOARD_FOCUS_ON_SLIDEUP

		// display/hide certain screen elements
		if ( ConsoleSliding < 0 ) {

			SlideInFloatingMenu();
			FadeInCockpit();
			MAP_FadeInStarmap();

		} else {

			SlideOutFloatingMenu();
			FadeOutCockpit();
			MAP_FadeOutStarmap();
		}
	}
}