/*
 * PARSEC - External Commands
 *
 * $Author: uberlinuxguy $ - $Date: 2004/09/15 12:25:23 $
 *
 * Orginally written by:
 *   Copyright (c) Markus Hadwiger     <msh@parsec.org>   1996-2001
 *
 *  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 <stddef.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 "objstruc.h"

// global externals
#include "globals.h"

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

// proprietary module headers
#include "con_act.h"
#include "con_aux.h"
#include "con_list.h"
#include "con_main.h"
#include "con_std.h"
#include "con_vald.h"
#include "e_demo.h"
#include "e_record.h"
#include "e_replay.h"
#include "sys_file.h"
#include "sys_path.h"



// maximum depth of recursion in command batch files
#define MAX_BATCH_REC_DEPTH		16

// special eof needed in package console scripts
#define PACKAGE_CON_EOF			";eof"
#define PACKAGE_CON_EOF_LEN		4

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

// string constants
static char con_extension[]		= CON_FILE_EXTENSION;
static char invalid_batch_name[]= "invalid name specifier.";
static char recursion_canceled[]= "command canceled due to recursion.";
static char recursion_maxdepth[]= "maximum recursion depth reached.";
static char replaying_script[]	= "replay in progress (script).";
static char replaying_binary[]	= "replay in progress (binary).";
static char no_replay[]			= "no replay in progress.";
static char stopped_replay[]	= "replay has been stopped.";
static char record_disallowed[]	= "recording not allowed (object camera is active).";

static char con_file_wldcard1[]	= "*" CON_FILE_EXTENSION;
static char con_file_wldcard2[] = REFCON_COMMANDS_DIR "*" CON_FILE_EXTENSION;
static char con_file_wldcard3[] = STDCON_COMMANDS_DIR "*" CON_FILE_EXTENSION;
static char con_file_wldcard4[] = RECORD_COMMANDS_DIR "*" CON_FILE_EXTENSION;

// name of batch command file to execute on every gameloop start
char gameloop_start_script[ PATH_MAX + 1 ] = "";

// list of external commands
char external_commands[ MAX_EXTERNAL_COMMANDS + 1 ][ COMMAND_NAME_ALLOC_LEN + 1 ];
int  external_command_types[ MAX_EXTERNAL_COMMANDS + 1 ];
int	 num_external_commands = 0;

// external batch execution vars
int processing_batch = 0;	// flag that commands are called from batch
int idle_reclevel    = 0;	// level of recursion idle wait stalled execution on
int	rec_depth        = 0;	// current level of recursion

// action commands not allowed?
int preempt_action_commands = FALSE;

// batch execution recursive call stack
static int	extcom_on_level[ MAX_BATCH_REC_DEPTH + 1 ];
static FILE *fp_for_level[ MAX_BATCH_REC_DEPTH + 1 ];

// log file (created command batch)
FILE *log_fp;
char log_name[ COMMAND_NAME_ALLOC_LEN + 1 ];
int  log_commands = 0;

// recording file
static char record_name[ COMMAND_NAME_ALLOC_LEN + 1 ];

// packet recording/replay file names
char packet_record_name[ COMMAND_NAME_ALLOC_LEN + 1 ];
char packet_replay_name[ COMMAND_NAME_ALLOC_LEN + 1 ];

// single command line
static char com_line[ MAX_CONSOLE_LINE_LENGTH + 1 ];

// cat feature variables
static char cat_name[ MAX_CONSOLE_LINE_LENGTH + 1 ];
static int  cat_pos;

// current active mod name
PUBLIC char* mod_names[ MAX_REGISTERED_MODS ];
PUBLIC int   mod_numnames = 0;
PUBLIC int   mod_override = FALSE;


// acquire scripts located in mod directories ---------------------------------
//
PRIVATE
void AcquireModScripts()
{
	for ( int mod = 0; mod < mod_numnames; mod++ ) {

		char *path = (char *) ALLOCMEM(
			strlen( mod_names[ mod ] ) + strlen( con_file_wldcard1 ) + 2 );
		if ( path == NULL ) {
			OUTOFMEM( 0 );
		}

		strcpy( path, mod_names[ mod ] );
		strcat( path, "/" );
		strcat( path, con_file_wldcard1 );

		char *npath = SYSs_ProcessPathString( path );
		SYSs_AcquireScriptPath( npath, COMTYPE_MODIFICATION, mod_names[ mod ] );

		FREEMEM( path );
	}
}


// build list of externally available commands --------------------------------
//
void BuildExternalCommandList()
{
	//NOTE:
	// the sequence of paths scanned in this function mostly determines the
	// display order of console scripts (ls command, tab completion, ...).
	// the actual precedence of scripts is determined by the search order
	// in OpenScript(). for consistency, the two orders should be the same.

	num_external_commands = 0;

	SYS_AcquirePackageScripts( COMTYPE_PACKAGE );

	if ( mod_override ) {
		AcquireModScripts();
	}

	SYSs_AcquireScriptPath( con_file_wldcard1, COMTYPE_ROOT, NULL );
	SYSs_AcquireScriptPath( con_file_wldcard2, COMTYPE_REFERENCE, NULL );
	SYSs_AcquireScriptPath( con_file_wldcard3, COMTYPE_STANDARD, NULL );
	SYSs_AcquireScriptPath( con_file_wldcard4, COMTYPE_RECORDING, NULL );

	if ( !mod_override ) {
		AcquireModScripts();
	}
}


// check if string is valid external command ----------------------------------
//
int CheckExternalCommand( char *com )
{
	ASSERT( com != NULL );

	//NOTE:
	// command script directories are only scanned once. therefore,
	// new commands copied into a directory while the game is still
	// running will not be noticed until next startup or explicit
	// rescanning via the "rescan" command.

	// to ensure scripts with explicitly specified paths work
	com = SYSs_ProcessPathString( com );

	// scan list in memory (no directory rescanning!!)
	int cid = -1;
	for ( int eid = 0; eid < num_external_commands; eid++ ) {
		ASSERT( external_commands[ eid ] != NULL );
		if ( stricmp( external_commands[ eid ], com ) == 0 ) {
			cid = eid;
			break;
		}
	}

	// return command number + 1 (thus 0 means command is invalid)
	return ( cid + 1 );
}


// insert command into log file (command batch) -------------------------------
//
int InsertCommandLog( char *command )
{
	ASSERT( command != NULL );

	if ( log_commands && ( strcmp( command, CMSTR( CM_CLOSE ) ) != 0 ) ) {
		// append command to currently open logfile
		fprintf( log_fp, "%s\n", command );
		return TRUE;
	}

	return FALSE;
}


// search all console script paths and open batch if it exists ----------------
//
PRIVATE
FILE *OpenScript( char *script )
{
	ASSERT( script != NULL );

	//NOTE:
	// the sequence of paths scanned in this function determines the
	// precedence of console scripts of the same name but located in
	// different directories.

	//NOTE:
	// the path search sequence is:
	// 1. data package
	// 2. root (local) directory
	// 3. reference directory (refs)
	// 4. standard directory (cons)
	// 5. recording directory (recs)

	//NOTE:
	// to avoid inconsistencies the search order in E_RECORD::LoadPacket()
	// and E_DEMO::DEMO_BinaryOpenDemo() should be consistent
	// with the search order used here.

	FILE *fp = NULL;

	strcpy( paste_str, script );
	strcat( paste_str, con_extension );

	// to ensure scripts with explicitly specified paths work
	char *path = SYSs_ProcessPathString( paste_str );

	if ( !AUX_DISABLE_PACKAGE_SCRIPTS ) {

		// try to read from package first
		if ( ( fp = SYS_fopen( path, "r" ) ) != NULL ) {
			return fp;
		}
	}

	// search root (local) directory
	if ( ( fp = fopen( path, "r" ) ) != NULL ) {
		return fp;
	}

	strcpy( paste_str, REFCON_COMMANDS_DIR );
	strcat( paste_str, script );
	strcat( paste_str, con_extension );

	// search reference directory (refs)
	if ( ( fp = fopen( paste_str, "r" ) ) != NULL ) {
		return fp;
	}

	strcpy( paste_str, STDCON_COMMANDS_DIR );
	strcat( paste_str, script );
	strcat( paste_str, con_extension );

	// search standard directory (cons)
	if ( ( fp = fopen( paste_str, "r" ) ) != NULL ) {
		return fp;
	}

	strcpy( paste_str, RECORD_COMMANDS_DIR );
	strcat( paste_str, script );
	strcat( paste_str, con_extension );

	// search recording directory (recs)
	return fopen( paste_str, "r" );
}


// display content of command batch file --------------------------------------
//
PRIVATE
void CatExternalCommands_ctd()
{
	int  i = 0;

	FILE *fp = OpenScript( cat_name );

	if ( fp != NULL ) {

		SYS_fseek( fp, cat_pos, SEEK_SET );

		int packeof = 0;
		while ( SYS_fgets( com_line, MAX_CONSOLE_LINE_LENGTH, fp ) != NULL ) {

			// check special package eof
			if ( strncmp( com_line, PACKAGE_CON_EOF, PACKAGE_CON_EOF_LEN ) == 0 ) {
				packeof = 1;
				break;
			}

			ProcessExternalLine( com_line );
			CON_AddLine( com_line );
			if ( ++i >= cur_vis_conlines - 1 ) {
				break;
			}
		}

		if ( packeof || SYS_feof( fp ) ) {
			CON_ListEndPrompt();
		} else {
			CON_ListCtdPrompt();
			cat_pos = SYS_ftell( fp );
		}

		SYS_fclose( fp );
	}
}


// display content of command batch file (command "cat") ----------------------
//
int Cmd_CatExternalCommands( char *cstr )
{
	ASSERT( cstr != NULL );
	HANDLE_COMMAND_DOMAIN_SEP( cstr );

	char *name = strtok( cstr, " " );

	if ( ( name == NULL ) || ( strtok( NULL, " " ) != NULL ) ) {
		CON_AddLine( "syntax: cat <script>." );
		return TRUE;
	}

	if ( !CheckExternalCommand( name ) ) {
		CON_AddLine( "script not found." );
		return TRUE;
	}

	strcpy( cat_name, name );
	FILE *fp = OpenScript( cat_name );

	if ( fp != NULL ) {

		int i = 0;
		int packeof = 0;
		while ( SYS_fgets( com_line, MAX_CONSOLE_LINE_LENGTH, fp ) != NULL ) {

			// check special package eof
			if ( strncmp( com_line, PACKAGE_CON_EOF, PACKAGE_CON_EOF_LEN ) == 0 ) {
				packeof = 1;
				break;
			}

			ProcessExternalLine( com_line );
			CON_AddLine( com_line );
			if ( ++i >= cur_vis_conlines - 1 ) {
				break;
			}
		}

		if ( !packeof && !SYS_feof( fp ) ) {
			cat_pos		   = SYS_ftell( fp );
			await_keypress = TRUE;
			com_cont_func  = CatExternalCommands_ctd;
		}

		SYS_fclose( fp );
	}

	return TRUE;
}


// forward declaration --------------------------------------------------------
//
PRIVATE
int ExecExternalLine( char *line, int echo );


// execute console command file automatically on startup ----------------------
//
void ExecConsoleFile( char *fname, int echo )
{
	//NOTE:
	// the scripts recognized by this function NEED NOT be
	// contained in external_commands[] since files are opened
	// directly and no error will result if they are not found.

	//NOTE:
	// this function sets the preempt_action_commands flag
	// to prevent execution of all (also direct!) action
	// commands. the processing_batch flag also will not be
	// set by this function.

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

	FILE *fp = SYS_fopen( fname, "r" );

	if ( fp != NULL ) {

		// used to determine if invoked from CON_MAIN::InitConsole()
		extern int console_init_done;

		// put together console message
		sprintf( paste_str, "executing %s", fname );

		if ( !console_init_done ) {
			// invocation from InitConsole() (exec init script)
			if ( TextModeActive )
				MSGPUT( "Executing console script (%s)...", fname );
			CON_AddLine( paste_str );
		} else {
			if ( !AUX_DISABLE_LEVEL_CONSOLE_MESSAGES ) {
				// not invoked from InitConsole()
				CON_AddMessage( paste_str );
			}
		}

		// disallow action commands
		preempt_action_commands = TRUE;

		// execute script line for line
		strcpy( com_line, con_prompt );
		while ( SYS_fgets( com_line + 2, MAX_CONSOLE_LINE_LENGTH - 2, fp ) != NULL ) {

			// check special package eof
			if ( strncmp( com_line + 2, PACKAGE_CON_EOF, PACKAGE_CON_EOF_LEN ) == 0 ) {
				break;
			}

			ExecExternalLine( com_line, echo );
		}

		// allow action commands once again
		preempt_action_commands = FALSE;

		// insert new prompt
		if ( console_init_done && echo )
			CON_AddLine( con_prompt );

		if ( TextModeActive ) {
			if ( AUX_CMD_WRITE_ACTIVE_IN_TEXTMODE ) {
				MSGOUT( "\nScript execution done." );
			} else {
				MSGOUT( "done." );
			}
		}

		SYS_fclose( fp );
	}
}


// scan external line, overwrite invalid characters with space ----------------
//
int ProcessExternalLine( char *scan )
{
	ASSERT( scan != NULL );

	int exec = 0;

	while ( *scan != 0 ) {
		if ( ( *scan == '\r' ) || ( *scan == '\n' ) ) {
			// strip '\r' and '\n' at end of line
			*scan-- = 0;
		} else if ( !ConsoleASCIIValid[ (byte) *scan ] ) {
			if ( ( *scan == '\\' ) && ConsoleASCIIValid[ (byte) '/' ] ) {
				// replace backslashes with slashes
				*scan = '/';
			} else {
				// replace invalid characters with spaces
				*scan = ' ';
			}
		} else {
			// convert valid characters to lower-case
			*scan = tolower( *scan );
			exec  = 1;
		}
		scan++;
	}

	return exec;
}


// execute externally obtained console line -----------------------------------
//
PRIVATE
int	ExecExternalLine( char *line, int echo )
{
	ASSERT( line != NULL );
	ASSERT( ( echo == FALSE ) || ( echo == TRUE ) );

	//NOTE:
	// a ';' in the first column starts a comment

	int exec = FALSE;
	if ( *( line + 2 ) != ';' ) {

		if ( ProcessExternalLine( line + 2 ) ) {
			if ( echo )
				CON_AddLine( line );
			ExecConsoleCommand( line + 2, echo );
			exec = TRUE;
		}
	}

	// count executed commands
	if ( !DEMO_BinaryReplayActive() ) {
		demoinfo_curline++;
	}

	return exec;
}


// execute all lines of external command batch --------------------------------
//
PRIVATE
void ExecLines( int echo )
{
	//NOTE:
	// this function is used by ExecExternalCommand(),
	// RestartExternalCommand(), and ExecExternalFile()
	// to execute all lines of a single console file.
	// it will be called recursively if a script invokes
	// another script.

	ASSERT( ( echo == FALSE ) || ( echo == TRUE ) );

	// go one recursion level down
	rec_depth++;

	strcpy( com_line, con_prompt );
	while ( SYS_fgets( com_line + 2, MAX_CONSOLE_LINE_LENGTH - 2, fp_for_level[ rec_depth - 1 ] ) != NULL ) {

		// check special package eof
		if ( strncmp( com_line + 2, PACKAGE_CON_EOF, PACKAGE_CON_EOF_LEN ) == 0 ) {
			break;
		}

		// execute current line
		ExecExternalLine( com_line, echo );

		// stall recursion if idlewait specified
		if ( CurActionWait > 0 ) {
			break;
		}
	}

	// go one recursion level up
	rec_depth--;
}


// execute external command (command batch file) ------------------------------
//
PRIVATE
int ExecExternalCommand( int extcom, int echo )
{
	//NOTE:
	// this function simply assumes that the current
	// recursion level in rec_depth is valid and can
	// be used. it is called by CallExternalCommand()
	// which performs recursion level management.

	ASSERT( extcom >= 0 );
	ASSERT( ( echo == FALSE ) || ( echo == TRUE ) );

	// store number of command on this level
	extcom_on_level[ rec_depth ] = extcom;

	// try to open command file
	fp_for_level[ rec_depth ] = OpenScript( external_commands[ extcom ] );

	// exec command file
	if ( fp_for_level[ rec_depth ] != NULL ) {

		// store name to use as packet replay file
		ASSERT( strlen( external_commands[ extcom ] ) <= COMMAND_NAME_ALLOC_LEN );
		strcpy( packet_replay_name, external_commands[ extcom ] );

		// exec all lines of this batch
		ExecLines( echo );

		// keep file open if recursion stalled
		if ( CurActionWait == 0 ) {
			SYS_fclose( fp_for_level[ rec_depth ] );
			fp_for_level[ rec_depth ] = NULL;
		}

		return TRUE;
	}

	return FALSE;
}


// execute external command (command batch file) via filename -----------------
//
int ExecExternalFile( char *command )
{
	//NOTE:
	// this is the main internal interface to execute
	// a specified console script. (used to automatically
	// execute scripts on game loop entry and video
	// subsystem switches, for instance.) the scripts
	// recognized by this function need to be contained
	// in external_commands[].

	//NOTE:
	// the processing_batch flag will not be set by this
	// function. this means that most action commands
	// will not be allowed to execute.

	//CAVEAT:
	// no checks are performed whether any replay is
	// currently in progress and therefore execution
	// should be disallowed.

	if ( ( command == NULL ) || ( *command == 0 ) )
		return FALSE;

	int extcom = CheckExternalCommand( command );

	if ( extcom-- == 0 )
	   return FALSE;

	// store number of command on this level
	extcom_on_level[ rec_depth ] = extcom;

	// try to open command file
	fp_for_level[ rec_depth ] = OpenScript( external_commands[ extcom ] );

	// exec command file
	if ( fp_for_level[ rec_depth ] != NULL ) {

		// exec all lines of this batch
		ExecLines( FALSE );

		// keep file open if recursion stalled
		if ( CurActionWait == 0 ) {
			SYS_fclose( fp_for_level[ rec_depth ] );
			fp_for_level[ rec_depth ] = NULL;
		}

		return TRUE;
	}

	return FALSE;
}


// compile the state header script necessary for demo cutting -----------------
//
int CompileDemoCut( FILE *fp, char *script )
{
	ASSERT( fp != NULL );
	ASSERT( script != NULL );

	ASSERT( rec_depth == 0 );

	if ( num_external_commands == MAX_EXTERNAL_COMMANDS ) {
		return FALSE;
	}

	// make sure the script is known
	int extcom = CheckExternalCommand( script );
	if ( extcom == 0 ) {
		// if enough space append to list and set type to root
		ASSERT( strlen( script ) <= COMMAND_NAME_ALLOC_LEN );
		strcpy( external_commands[ num_external_commands ], script );
		external_command_types[ num_external_commands ] = COMTYPE_ROOT;
		extcom = ++num_external_commands;
	}

	// compile the script to already open file
	compile_fp       = fp;
	compile_script   = TRUE;
	processing_batch = TRUE;

	ExecExternalCommand( extcom - 1, FALSE );

	compile_fp       = NULL;
	processing_batch = FALSE;
	compile_script   = FALSE;

	return TRUE;
}


// determine if script replay currently in progress ---------------------------
//
int ScriptReplayActive()
{
	// if no recursion is stalled then no
	// replay is currently in progress
	return ( idle_reclevel > 0 );
}


// restart ExecExternalCommand() ----------------------------------------------
//
int RestartExternalCommand( int echo )
{
	//NOTE:
	// this function is called by E_REPLAY::FetchNewActions()
	// to recommence script execution. it is quite similar
	// to ExecExternalCommand() and that function will
	// actually be called by ExecLines() if further command
	// invocations are encountered.

	ASSERT( ( echo == FALSE ) || ( echo == TRUE ) );

	// check if command batch execution has been stalled
	if ( !ScriptReplayActive() )
		return FALSE;

	// set batch execution flag
	processing_batch = TRUE;

	// non-interactive console mode
	con_non_interactive = TRUE;

	// start in bottom level of recursion
	rec_depth = idle_reclevel;

	// restart stalled execution
	idle_reclevel = 0;

	do {

		// set correct recursion level
		rec_depth--;

		// exec all lines of this batch
		ExecLines( echo );

		// keep file open if recursion stalled
		if ( CurActionWait == 0 ) {
			SYS_fclose( fp_for_level[ rec_depth ] );
			fp_for_level[ rec_depth ] = NULL;
		} else {
			// simulate unraveling of
			// recursion to highest level
			rec_depth = 0;
			break;
		}

	} while ( rec_depth > 0 );

	// clear batch execution flag
	processing_batch = FALSE;

	// back to interactive console mode
	con_non_interactive = FALSE;

	// ensure no dangling automatic actions
	// if execution finished (not stalled)
	if ( idle_reclevel == 0 ) {
		REPLAY_StopAutomaticActions();
	}

	return TRUE;
}


// check validity of batchname ------------------------------------------------
//
PRIVATE
int CheckBatchName( char *name )
{
	ASSERT( name != NULL );

	int fnlen = strlen( name );

	if ( ( fnlen < 1 ) || ( fnlen > COMMAND_NAME_VALID_LEN ) ||
		 ( strtok( NULL, " " ) != NULL ) ) {
		CON_AddLine( invalid_batch_name );
		return FALSE;
	}

	for ( int pos = 0; pos < fnlen; pos++ ) {
		// only alphanumeric characters and underscores are allowed
		if ( !isalnum( name[ pos ] ) && ( name[ pos ] != '_' ) ) {
			CON_AddLine( invalid_batch_name );
			return FALSE;
		}
	}

	return TRUE;
}


// open output script for writing ---------------------------------------------
//
int OpenOutputBatch( char *cstr, int type )
{
	ASSERT( cstr != NULL );
	ASSERT( ( type == CM_CREATE ) || ( type == CM_OPEN ) || ( type == CM_APPEND ) );
	HANDLE_COMMAND_DOMAIN_SEP( cstr );

	if ( log_commands ) {
		CON_AddLine( "there is another script open." );
		return TRUE;
	}

	char *name = strtok( cstr, " " );
	if ( name == NULL ) {
		CON_AddLine( arg_missing );
		return TRUE;
	}

	if ( !CheckBatchName( name ) )
		return TRUE;
	strcpy( log_name, name );

	if ( CheckExternalCommand( name ) && ( type == CM_CREATE ) ) {
		CON_AddLine( "there is already a script with this name." );
		return TRUE;
	}
	strcpy( paste_str, name );
	strcat( paste_str, con_extension );

	const char *mode = ( type == CM_APPEND ) ? "a" : "w";
	if ( ( log_fp = fopen( paste_str, mode ) ) != NULL ) {
		log_commands = 1;
	} else {
		CON_AddLine( "cannot open script with this name." );
	}

	return TRUE;
}


// close output batch ---------------------------------------------------------
//
void CloseOutputBatch()
{
	if ( log_commands ) {

		fclose( log_fp );
		log_commands = 0;
		sprintf( paste_str, "script %s closed.", log_name );
		CON_AddLine( paste_str );

		// if command not already in list: append
		if ( !CheckExternalCommand( log_name ) &&
			 ( num_external_commands < MAX_EXTERNAL_COMMANDS ) ) {

			// if enough space append to list and set type to root
			ASSERT( strlen( log_name ) <= COMMAND_NAME_ALLOC_LEN );
			strcpy( external_commands[ num_external_commands ], log_name );
			external_command_types[ num_external_commands ] = COMTYPE_ROOT;
			num_external_commands++;
		}

	} else {
		CON_AddLine( "there is no script open." );
	}
}


// set file name of script automatically executed on start of game loop -------
//
int Cmd_SetGameLoopBatchName( char *cstr )
{
	ASSERT( cstr != NULL );
	HANDLE_COMMAND_DOMAIN_SEP( cstr );

	char *name = strtok( cstr, " " );

	if ( name == NULL ) {
		if ( *gameloop_start_script != 0 ) {
			// display name of currently selected
			// gameloop start-script
			CON_AddLine( gameloop_start_script );
		} else {
			CON_AddLine( "no gameloop start-script set." );
		}
		return TRUE;
	}

	if ( strtok( NULL, " " ) != NULL ) {
		CON_AddLine( "syntax: glbatch <script>." );
		return TRUE;
	}

	if ( CheckBatchName( name ) ) {
		// set new name for gameloop start-script
		strcpy( gameloop_start_script, name );
		sprintf( paste_str, "gameloop start-script set to: %s", gameloop_start_script );
		CON_AddLine( paste_str );
	} else {
		CON_AddLine( "invalid script name." );
	}

	return TRUE;
}


// start recording into command batch -----------------------------------------
//
int StartRecording( char *cstr, int savestate )
{
	ASSERT( cstr != NULL );
	HANDLE_COMMAND_DOMAIN_SEP( cstr );

	if ( !RecordingActive ) {

#ifdef PARSEC_CLIENT
		// object camera must be off
		if ( ObjCameraActive ) {
			CON_AddLine( record_disallowed );
			return TRUE;
		}
#endif // PARSEC_CLIENT

		// fetch name for recording
		char *name = strtok( cstr, " " );
		if ( name == NULL ) {
			CON_AddLine( arg_missing );
			return TRUE;
		}
		if ( !CheckBatchName( name ) )
			return TRUE;

		// store name (needed by CloseRecording())
		strcpy( record_name, name );

		// store name to use as packet record file
		strcpy( packet_record_name, name );

		// create actual file name
		strcpy( paste_str, name );
		strcat( paste_str, con_extension );

		if ( ( RecordingFp = fopen( paste_str, "w" ) ) != NULL ) {

			RemoteRecPacketId = 0;
			RecordingActive   = TRUE;

			// warn user if packet recording is off
			if ( NetConnected && !RecordRemotePackets ) {
				CON_AddLine( "[warning]: remote packet recording is off." );
			}

			// save game state (data screenshot) if desired
			if ( savestate ) {
				REC_InitMatrices();
				SaveGameState();
				CON_AddLine( "game state saved." );
			}

		} else {

			CON_AddLine( "cannot start a recording with this name." );
		}

	} else {

		CON_AddLine( "recording already in progress." );
	}

	return TRUE;
}


// close recording batch ------------------------------------------------------
//
void CloseRecording()
{
	fclose( RecordingFp );

	RecordingActive = 0;
	RemoteRecSessionId++;

	sprintf( paste_str, "recording %s closed.", record_name );
	CON_AddLine( paste_str );

	// if command not already in list: append
	if ( !CheckExternalCommand( record_name ) &&
		 ( num_external_commands < MAX_EXTERNAL_COMMANDS ) ) {

		// if enough space append to list and set type to
		// root (not recording since it will be placed
		// into the root directory!)
		ASSERT( strlen( record_name ) <= COMMAND_NAME_ALLOC_LEN );
		strcpy( external_commands[ num_external_commands ], record_name );
		external_command_types[ num_external_commands ] = COMTYPE_ROOT;
		num_external_commands++;
	}
}


// call external command and check recursion; called by ExecConsoleCommand() --
//
void CallExternalCommand( int extcom, int echo )
{
	//NOTE:
	// no new command can be started if replay in progress.
	// unfortunately, this means that no script at all
	// can be executed while any other script is stalled.
	// alas, this includes utility scripts.

	ASSERT( extcom >= 0 );
	ASSERT( ( echo == FALSE ) || ( echo == TRUE ) );

	// init demo info
	if ( !DEMO_BinaryReplayActive() ) {
		DEMO_InitInfo();
	}

	// assume action commands will be allowed
	int actionflag = TRUE;

	// remember action wait
	int curactionwait = CurActionWait;

	// handle non-recursive call
	if ( rec_depth == 0 ) {

		if ( ScriptReplayActive() ) {
			CON_AddLine( "script replay in progress. command not executed." );
			return;
		}

		if ( DEMO_BinaryReplayActive() ) {

			// disallow action commands to allow
			// simultaneous playback of binary demo
			actionflag = FALSE;

			//NOTE:
			// this ensures that no other ac.wait will be
			// executed, conflicting with the current one.

			// prevent batch execution from stalling
			CurActionWait = 0;
		}
	}

	// check if maximum recursion depth reached
	if ( rec_depth <= MAX_BATCH_REC_DEPTH ) {

		// set batch execution flag
		processing_batch = actionflag;

		// check all recursion levels above this one
		int lvl = 0;
		for (lvl = 0; lvl < rec_depth; lvl++ )
			if ( extcom_on_level[ lvl ] == extcom )
				break;

		// open contained batch if no endless recursion detected
		if ( lvl == rec_depth ) {
			ExecExternalCommand( extcom, echo );
		} else {
			CON_AddLine( recursion_canceled );
		}

	} else {
		// output error message if no more recursion levels available
		CON_AddLine( recursion_maxdepth );
	}

	// handle non-recursive call
	if ( rec_depth == 0 ) {

		// clear batch execution flag
		processing_batch = FALSE;

		// distinguish script only/simultaneous binary replay
		if ( actionflag == FALSE ) {

			// restore wait interval if binary demo
			// replay simultaneously in progress
			CurActionWait = curactionwait;

		} else {

			// ensure no dangling automatic actions
			// (only if no simultaneous binary replay)
			REPLAY_StopAutomaticActions();
		}
	}
}


// kill batch execution that is currently in progress -------------------------
//
void ScriptStopReplay()
{
	// immediately stop idle waiting
	CurActionWait = 0;

	// shut down recursive call stack
	while ( idle_reclevel > 0 ) {
		// step one level up
		idle_reclevel--;
		// close files kept open to maintain
		// state of recursion for script files
		if ( fp_for_level[ idle_reclevel ] != NULL ) {
			SYS_fclose( fp_for_level[ idle_reclevel ] );
			fp_for_level[ idle_reclevel ] = NULL;
		}
	}
	ASSERT( idle_reclevel == 0 );

	// kill dangling automatic actions
	REPLAY_StopAutomaticActions();
}


// close either recording or output batch -------------------------------------
//
void Cmd_CloseOutputBatch()
{
	if ( RecordingActive )
		CloseRecording();
	else
		CloseOutputBatch();
}


// stop replay of command batch (command "repstop") ---------------------------
//
void Cmd_StopBatchReplay()
{
	if ( !DEMO_ReplayActive() ) {
		CON_AddLine( no_replay );
	} else {
		// stop both binary replay and command batch replay
		DEMO_StopReplay();
		CON_AddLine( stopped_replay );
	}
}


// query status of command batch replay (command "repinfo") -------------------
//
void Cmd_QueryReplayInfo()
{
	if ( ScriptReplayActive() )
		CON_AddLine( replaying_script );
	else if ( DEMO_BinaryReplayActive() )
		CON_AddLine( replaying_binary );
	else
		CON_AddLine( no_replay );
}


// rescan list of external commands (command "rescan") ------------------------
//
void Cmd_RescanExternalCommands()
{
	// rebuild demo info
	DEMO_RegisterInitialDemos();

	// rebuild script cache
	BuildExternalCommandList();
	CON_AddLine( "script cache rebuilt." );
}