diff options
Diffstat (limited to 'src/parsec_server/con_main_sv.cpp')
| -rwxr-xr-x | src/parsec_server/con_main_sv.cpp | 1586 |
1 files changed, 1586 insertions, 0 deletions
diff --git a/src/parsec_server/con_main_sv.cpp b/src/parsec_server/con_main_sv.cpp new file mode 100755 index 0000000..4de9331 --- /dev/null +++ b/src/parsec_server/con_main_sv.cpp @@ -0,0 +1,1586 @@ +/* + * PARSEC - Server Console Main Module + * + * $Author: uberlinuxguy $ - $Date: 2004/09/26 03:43:47 $ + * + * Orginally written by: + * Copyright (c) Clemens Beer <cbx@parsec.org> 2001 + * 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_sv.h" +//#include "vid_defs.h" + +// drawing subsystem +//#include "d_bmap.h" +//#include "d_font.h" + +// local module header +#include "con_main_sv.h" + +// proprietary module headers +#include "con_act_sv.h" +#include "con_arg.h" +#include "con_aux_sv.h" +#include "con_com_sv.h" +//#include "con_conf.h" +#include "con_ext_sv.h" +#include "con_info_sv.h" +#include "con_int_sv.h" +//#include "con_kmap.h" +#include "con_list_sv.h" +//#include "con_rc.h" +#include "con_std_sv.h" +#include "con_tab.h" +#include "con_vald.h" +//#include "e_color.h" +//#include "e_demo.h" +//#include "e_draw.h" +#include "net_limits.h" +#include "net_defs.h" +#include "e_gameserver.h" +//#include "g_supp.h" +//#include "h_cockpt.h" +//#include "h_strmap.h" +#include "inp_main_sv.h" +#include "keycodes.h" +//#include "m_main.h" +#include "sys_path.h" +#include "sys_swap.h" + +// CURSES library ------------------------------------------------------------- +#ifdef USE_CURSES + #ifdef SYSTEM_WIN32_UNUSED + #pragma comment( lib, "curses.lib" ) + #endif // SYSTEM_WIN32_UNUSED +#endif // USE_CURSES + +// 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 +#define CONSOLE_OUTPUT_WORKAROUND + + +// 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_sv" CON_FILE_EXTENSION; +PUBLIC char boot_script_master_name[] = "boot_ms" CON_FILE_EXTENSION; +static char demo_script_name[] = "demo_sv" 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: \"%s\""; +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 = FALSE; +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 ]; + + +// CURSES library ------------------------------------------------------------- +// +#ifdef USE_CURSES + WINDOW* g_curses_in_win = NULL; + WINDOW* g_curses_out_win = NULL; +#endif // USE_CURSES + + +// 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 ); + wclear( g_curses_in_win ); + cursor_x = 0; +} + + +// 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; + if(TheServer->GetServerIsMaster()){ + startupscript = boot_script_master_name; + } else { + startupscript = 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; + if(TheServer->GetServerIsMaster()){ + startupscript = boot_script_master_name; + } else { + startupscript = boot_script_name; + } + ExecConsoleFile( startupscript, echo ); + } +} + +// init CURSES windows -------------------------------------------------------- +// +void CON_InitCurses() +{ +#ifdef USE_CURSES + + initscr(); + cbreak(); + //echo(); + + + // create input window + g_curses_in_win = newwin( 1, COLS, LINES - 1, 0 ); + //wattrset( g_curses_in_win, A_REVERSE ); + keypad( g_curses_in_win, TRUE ); + nodelay( g_curses_in_win, TRUE ); + + // create output window ( -1 to ensure we do not overwrite the input window ) + g_curses_out_win = newwin( LINES - 1, COLS, 0, 0 ); + nodelay( g_curses_out_win, TRUE ); + + // scrolling is ok + scrollok( g_curses_in_win, TRUE ); + scrollok( g_curses_out_win, TRUE ); + + //slk_init( 1 ); + /*slk_set(1, "Insert", 0); + slk_set(2, "Quit", 0); + slk_set(3, "Add", 0); + slk_set(4, "Delete", 0); + slk_set(5, "Undo", 0); + slk_set(6, "Search", 0); + slk_set(7, "Replace", 0); + slk_set(8, "Save", 0); + slk_refresh(); + */ + + +#endif // USE_CURSES +} + + +// kill all CURSES windows and related stuff ---------------------------------- +// +void CON_KillCurses() +{ +#ifdef USE_CURSES + nocbreak(); + echo(); + endwin(); +#endif // USE_CURSES +} + + +// init memory needed for console --------------------------------------------- +// +void CON_InitConsole() +{ + ASSERT( !console_init_done ); + + if ( !console_init_done ) { + int lid; + // erase console contents + for ( lid = 0; lid < NUM_CONSOLE_LINES; lid++ ) { + memset( con_lines[ lid ], 0, MAX_CONSOLE_LINE_LENGTH + 1 ); + } + + // 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; + + EraseConLine( con_bottom ); + strcpy( con_lines[ con_bottom ], con_prompt ); + +#ifdef PROCESS_STARTUP_SCRIPT + + // there's no reason to run the external scripts when we are only + // running in master server mode. + if(!TheServer->GetServerIsMaster()) { + // build list of external commands + BuildExternalCommandList(); + + // exec boot.con (also for registered mods) + ExecStartupScript( ECHO_STARTUP_SCRIPT ); + } +#endif // PROCESS_STARTUP_SCRIPT + + //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() +{ +//FIXME: needed on server ? + +/* // 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 CON_KillConsole() +{ + if ( console_init_done ) { + console_init_done = FALSE; + + InitConsoleFileHandling(); + } +} + + +// flush keyboard buffer for console ------------------------------------------ +// +void FlushConsoleBuffer() +{ + dword *pos; + + while ( *( pos = &KeybBuffer->Data + KeybBuffer->ReadPos ) ) { + KeybBuffer->ReadPos = ( KeybBuffer->ReadPos + 1 ) % KEYB_BUFF_SIZ; + *pos = 0; + } +} + + +// add new message to console (preserve current input) ------------------------ +// +PUBLIC +void CON_AddMessage( const char *text ) +{ + ASSERT( text != NULL ); + + // normal message output + MSGOUT( text ); +} + + +// flag whether next CON_AddLine() should overwrite the current line ---------- +// +static int skip_next_nl = FALSE; + + +// add new line to console ---------------------------------------------------- +// +PUBLIC +void CON_AddLine( const char *text ) +{ + ASSERT( text != NULL ); + + // normal text output + MSGOUT( text ); +} + + +// add line feed in console --------------------------------------------------- +// +PUBLIC +void CON_AddLineFeed() +{ + // force line feed + skip_next_nl = FALSE; + CON_AddLine( con_prompt ); +} + + +// set flag to disable next line feed in CON_AddLine() ------------------------ +// +PUBLIC +void CON_DisableLineFeed() +{ + // set flag + skip_next_nl = TRUE; +} + + +// set flag to not eat next line feed in CON_AddLine() ------------------------ +// +PUBLIC +void CON_EnableLineFeed() +{ + // clear flag + skip_next_nl = FALSE; +} + + +// delete current console line ------------------------------------------------ +// +PUBLIC +void CON_DelLine() +{ + EraseConLine( con_bottom ); +} + + +// return pointer to current console line ------------------------------------- +// +PUBLIC +char *CON_GetLine() +{ + return con_lines[ con_bottom ]; +} + + +// print prompt for list continuation ----------------------------------------- +// +PUBLIC +void CON_ListCtdPrompt() +{ + CON_AddLine( press_space ); + + // ensure proper view alignment + edit_ofs_x = ( cursor_x > ConsoleEnterLength ) ? ( cursor_x - ConsoleEnterLength ) : 0; +} + + +// print prompt after list has ended ------------------------------------------ +// +PUBLIC +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 ); + } +} + + +// check geometric extents of console window ---------------------------------- +// +void CheckConExtents() +{ + ASSERT( FALSE ); +} + + +// 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(strncmp(scan, int_commands[ icom ].command, strlen(int_commands[ icom ].command)) ==0) { + 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) + char *scan = strtok( command, " " ); + + // 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( scan ) ) { + } else if ( CheckKeyMappingSilent( scan ) ) { + */} else if ( CheckSetIntArray( int_print_base, scan, auxflag_array_name, AuxEnabling, MAX_SV_ARRAY_SIZE ) ) { + } else { + // printout the command that could not be found + char szBuffer[ 512 ]; + sprintf( szBuffer, unknown_command, scan ); + CON_AddLine( szBuffer ); + } + } 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 ) ) { + + // printout the command that could not be found + char szBuffer[ 512 ]; + sprintf( szBuffer, unknown_command, command ); + CON_AddLine( szBuffer ); + + 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(); + + // output command + CON_AddLine( con_lines[ con_bottom ] ); + + // 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 ); + } + + EraseConLine( con_bottom ); + strcpy( con_lines[ con_bottom ], 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; +} + + +// check input for console window --------------------------------------------- +// +PRIVATE +bool_t CheckConsoleInput() +{ + // scan keyboardbuffer and process key-presses sequentially + dword *pos; + bool_t console_input_done = false; + while ( *( pos = &KeybBuffer->Data + KeybBuffer->ReadPos ) ) { + + int curlinelen = strlen( con_lines[ con_bottom ] + PROMPT_SIZE ); + + if ( await_keypress && com_cont_func ) { + + // <space> or <enter> continues listing + if ( ( *pos == CKC_SPACE ) || ( *pos == 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 ( *pos == 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 ( *pos & CKC_CTRL_MASK ) { + + // control keys (CKC_xx) + switch ( *pos ) { + + // <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; + 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 || con_in_talk_mode ) + 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 || con_in_talk_mode ) + 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; + } + + } else { + + // typeable characters + if ( ( ConsoleASCIIValid[ *pos & 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)*pos; + } + } else { + con_lines[ con_bottom ][ PROMPT_SIZE + cursor_x++ ] = (byte)*pos; + } + } + } + + // advance one position in circular keybuffer + KeybBuffer->ReadPos = ( KeybBuffer->ReadPos + 1 ) % KEYB_BUFF_SIZ; + *pos = 0; + + console_input_done = true; + } + + return console_input_done; +} + + +// type for writestring function pointer -------------------------------------- +// +typedef void (*WSFP)( ... ); + +//NOTE: +// this declaration is in global scope because of the extern "C". +// only gcc needs the otherwise redundant curly braces, however. + + + +// process quicksay console input and draw it --------------------------------- +// +int QuicksayConsole() +{ +/* // check whether main console has turned quicksay off + if ( !KeybFlags->ConEnabled || !KeybFlags->ConActive ) { + return FALSE; + } + + dword *pos; + dword readpos = KeybBuffer->ReadPos; + + // scan console input buffer for ESCAPE or ENTER which + // should turn off quicksay mode again + while ( *( pos = &KeybBuffer->Data + readpos ) ) { + + if ( *pos == CKC_ESCAPE || *pos == CKC_ENTER ) { + SetQuicksayConsole( FALSE ); + } + + readpos = ( readpos + 1 ) % KEYB_BUFF_SIZ; + } + + // use standard input handling + CheckConsoleInput(); + + // 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; + } + + // determine whether translucency should be used + int translucent = VID_TRANSLUCENCY_SUPPORTED; + + D_SetWStrContext( CharsetInfo[ HUD_CHARSETNO ].charsetpointer, + CharsetInfo[ HUD_CHARSETNO ].geompointer, + NULL, + CharsetInfo[ HUD_CHARSETNO ].width, + CharsetInfo[ HUD_CHARSETNO ].height ); + + // write text translucent only for color depths below 32 bit per pixel + WSFP wsfp = translucent ? (WSFP) &D_WriteTrString : (WSFP) &D_WriteString; + + // 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 + wsfp( 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; + wsfp( cursorstr, xpos, ypos, TRTAB_PANELTEXT ); + } + + // allow caller to check for disabling + return KeybFlags->ConActive; + */ + + return FALSE; +} + + +// draw console window -------------------------------------------------------- +// +PRIVATE +void DrawConsole( bool_t bClear ) +{ + //NOTE: in order to minimize screen flicker, we only clear the inputline, + // if the previous contents was longers + if ( bClear ) + wclear( g_curses_in_win ); + + mvwprintw( g_curses_in_win, 0, 0, con_lines[ con_bottom ] ); + wmove( g_curses_in_win, 0, cursor_x + PROMPT_SIZE ); + wrefresh( g_curses_in_win ); +} + + +// main console function: process keyboard input and draw console window ------ +// +PUBLIC +void CON_ConsoleMain() +{ + static bool_t init_prompt_drawn = false; + + // set number of currently visible console lines + // (negative values allowed!) + cur_vis_conlines = ConsoleHeight; + + unsigned int len_before = strlen( con_lines[ con_bottom ] ); + + // process console keyboard input + if ( CheckConsoleInput() || !init_prompt_drawn ) { + + init_prompt_drawn = true; + // draw console + DrawConsole( len_before > strlen( con_lines[ con_bottom ] ) ); + } +} |