Quake-III-Arena

cmd.c (13732B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena source code 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.
 
 Quake III Arena source code 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 Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 // cmd.c -- Quake script command processing module
 
 #include "../game/q_shared.h"
 #include "qcommon.h"
 
 #define	MAX_CMD_BUFFER	16384
 #define	MAX_CMD_LINE	1024
 
 typedef struct {
 	byte	*data;
 	int		maxsize;
 	int		cursize;
 } cmd_t;
 
 int			cmd_wait;
 cmd_t		cmd_text;
 byte		cmd_text_buf[MAX_CMD_BUFFER];
 
 
 //=============================================================================
 
 /*
 ============
 Cmd_Wait_f
 
 Causes execution of the remainder of the command buffer to be delayed until
 next frame.  This allows commands like:
 bind g "cmd use rocket ; +attack ; wait ; -attack ; cmd use blaster"
 ============
 */
 void Cmd_Wait_f( void ) {
 	if ( Cmd_Argc() == 2 ) {
 		cmd_wait = atoi( Cmd_Argv( 1 ) );
 	} else {
 		cmd_wait = 1;
 	}
 }
 
 
 /*
 =============================================================================
 
 						COMMAND BUFFER
 
 =============================================================================
 */
 
 /*
 ============
 Cbuf_Init
 ============
 */
 void Cbuf_Init (void)
 {
 	cmd_text.data = cmd_text_buf;
 	cmd_text.maxsize = MAX_CMD_BUFFER;
 	cmd_text.cursize = 0;
 }
 
 /*
 ============
 Cbuf_AddText
 
 Adds command text at the end of the buffer, does NOT add a final \n
 ============
 */
 void Cbuf_AddText( const char *text ) {
 	int		l;
 	
 	l = strlen (text);
 
 	if (cmd_text.cursize + l >= cmd_text.maxsize)
 	{
 		Com_Printf ("Cbuf_AddText: overflow\n");
 		return;
 	}
 	Com_Memcpy(&cmd_text.data[cmd_text.cursize], text, l);
 	cmd_text.cursize += l;
 }
 
 
 /*
 ============
 Cbuf_InsertText
 
 Adds command text immediately after the current command
 Adds a \n to the text
 ============
 */
 void Cbuf_InsertText( const char *text ) {
 	int		len;
 	int		i;
 
 	len = strlen( text ) + 1;
 	if ( len + cmd_text.cursize > cmd_text.maxsize ) {
 		Com_Printf( "Cbuf_InsertText overflowed\n" );
 		return;
 	}
 
 	// move the existing command text
 	for ( i = cmd_text.cursize - 1 ; i >= 0 ; i-- ) {
 		cmd_text.data[ i + len ] = cmd_text.data[ i ];
 	}
 
 	// copy the new text in
 	Com_Memcpy( cmd_text.data, text, len - 1 );
 
 	// add a \n
 	cmd_text.data[ len - 1 ] = '\n';
 
 	cmd_text.cursize += len;
 }
 
 
 /*
 ============
 Cbuf_ExecuteText
 ============
 */
 void Cbuf_ExecuteText (int exec_when, const char *text)
 {
 	switch (exec_when)
 	{
 	case EXEC_NOW:
 		if (text && strlen(text) > 0) {
 			Cmd_ExecuteString (text);
 		} else {
 			Cbuf_Execute();
 		}
 		break;
 	case EXEC_INSERT:
 		Cbuf_InsertText (text);
 		break;
 	case EXEC_APPEND:
 		Cbuf_AddText (text);
 		break;
 	default:
 		Com_Error (ERR_FATAL, "Cbuf_ExecuteText: bad exec_when");
 	}
 }
 
 /*
 ============
 Cbuf_Execute
 ============
 */
 void Cbuf_Execute (void)
 {
 	int		i;
 	char	*text;
 	char	line[MAX_CMD_LINE];
 	int		quotes;
 
 	while (cmd_text.cursize)
 	{
 		if ( cmd_wait )	{
 			// skip out while text still remains in buffer, leaving it
 			// for next frame
 			cmd_wait--;
 			break;
 		}
 
 		// find a \n or ; line break
 		text = (char *)cmd_text.data;
 
 		quotes = 0;
 		for (i=0 ; i< cmd_text.cursize ; i++)
 		{
 			if (text[i] == '"')
 				quotes++;
 			if ( !(quotes&1) &&  text[i] == ';')
 				break;	// don't break if inside a quoted string
 			if (text[i] == '\n' || text[i] == '\r' )
 				break;
 		}
 
 		if( i >= (MAX_CMD_LINE - 1)) {
 			i = MAX_CMD_LINE - 1;
 		}
 				
 		Com_Memcpy (line, text, i);
 		line[i] = 0;
 		
 // delete the text from the command buffer and move remaining commands down
 // this is necessary because commands (exec) can insert data at the
 // beginning of the text buffer
 
 		if (i == cmd_text.cursize)
 			cmd_text.cursize = 0;
 		else
 		{
 			i++;
 			cmd_text.cursize -= i;
 			memmove (text, text+i, cmd_text.cursize);
 		}
 
 // execute the command line
 
 		Cmd_ExecuteString (line);		
 	}
 }
 
 
 /*
 ==============================================================================
 
 						SCRIPT COMMANDS
 
 ==============================================================================
 */
 
 
 /*
 ===============
 Cmd_Exec_f
 ===============
 */
 void Cmd_Exec_f( void ) {
 	char	*f;
 	int		len;
 	char	filename[MAX_QPATH];
 
 	if (Cmd_Argc () != 2) {
 		Com_Printf ("exec <filename> : execute a script file\n");
 		return;
 	}
 
 	Q_strncpyz( filename, Cmd_Argv(1), sizeof( filename ) );
 	COM_DefaultExtension( filename, sizeof( filename ), ".cfg" ); 
 	len = FS_ReadFile( filename, (void **)&f);
 	if (!f) {
 		Com_Printf ("couldn't exec %s\n",Cmd_Argv(1));
 		return;
 	}
 	Com_Printf ("execing %s\n",Cmd_Argv(1));
 	
 	Cbuf_InsertText (f);
 
 	FS_FreeFile (f);
 }
 
 
 /*
 ===============
 Cmd_Vstr_f
 
 Inserts the current value of a variable as command text
 ===============
 */
 void Cmd_Vstr_f( void ) {
 	char	*v;
 
 	if (Cmd_Argc () != 2) {
 		Com_Printf ("vstr <variablename> : execute a variable command\n");
 		return;
 	}
 
 	v = Cvar_VariableString( Cmd_Argv( 1 ) );
 	Cbuf_InsertText( va("%s\n", v ) );
 }
 
 
 /*
 ===============
 Cmd_Echo_f
 
 Just prints the rest of the line to the console
 ===============
 */
 void Cmd_Echo_f (void)
 {
 	int		i;
 	
 	for (i=1 ; i<Cmd_Argc() ; i++)
 		Com_Printf ("%s ",Cmd_Argv(i));
 	Com_Printf ("\n");
 }
 
 
 /*
 =============================================================================
 
 					COMMAND EXECUTION
 
 =============================================================================
 */
 
 typedef struct cmd_function_s
 {
 	struct cmd_function_s	*next;
 	char					*name;
 	xcommand_t				function;
 } cmd_function_t;
 
 
 static	int			cmd_argc;
 static	char		*cmd_argv[MAX_STRING_TOKENS];		// points into cmd_tokenized
 static	char		cmd_tokenized[BIG_INFO_STRING+MAX_STRING_TOKENS];	// will have 0 bytes inserted
 static	char		cmd_cmd[BIG_INFO_STRING]; // the original command we received (no token processing)
 
 static	cmd_function_t	*cmd_functions;		// possible commands to execute
 
 /*
 ============
 Cmd_Argc
 ============
 */
 int		Cmd_Argc( void ) {
 	return cmd_argc;
 }
 
 /*
 ============
 Cmd_Argv
 ============
 */
 char	*Cmd_Argv( int arg ) {
 	if ( (unsigned)arg >= cmd_argc ) {
 		return "";
 	}
 	return cmd_argv[arg];	
 }
 
 /*
 ============
 Cmd_ArgvBuffer
 
 The interpreted versions use this because
 they can't have pointers returned to them
 ============
 */
 void	Cmd_ArgvBuffer( int arg, char *buffer, int bufferLength ) {
 	Q_strncpyz( buffer, Cmd_Argv( arg ), bufferLength );
 }
 
 
 /*
 ============
 Cmd_Args
 
 Returns a single string containing argv(1) to argv(argc()-1)
 ============
 */
 char	*Cmd_Args( void ) {
 	static	char		cmd_args[MAX_STRING_CHARS];
 	int		i;
 
 	cmd_args[0] = 0;
 	for ( i = 1 ; i < cmd_argc ; i++ ) {
 		strcat( cmd_args, cmd_argv[i] );
 		if ( i != cmd_argc-1 ) {
 			strcat( cmd_args, " " );
 		}
 	}
 
 	return cmd_args;
 }
 
 /*
 ============
 Cmd_Args
 
 Returns a single string containing argv(arg) to argv(argc()-1)
 ============
 */
 char *Cmd_ArgsFrom( int arg ) {
 	static	char		cmd_args[BIG_INFO_STRING];
 	int		i;
 
 	cmd_args[0] = 0;
 	if (arg < 0)
 		arg = 0;
 	for ( i = arg ; i < cmd_argc ; i++ ) {
 		strcat( cmd_args, cmd_argv[i] );
 		if ( i != cmd_argc-1 ) {
 			strcat( cmd_args, " " );
 		}
 	}
 
 	return cmd_args;
 }
 
 /*
 ============
 Cmd_ArgsBuffer
 
 The interpreted versions use this because
 they can't have pointers returned to them
 ============
 */
 void	Cmd_ArgsBuffer( char *buffer, int bufferLength ) {
 	Q_strncpyz( buffer, Cmd_Args(), bufferLength );
 }
 
 /*
 ============
 Cmd_Cmd
 
 Retrieve the unmodified command string
 For rcon use when you want to transmit without altering quoting
 https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=543
 ============
 */
 char *Cmd_Cmd()
 {
 	return cmd_cmd;
 }
 
 /*
 ============
 Cmd_TokenizeString
 
 Parses the given string into command line tokens.
 The text is copied to a seperate buffer and 0 characters
 are inserted in the apropriate place, The argv array
 will point into this temporary buffer.
 ============
 */
 // NOTE TTimo define that to track tokenization issues
 //#define TKN_DBG
 void Cmd_TokenizeString( const char *text_in ) {
 	const char	*text;
 	char	*textOut;
 
 #ifdef TKN_DBG
   // FIXME TTimo blunt hook to try to find the tokenization of userinfo
   Com_DPrintf("Cmd_TokenizeString: %s\n", text_in);
 #endif
 
 	// clear previous args
 	cmd_argc = 0;
 
 	if ( !text_in ) {
 		return;
 	}
 	
 	Q_strncpyz( cmd_cmd, text_in, sizeof(cmd_cmd) );
 
 	text = text_in;
 	textOut = cmd_tokenized;
 
 	while ( 1 ) {
 		if ( cmd_argc == MAX_STRING_TOKENS ) {
 			return;			// this is usually something malicious
 		}
 
 		while ( 1 ) {
 			// skip whitespace
 			while ( *text && *text <= ' ' ) {
 				text++;
 			}
 			if ( !*text ) {
 				return;			// all tokens parsed
 			}
 
 			// skip // comments
 			if ( text[0] == '/' && text[1] == '/' ) {
 				return;			// all tokens parsed
 			}
 
 			// skip /* */ comments
 			if ( text[0] == '/' && text[1] =='*' ) {
 				while ( *text && ( text[0] != '*' || text[1] != '/' ) ) {
 					text++;
 				}
 				if ( !*text ) {
 					return;		// all tokens parsed
 				}
 				text += 2;
 			} else {
 				break;			// we are ready to parse a token
 			}
 		}
 
 		// handle quoted strings
     // NOTE TTimo this doesn't handle \" escaping
 		if ( *text == '"' ) {
 			cmd_argv[cmd_argc] = textOut;
 			cmd_argc++;
 			text++;
 			while ( *text && *text != '"' ) {
 				*textOut++ = *text++;
 			}
 			*textOut++ = 0;
 			if ( !*text ) {
 				return;		// all tokens parsed
 			}
 			text++;
 			continue;
 		}
 
 		// regular token
 		cmd_argv[cmd_argc] = textOut;
 		cmd_argc++;
 
 		// skip until whitespace, quote, or command
 		while ( *text > ' ' ) {
 			if ( text[0] == '"' ) {
 				break;
 			}
 
 			if ( text[0] == '/' && text[1] == '/' ) {
 				break;
 			}
 
 			// skip /* */ comments
 			if ( text[0] == '/' && text[1] =='*' ) {
 				break;
 			}
 
 			*textOut++ = *text++;
 		}
 
 		*textOut++ = 0;
 
 		if ( !*text ) {
 			return;		// all tokens parsed
 		}
 	}
 	
 }
 
 
 /*
 ============
 Cmd_AddCommand
 ============
 */
 void	Cmd_AddCommand( const char *cmd_name, xcommand_t function ) {
 	cmd_function_t	*cmd;
 	
 	// fail if the command already exists
 	for ( cmd = cmd_functions ; cmd ; cmd=cmd->next ) {
 		if ( !strcmp( cmd_name, cmd->name ) ) {
 			// allow completion-only commands to be silently doubled
 			if ( function != NULL ) {
 				Com_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
 			}
 			return;
 		}
 	}
 
 	// use a small malloc to avoid zone fragmentation
 	cmd = S_Malloc (sizeof(cmd_function_t));
 	cmd->name = CopyString( cmd_name );
 	cmd->function = function;
 	cmd->next = cmd_functions;
 	cmd_functions = cmd;
 }
 
 /*
 ============
 Cmd_RemoveCommand
 ============
 */
 void	Cmd_RemoveCommand( const char *cmd_name ) {
 	cmd_function_t	*cmd, **back;
 
 	back = &cmd_functions;
 	while( 1 ) {
 		cmd = *back;
 		if ( !cmd ) {
 			// command wasn't active
 			return;
 		}
 		if ( !strcmp( cmd_name, cmd->name ) ) {
 			*back = cmd->next;
 			if (cmd->name) {
 				Z_Free(cmd->name);
 			}
 			Z_Free (cmd);
 			return;
 		}
 		back = &cmd->next;
 	}
 }
 
 
 /*
 ============
 Cmd_CommandCompletion
 ============
 */
 void	Cmd_CommandCompletion( void(*callback)(const char *s) ) {
 	cmd_function_t	*cmd;
 	
 	for (cmd=cmd_functions ; cmd ; cmd=cmd->next) {
 		callback( cmd->name );
 	}
 }
 
 
 /*
 ============
 Cmd_ExecuteString
 
 A complete command line has been parsed, so try to execute it
 ============
 */
 void	Cmd_ExecuteString( const char *text ) {	
 	cmd_function_t	*cmd, **prev;
 
 	// execute the command line
 	Cmd_TokenizeString( text );		
 	if ( !Cmd_Argc() ) {
 		return;		// no tokens
 	}
 
 	// check registered command functions	
 	for ( prev = &cmd_functions ; *prev ; prev = &cmd->next ) {
 		cmd = *prev;
 		if ( !Q_stricmp( cmd_argv[0],cmd->name ) ) {
 			// rearrange the links so that the command will be
 			// near the head of the list next time it is used
 			*prev = cmd->next;
 			cmd->next = cmd_functions;
 			cmd_functions = cmd;
 
 			// perform the action
 			if ( !cmd->function ) {
 				// let the cgame or game handle it
 				break;
 			} else {
 				cmd->function ();
 			}
 			return;
 		}
 	}
 	
 	// check cvars
 	if ( Cvar_Command() ) {
 		return;
 	}
 
 	// check client game commands
 	if ( com_cl_running && com_cl_running->integer && CL_GameCommand() ) {
 		return;
 	}
 
 	// check server game commands
 	if ( com_sv_running && com_sv_running->integer && SV_GameCommand() ) {
 		return;
 	}
 
 	// check ui commands
 	if ( com_cl_running && com_cl_running->integer && UI_GameCommand() ) {
 		return;
 	}
 
 	// send it as a server command if we are connected
 	// this will usually result in a chat message
 	CL_ForwardCommandToServer ( text );
 }
 
 /*
 ============
 Cmd_List_f
 ============
 */
 void Cmd_List_f (void)
 {
 	cmd_function_t	*cmd;
 	int				i;
 	char			*match;
 
 	if ( Cmd_Argc() > 1 ) {
 		match = Cmd_Argv( 1 );
 	} else {
 		match = NULL;
 	}
 
 	i = 0;
 	for (cmd=cmd_functions ; cmd ; cmd=cmd->next) {
 		if (match && !Com_Filter(match, cmd->name, qfalse)) continue;
 
 		Com_Printf ("%s\n", cmd->name);
 		i++;
 	}
 	Com_Printf ("%i commands\n", i);
 }
 
 /*
 ============
 Cmd_Init
 ============
 */
 void Cmd_Init (void) {
 	Cmd_AddCommand ("cmdlist",Cmd_List_f);
 	Cmd_AddCommand ("exec",Cmd_Exec_f);
 	Cmd_AddCommand ("vstr",Cmd_Vstr_f);
 	Cmd_AddCommand ("echo",Cmd_Echo_f);
 	Cmd_AddCommand ("wait", Cmd_Wait_f);
 }