X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=cmd.c;h=e8a275f545ee301d03aed0b7980a40b0c39d9a95;hb=ec5bfe9159477756e615cf1cd69dfb66ac75b9a2;hp=a59a46f6189e86fe3ed91c5ee282f31100ec107a;hpb=3b27c0e3bc751cbf1f7c562c2bebfd3ec9b18f58;p=xonotic%2Fdarkplaces.git

diff --git a/cmd.c b/cmd.c
index a59a46f6..e8a275f5 100644
--- a/cmd.c
+++ b/cmd.c
@@ -144,6 +144,7 @@ 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
@@ -159,6 +160,8 @@ void Cbuf_Execute (void)
 		{
 			if (text[i] == '"')
 				quotes ^= 1;
+			if (text[i] == '\\' && (text[i+1] == '"' || text[i+1] == '\\'))
+				i++;
 			if ( !quotes &&  text[i] == ';')
 				break;	// don't break if inside a quoted string
 			if (text[i] == '\r' || text[i] == '\n')
@@ -178,12 +181,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
@@ -216,7 +233,7 @@ qboolean host_stuffcmdsrun = false;
 void Cmd_StuffCmds_f (void)
 {
 	int		i, j, l;
-	// this is per command, and bounds checked (no buffer overflows)
+	// this is for all commandline options combined (and is bounds checked)
 	char	build[MAX_INPUTLINE];
 
 	if (Cmd_Argc () != 1)
@@ -230,11 +247,12 @@ void Cmd_StuffCmds_f (void)
 		return;
 
 	host_stuffcmdsrun = true;
+	build[0] = 0;
+	l = 0;
 	for (i = 0;i < com_argc;i++)
 	{
-		if (com_argv[i] && com_argv[i][0] == '+' && (com_argv[i][1] < '0' || com_argv[i][1] > '9'))
+		if (com_argv[i] && com_argv[i][0] == '+' && (com_argv[i][1] < '0' || com_argv[i][1] > '9') && l + strlen(com_argv[i]) - 1 <= sizeof(build) - 1)
 		{
-			l = 0;
 			j = 1;
 			while (com_argv[i][j])
 				build[l++] = com_argv[i][j++];
@@ -245,20 +263,24 @@ void Cmd_StuffCmds_f (void)
 					continue;
 				if ((com_argv[i][0] == '+' || com_argv[i][0] == '-') && (com_argv[i][1] < '0' || com_argv[i][1] > '9'))
 					break;
-				if (l + strlen(com_argv[i]) + 5 > sizeof(build))
+				if (l + strlen(com_argv[i]) + 4 > sizeof(build) - 1)
 					break;
 				build[l++] = ' ';
-				build[l++] = '\"';
+				if (strchr(com_argv[i], ' '))
+					build[l++] = '\"';
 				for (j = 0;com_argv[i][j];j++)
 					build[l++] = com_argv[i][j];
-				build[l++] = '\"';
+				if (strchr(com_argv[i], ' '))
+					build[l++] = '\"';
 			}
 			build[l++] = '\n';
-			build[l++] = 0;
-			Cbuf_InsertText (build);
 			i--;
 		}
 	}
+	// now terminate the combined string and prepend it to the command buffer
+	// we already reserved space for the terminator
+	build[l++] = 0;
+	Cbuf_InsertText (build);
 }
 
 
@@ -496,6 +518,185 @@ 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)
+			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
 
@@ -503,8 +704,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 ) {
@@ -514,74 +716,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_ParseTokenConsole( &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++;
 		}
 	}
@@ -598,10 +824,16 @@ 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 buffer2[ MAX_INPUTLINE * 2 + 2 ];
 	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 );
 }
 
 /*
@@ -771,7 +1003,7 @@ static void Cmd_TokenizeString (const char *text)
 		if (cmd_argc == 1)
 			cmd_args = text;
 
-		if (!COM_ParseTokenConsole(&text))
+		if (!COM_ParseToken_Console(&text))
 			return;
 
 		if (cmd_argc < MAX_ARGS)
@@ -1164,6 +1396,7 @@ Sends an entire command string over to the server, unprocessed
 */
 void Cmd_ForwardStringToServer (const char *s)
 {
+	char temp[128];
 	if (cls.state != ca_connected)
 	{
 		Con_Printf("Can't \"%s\", not connected\n", s);
@@ -1180,7 +1413,105 @@ void Cmd_ForwardStringToServer (const char *s)
 		MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd);
 	else
 		MSG_WriteByte(&cls.netcon->message, clc_stringcmd);
-	SZ_Write(&cls.netcon->message, (const unsigned char *)s, (int)strlen(s) + 1);
+	if ((!strncmp(s, "say ", 4) || !strncmp(s, "say_team ", 9)) && cl_locs_enable.integer)
+	{
+		// say/say_team commands can replace % character codes with status info
+		while (*s)
+		{
+			if (*s == '%' && s[1])
+			{
+				// handle proquake message macros
+				temp[0] = 0;
+				switch (s[1])
+				{
+				case 'l': // current location
+					CL_Locs_FindLocationName(temp, sizeof(temp), cl.movement_origin);
+					break;
+				case 'h': // current health
+					dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_HEALTH]);
+					break;
+				case 'a': // current armor
+					dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_ARMOR]);
+					break;
+				case 'x': // current rockets
+					dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_ROCKETS]);
+					break;
+				case 'c': // current cells
+					dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_CELLS]);
+					break;
+				// silly proquake macros
+				case 'd': // loc at last death
+					CL_Locs_FindLocationName(temp, sizeof(temp), cl.lastdeathorigin);
+					break;
+				case 't': // current time
+					dpsnprintf(temp, sizeof(temp), "%.0f:%.0f", floor(cl.time / 60), cl.time - floor(cl.time / 60) * 60);
+					break;
+				case 'r': // rocket launcher status ("I have RL", "I need rockets", "I need RL")
+					if (!(cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER))
+						dpsnprintf(temp, sizeof(temp), "I need RL");
+					else if (!cl.stats[STAT_ROCKETS])
+						dpsnprintf(temp, sizeof(temp), "I need rockets");
+					else
+						dpsnprintf(temp, sizeof(temp), "I have RL");
+					break;
+				case 'p': // powerup status (outputs "quad" "pent" and "eyes" according to status)
+					if (cl.stats[STAT_ITEMS] & IT_QUAD)
+					{
+						if (temp[0])
+							strlcat(temp, " ", sizeof(temp));
+						strlcat(temp, "quad", sizeof(temp));
+					}
+					if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)
+					{
+						if (temp[0])
+							strlcat(temp, " ", sizeof(temp));
+						strlcat(temp, "pent", sizeof(temp));
+					}
+					if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
+					{
+						if (temp[0])
+							strlcat(temp, " ", sizeof(temp));
+						strlcat(temp, "eyes", sizeof(temp));
+					}
+					break;
+				case 'w': // weapon status (outputs "SSG:NG:SNG:GL:RL:LG" with the text between : characters omitted if you lack the weapon)
+					if (cl.stats[STAT_ITEMS] & IT_SUPER_SHOTGUN)
+						strlcat(temp, "SSG", sizeof(temp));
+					strlcat(temp, ":", sizeof(temp));
+					if (cl.stats[STAT_ITEMS] & IT_NAILGUN)
+						strlcat(temp, "NG", sizeof(temp));
+					strlcat(temp, ":", sizeof(temp));
+					if (cl.stats[STAT_ITEMS] & IT_SUPER_NAILGUN)
+						strlcat(temp, "SNG", sizeof(temp));
+					strlcat(temp, ":", sizeof(temp));
+					if (cl.stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER)
+						strlcat(temp, "GL", sizeof(temp));
+					strlcat(temp, ":", sizeof(temp));
+					if (cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER)
+						strlcat(temp, "RL", sizeof(temp));
+					strlcat(temp, ":", sizeof(temp));
+					if (cl.stats[STAT_ITEMS] & IT_LIGHTNING)
+						strlcat(temp, "LG", sizeof(temp));
+					break;
+				default:
+					// not a recognized macro, print it as-is...
+					temp[0] = s[0];
+					temp[1] = s[1];
+					temp[2] = 0;
+					break;
+				}
+				// write the resulting text
+				SZ_Write(&cls.netcon->message, (unsigned char *)temp, strlen(temp));
+				s += 2;
+				continue;
+			}
+			MSG_WriteByte(&cls.netcon->message, *s);
+			s++;
+		}
+		MSG_WriteByte(&cls.netcon->message, 0);
+	}
+	else // any other command is passed on as-is
+		SZ_Write(&cls.netcon->message, (const unsigned char *)s, (int)strlen(s) + 1);
 }
 
 /*