X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=cmd.c;h=c9e5cb7b81df325bb915fecb2339c044069225bd;hb=eb59c580e111af2abb37775ef320151776fe84d1;hp=00aa78ba00bda6298494e3cfc82bf98c3da610de;hpb=5ed1c3533b68ecc28947896ce646f2dda1e82c66;p=xonotic%2Fdarkplaces.git

diff --git a/cmd.c b/cmd.c
index 00aa78ba..c9e5cb7b 100644
--- a/cmd.c
+++ b/cmd.c
@@ -24,11 +24,12 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #define	MAX_ALIAS_NAME	32
 // this is the largest script file that can be executed in one step
 // LordHavoc: inreased this from 8192 to 32768
-#define CMDBUFSIZE 32768
+// div0: increased this from 32k to 128k
+#define CMDBUFSIZE 131072
 // maximum number of parameters to a command
 #define	MAX_ARGS 80
 // maximum tokenizable commandline length (counting NUL terminations)
-#define CMD_TOKENIZELENGTH (MAX_INPUTLINE + 80)
+#define CMD_TOKENIZELENGTH (MAX_INPUTLINE + MAX_ARGS)
 
 typedef struct cmdalias_s
 {
@@ -62,6 +63,116 @@ static void Cmd_Wait_f (void)
 	cmd_wait = true;
 }
 
+typedef struct cmddeferred_s
+{
+	struct cmddeferred_s *next;
+	char *value;
+	double time;
+} cmddeferred_t;
+
+static cmddeferred_t *cmd_deferred_list = NULL;
+
+/*
+============
+Cmd_Defer_f
+
+Cause a command to be executed after a delay.
+============
+*/
+static void Cmd_Defer_f (void)
+{
+	if(Cmd_Argc() == 1)
+	{
+		double time = Sys_DoubleTime();
+		cmddeferred_t *next = cmd_deferred_list;
+		if(!next)
+			Con_Printf("No commands are pending.\n");
+		while(next)
+		{
+			Con_Printf("-> In %9.2f: %s\n", next->time-time, next->value);
+			next = next->next;
+		}
+	} else if(Cmd_Argc() == 2 && !strcasecmp("clear", Cmd_Argv(1)))
+	{
+		while(cmd_deferred_list)
+		{
+			cmddeferred_t *cmd = cmd_deferred_list;
+			cmd_deferred_list = cmd->next;
+			Mem_Free(cmd->value);
+			Mem_Free(cmd);
+		}
+	} else if(Cmd_Argc() == 3)
+	{
+		const char *value = Cmd_Argv(2);
+		cmddeferred_t *defcmd = (cmddeferred_t*)Mem_Alloc(tempmempool, sizeof(*defcmd));
+		size_t len = strlen(value);
+
+		defcmd->time = Sys_DoubleTime() + atof(Cmd_Argv(1));
+		defcmd->value = (char*)Mem_Alloc(tempmempool, len+1);
+		memcpy(defcmd->value, value, len+1);
+		defcmd->next = NULL;
+
+		if(cmd_deferred_list)
+		{
+			cmddeferred_t *next = cmd_deferred_list;
+			while(next->next)
+				next = next->next;
+			next->next = defcmd;
+		} else
+			cmd_deferred_list = defcmd;
+		/* Stupid me... this changes the order... so commands with the same delay go blub :S
+		  defcmd->next = cmd_deferred_list;
+		  cmd_deferred_list = defcmd;*/
+	} else {
+		Con_Printf("usage: defer <seconds> <command>\n"
+			   "       defer clear\n");
+		return;
+	}
+}
+
+/*
+============
+Cmd_Centerprint_f
+
+Print something to the center of the screen using SCR_Centerprint
+============
+*/
+static void Cmd_Centerprint_f (void)
+{
+	char msg[MAX_INPUTLINE];
+	unsigned int i, c, p;
+	c = Cmd_Argc();
+	if(c >= 2)
+	{
+		strlcpy(msg, Cmd_Argv(1), sizeof(msg));
+		for(i = 2; i < c; ++i)
+		{
+			strlcat(msg, " ", sizeof(msg));
+			strlcat(msg, Cmd_Argv(i), sizeof(msg));
+		}
+		c = strlen(msg);
+		for(p = 0, i = 0; i < c; ++i)
+		{
+			if(msg[i] == '\\')
+			{
+				if(msg[i+1] == 'n')
+					msg[p++] = '\n';
+				else if(msg[i+1] == '\\')
+					msg[p++] = '\\';
+				else {
+					msg[p++] = '\\';
+					msg[p++] = msg[i+1];
+				}
+				++i;
+			} else {
+				msg[p++] = msg[i];
+			}
+		}
+		msg[p] = '\0';
+		SCR_CenterPrint(msg);
+	}
+}
+
 /*
 =============================================================================
 
@@ -132,6 +243,41 @@ void Cbuf_InsertText (const char *text)
 	}
 }
 
+/*
+============
+Cbuf_Execute_Deferred --blub
+============
+*/
+void Cbuf_Execute_Deferred (void)
+{
+	cmddeferred_t *cmd, *prev;
+	double time = Sys_DoubleTime();
+	prev = NULL;
+	cmd = cmd_deferred_list;
+	while(cmd)
+	{
+		if(cmd->time <= time)
+		{
+			Cbuf_AddText(cmd->value);
+			Cbuf_AddText(";\n");
+			Mem_Free(cmd->value);
+
+			if(prev) {
+				prev->next = cmd->next;
+				Mem_Free(cmd);
+				cmd = prev->next;
+			} else {
+				cmd_deferred_list = cmd->next;
+				Mem_Free(cmd);
+				cmd = cmd_deferred_list;
+			}
+			continue;
+		}
+		prev = cmd;
+		cmd = cmd->next;
+	}
+}
+
 /*
 ============
 Cbuf_Execute
@@ -144,11 +290,13 @@ void Cbuf_Execute (void)
 	char *text;
 	char line[MAX_INPUTLINE];
 	char preprocessed[MAX_INPUTLINE];
+	char *firstchar;
 	int quotes;
 
 	// LordHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes
 	cmd_tokenizebufferpos = 0;
 
+	Cbuf_Execute_Deferred();
 	while (cmd_text.cursize)
 	{
 // find a \n or ; line break
@@ -159,7 +307,9 @@ void Cbuf_Execute (void)
 		{
 			if (text[i] == '"')
 				quotes ^= 1;
-			if (text[i] == '\\' && text[i+1] == '"')
+			// make sure i doesn't get > cursize which causes a negative
+			// size in memmove, which is fatal --blub
+			if (i < (cmd_text.cursize-1) && (text[i] == '\\' && (text[i+1] == '"' || text[i+1] == '\\')))
 				i++;
 			if ( !quotes &&  text[i] == ';')
 				break;	// don't break if inside a quoted string
@@ -167,8 +317,17 @@ void Cbuf_Execute (void)
 				break;
 		}
 
-		memcpy (line, text, i);
-		line[i] = 0;
+		// better than CRASHING on overlong input lines that may SOMEHOW enter the buffer
+		if(i >= MAX_INPUTLINE)
+		{
+			Con_Printf("Warning: console input buffer had an overlong line. Ignored.\n");
+			line[0] = 0;
+		}
+		else
+		{
+			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, alias) can insert data at the
@@ -180,12 +339,26 @@ void Cbuf_Execute (void)
 		{
 			i++;
 			cmd_text.cursize -= i;
-			memcpy (cmd_text.data, text+i, cmd_text.cursize);
+			memmove (cmd_text.data, text+i, cmd_text.cursize);
 		}
 
 // execute the command line
-		Cmd_PreprocessString( line, preprocessed, sizeof(preprocessed), NULL );
-		Cmd_ExecuteString (preprocessed, src_command);
+		firstchar = line + strspn(line, " \t");
+		if(
+			(strncmp(firstchar, "alias", 5) || (firstchar[5] != ' ' && firstchar[5] != '\t'))
+			&&
+			(strncmp(firstchar, "bind", 4) || (firstchar[4] != ' ' && firstchar[4] != '\t'))
+			&&
+			(strncmp(firstchar, "in_bind", 7) || (firstchar[7] != ' ' && firstchar[7] != '\t'))
+		)
+		{
+			Cmd_PreprocessString( line, preprocessed, sizeof(preprocessed), NULL );
+			Cmd_ExecuteString (preprocessed, src_command);
+		}
+		else
+		{
+			Cmd_ExecuteString (line, src_command);
+		}
 
 		if (cmd_wait)
 		{	// skip out while text still remains in buffer, leaving it
@@ -290,7 +463,7 @@ static void Cmd_Exec_f (void)
 		Con_Printf("couldn't exec %s\n",Cmd_Argv(1));
 		return;
 	}
-	Con_DPrintf("execing %s\n",Cmd_Argv(1));
+	Con_Printf("execing %s\n",Cmd_Argv(1));
 
 	// if executing default.cfg for the first time, lock the cvar defaults
 	// it may seem backwards to insert this text BEFORE the default.cfg
@@ -397,7 +570,7 @@ static void Cmd_Toggle_f(void)
 		}
 		else
 		{ // Invalid CVar
-			Con_Printf("ERROR : CVar '%s' not found\n", Cmd_Argv(2) );
+			Con_Printf("ERROR : CVar '%s' not found\n", Cmd_Argv(1) );
 		}
 	}
 }
@@ -503,6 +676,186 @@ cmd_source_t cmd_source;
 
 static cmd_function_t *cmd_functions;		// possible commands to execute
 
+static const char *Cmd_GetDirectCvarValue(const char *varname, cmdalias_t *alias, qboolean *is_multiple)
+{
+	cvar_t *cvar;
+	long argno;
+	char *endptr;
+
+	if(is_multiple)
+		*is_multiple = false;
+
+	if(!varname || !*varname)
+		return NULL;
+
+	if(alias)
+	{
+		if(!strcmp(varname, "*"))
+		{
+			if(is_multiple)
+				*is_multiple = true;
+			return Cmd_Args();
+		}
+		else if(varname[strlen(varname) - 1] == '-')
+		{
+			argno = strtol(varname, &endptr, 10);
+			if(endptr == varname + strlen(varname) - 1)
+			{
+				// whole string is a number, apart from the -
+				const char *p = Cmd_Args();
+				for(; argno > 1; --argno)
+					if(!COM_ParseToken_Console(&p))
+						break;
+				if(p)
+				{
+					if(is_multiple)
+						*is_multiple = true;
+
+					// kill pre-argument whitespace
+					for (;*p && *p <= ' ';p++)
+						;
+
+					return p;
+				}
+			}
+		}
+		else
+		{
+			argno = strtol(varname, &endptr, 10);
+			if(*endptr == 0)
+			{
+				// whole string is a number
+				// NOTE: we already made sure we don't have an empty cvar name!
+				if(argno >= 0 && argno < Cmd_Argc())
+					return Cmd_Argv(argno);
+			}
+		}
+	}
+
+	if((cvar = Cvar_FindVar(varname)) && !(cvar->flags & CVAR_PRIVATE))
+		return cvar->string;
+
+	return NULL;
+}
+
+qboolean Cmd_QuoteString(char *out, size_t outlen, const char *in, const char *quoteset)
+{
+	qboolean quote_quot = !!strchr(quoteset, '"');
+	qboolean quote_backslash = !!strchr(quoteset, '\\');
+	qboolean quote_dollar = !!strchr(quoteset, '$');
+
+	while(*in)
+	{
+		if(*in == '"' && quote_quot)
+		{
+			if(outlen <= 2)
+			{
+				*out++ = 0;
+				return false;
+			}
+			*out++ = '\\'; --outlen;
+			*out++ = '"'; --outlen;
+		}
+		else if(*in == '\\' && quote_backslash)
+		{
+			if(outlen <= 2)
+			{
+				*out++ = 0;
+				return false;
+			}
+			*out++ = '\\'; --outlen;
+			*out++ = '\\'; --outlen;
+		}
+		else if(*in == '$' && quote_dollar)
+		{
+			if(outlen <= 2)
+			{
+				*out++ = 0;
+				return false;
+			}
+			*out++ = '$'; --outlen;
+			*out++ = '$'; --outlen;
+		}
+		else
+		{
+			if(outlen <= 1)
+			{
+				*out++ = 0;
+				return false;
+			}
+			*out++ = *in; --outlen;
+		}
+		++in;
+	}
+	*out++ = 0;
+	return true;
+}
+
+static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t *alias)
+{
+	static char varname[MAX_INPUTLINE];
+	static char varval[MAX_INPUTLINE];
+	const char *varstr;
+	char *varfunc;
+
+	if(varlen >= MAX_INPUTLINE)
+		varlen = MAX_INPUTLINE - 1;
+	memcpy(varname, var, varlen);
+	varname[varlen] = 0;
+	varfunc = strchr(varname, ' ');
+
+	if(varfunc)
+	{
+		*varfunc = 0;
+		++varfunc;
+	}
+
+	if(*var == 0)
+	{
+		// empty cvar name?
+		return NULL;
+	}
+
+	varstr = NULL;
+
+	if(varname[0] == '$')
+		varstr = Cmd_GetDirectCvarValue(Cmd_GetDirectCvarValue(varname + 1, alias, NULL), alias, NULL);
+	else
+	{
+		qboolean is_multiple = false;
+		// Exception: $* and $n- don't use the quoted form by default
+		varstr = Cmd_GetDirectCvarValue(varname, alias, &is_multiple);
+		if(is_multiple)
+			if(!varfunc)
+				varfunc = "asis";
+	}
+
+	if(!varstr)
+	{
+		if(alias)
+			Con_Printf("Warning: Could not expand $%s in alias %s\n", varname, alias->name);
+		else
+			Con_Printf("Warning: Could not expand $%s\n", varname);
+		return NULL;
+	}
+
+	if(!varfunc || !strcmp(varfunc, "q")) // note: quoted form is default, use "asis" to override!
+	{
+		// quote it so it can be used inside double quotes
+		// we just need to replace " by \", and of course, double backslashes
+		Cmd_QuoteString(varval, sizeof(varval), varstr, "\"\\");
+		return varval;
+	}
+	else if(!strcmp(varfunc, "asis"))
+	{
+		return varstr;
+	}
+	else
+		Con_Printf("Unknown variable function %s\n", varfunc);
+
+	return varstr;
+}
+
 /*
 Cmd_PreprocessString
 
@@ -510,8 +863,9 @@ Preprocesses strings and replaces $*, $param#, $cvar accordingly
 */
 static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias ) {
 	const char *in;
+	size_t eat, varlen;
 	unsigned outlen;
-	int inquote;
+	const char *val;
 
 	// don't crash if there's no room in the outtext buffer
 	if( maxoutlen == 0 ) {
@@ -521,74 +875,98 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma
 
 	in = intext;
 	outlen = 0;
-	inquote = 0;
 
 	while( *in && outlen < maxoutlen ) {
-		if( *in == '$' && !inquote ) {
+		if( *in == '$' ) {
 			// this is some kind of expansion, see what comes after the $
 			in++;
-			// replacements that can always be used:
-			// $$ is replaced with $, to allow escaping $
-			// $<cvarname> is replaced with the contents of the cvar
+
+			// The console does the following preprocessing:
+			//
+			// - $$ is transformed to a single dollar sign.
+			// - $var or ${var} are expanded to the contents of the named cvar,
+			//   with quotation marks and backslashes quoted so it can safely
+			//   be used inside quotation marks (and it should always be used
+			//   that way)
+			// - ${var asis} inserts the cvar value as is, without doing this
+			//   quoting
+			// - prefix the cvar name with a dollar sign to do indirection;
+			//   for example, if $x has the value timelimit, ${$x} will return
+			//   the value of $timelimit
+			// - when expanding an alias, the special variable name $* refers
+			//   to all alias parameters, and a number refers to that numbered
+			//   alias parameter, where the name of the alias is $0, the first
+			//   parameter is $1 and so on; as a special case, $* inserts all
+			//   parameters, without extra quoting, so one can use $* to just
+			//   pass all parameters around. All parameters starting from $n
+			//   can be referred to as $n- (so $* is equivalent to $1-).
 			//
-			// the following can be used in aliases only:
-			// $* is replaced with all formal parameters (including name of the alias - this probably is not desirable)
-			// $0 is replaced with the name of this alias
-			// $<number> is replaced with an argument to this alias (or copied as-is if no such parameter exists), can be multiple digits
+			// Note: when expanding an alias, cvar expansion is done in the SAME step
+			// as alias expansion so that alias parameters or cvar values containing
+			// dollar signs have no unwanted bad side effects. However, this needs to
+			// be accounted for when writing complex aliases. For example,
+			//   alias foo "set x NEW; echo $x"
+			// actually expands to
+			//   "set x NEW; echo OLD"
+			// and will print OLD! To work around this, use a second alias:
+			//   alias foo "set x NEW; foo2"
+			//   alias foo2 "echo $x"
+			//
+			// Also note: lines starting with alias are exempt from cvar expansion.
+			// If you want cvar expansion, write "alias" instead:
+			//
+			//   set x 1
+			//   alias foo "echo $x"
+			//   "alias" bar "echo $x"
+			//   set x 2
+			//
+			// foo will print 2, because the variable $x will be expanded when the alias
+			// gets expanded. bar will print 1, because the variable $x was expanded
+			// at definition time. foo can be equivalently defined as
+			//
+			//   "alias" foo "echo $$x"
+			//
+			// because at definition time, $$ will get replaced to a single $.
+
 			if( *in == '$' ) {
-				outtext[outlen++] = *in++;
-			} else if( *in == '*' && alias ) {
-				const char *linein = Cmd_Args();
-
-				// include all parameters
-				if (linein) {
-					while( *linein && outlen < maxoutlen ) {
-						outtext[outlen++] = *linein++;
-					}
+				val = "$";
+				eat = 1;
+			} else if(*in == '{') {
+				varlen = strcspn(in + 1, "}");
+				if(in[varlen + 1] == '}')
+				{
+					val = Cmd_GetCvarValue(in + 1, varlen, alias);
+					eat = varlen + 2;
 				}
-
-				in++;
-			} else if( '0' <= *in && *in <= '9' && alias ) {
-				char *nexttoken;
-				int argnum;
-
-				argnum = strtol( in, &nexttoken, 10 );
-
-				if( 0 <= argnum && argnum < Cmd_Argc() ) {
-					const char *param = Cmd_Argv( argnum );
-					while( *param && outlen < maxoutlen ) {
-						outtext[outlen++] = *param++;
-					}
-					in = nexttoken;
-				} else if( argnum >= Cmd_Argc() ) {
-					Con_Printf( "Warning: Not enough parameters passed to alias '%s', at least %i expected:\n    %s\n", alias->name, argnum, alias->value );
-					outtext[outlen++] = '$';
+				else
+				{
+					// ran out of data?
+					val = NULL;
+					eat = varlen + 1;
 				}
 			} else {
-				cvar_t *cvar;
-				const char *tempin = in;
-
-				COM_ParseToken_Console( &tempin );
-				// don't expand rcon_password or similar cvars (CVAR_PRIVATE flag)
-				if ((cvar = Cvar_FindVar(&com_token[0])) && !(cvar->flags & CVAR_PRIVATE)) {
-					const char *cvarcontent = cvar->string;
-					while( *cvarcontent && outlen < maxoutlen ) {
-						outtext[outlen++] = *cvarcontent++;
-					}
-					in = tempin;
-				} else {
-					if( alias ) {
-						Con_Printf( "Warning: could not find cvar %s when expanding alias %s\n    %s\n", com_token, alias->name, alias->value );
-					} else {
-						Con_Printf( "Warning: could not find cvar %s\n", com_token );
-					}
-					outtext[outlen++] = '$';
+				varlen = strspn(in, "*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-");
+				val = Cmd_GetCvarValue(in, varlen, alias);
+				eat = varlen;
+			}
+			if(val)
+			{
+				// insert the cvar value
+				while(*val && outlen < maxoutlen)
+					outtext[outlen++] = *val++;
+				in += eat;
+			}
+			else
+			{
+				// copy the unexpanded text
+				outtext[outlen++] = '$';
+				while(eat && outlen < maxoutlen)
+				{
+					outtext[outlen++] = *in++;
+					--eat;
 				}
 			}
 		} else {
-			if( *in == '"' ) {
-				inquote ^= 1;
-			}
 			outtext[outlen++] = *in++;
 		}
 	}
@@ -604,11 +982,17 @@ Called for aliases and fills in the alias into the cbuffer
 */
 static void Cmd_ExecuteAlias (cmdalias_t *alias)
 {
-	static char buffer[ MAX_INPUTLINE + 2 ];
+	static char buffer[ MAX_INPUTLINE ];
+	static char buffer2[ MAX_INPUTLINE ];
 	Cmd_PreprocessString( alias->value, buffer, sizeof(buffer) - 2, alias );
 	// insert at start of command buffer, so that aliases execute in order
 	// (fixes bug introduced by Black on 20050705)
-	Cbuf_InsertText( buffer );
+
+	// Note: Cbuf_PreprocessString will be called on this string AGAIN! So we
+	// have to make sure that no second variable expansion takes place, otherwise
+	// alias parameters containing dollar signs can have bad effects.
+	Cmd_QuoteString(buffer2, sizeof(buffer2), buffer, "$");
+	Cbuf_InsertText( buffer2 );
 }
 
 /*
@@ -690,6 +1074,9 @@ void Cmd_Init_Commands (void)
 	Cmd_AddCommand ("cvar_resettodefaults_nosaveonly", Cvar_ResetToDefaults_NoSaveOnly_f, "sets all non-saved cvars to their locked default values (variables that will not be saved to config.cfg)");
 	Cmd_AddCommand ("cvar_resettodefaults_saveonly", Cvar_ResetToDefaults_SaveOnly_f, "sets all saved cvars to their locked default values (variables that will be saved to config.cfg)");
 
+	Cmd_AddCommand ("cprint", Cmd_Centerprint_f, "print something at the screen center");
+	Cmd_AddCommand ("defer", Cmd_Defer_f, "execute a command in the future");
+
 	// DRESK - 5/14/06
 	// Support Doom3-style Toggle Command
 	Cmd_AddCommand( "toggle", Cmd_Toggle_f, "toggles a console variable's values (use for more info)");
@@ -1082,11 +1469,13 @@ FIXME: lookupnoadd the token to speed search?
 void Cmd_ExecuteString (const char *text, cmd_source_t src)
 {
 	int oldpos;
+	int found;
 	cmd_function_t *cmd;
 	cmdalias_t *a;
 
 	oldpos = cmd_tokenizebufferpos;
 	cmd_source = src;
+	found = false;
 
 	Cmd_TokenizeString (text);
 
@@ -1121,8 +1510,9 @@ void Cmd_ExecuteString (const char *text, cmd_source_t src)
 				}
 				else
 					Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(0));
-				cmd_tokenizebufferpos = oldpos;
-				return;
+				found = true;
+				goto command_found;
+				break;
 			case src_client:
 				if (cmd->clientfunction)
 				{
@@ -1135,11 +1525,13 @@ void Cmd_ExecuteString (const char *text, cmd_source_t src)
 			break;
 		}
 	}
+command_found:
 
 	// if it's a client command and no command was found, say so.
 	if (cmd_source == src_client)
 	{
 		Con_Printf("player \"%s\" tried to %s\n", host_client->name, text);
+		cmd_tokenizebufferpos = oldpos;
 		return;
 	}
 
@@ -1154,6 +1546,12 @@ void Cmd_ExecuteString (const char *text, cmd_source_t src)
 		}
 	}
 
+	if(found) // if the command was hooked and found, all is good
+	{
+		cmd_tokenizebufferpos = oldpos;
+		return;
+	}
+
 // check cvars
 	if (!Cvar_Command () && host_framecount > 0)
 		Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(0));