X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cmd.c;h=2e80075469fc0fb138016c97817a8d6bf3862fb3;hp=7f2a113a50df808e97988f3b303e6542c22f22fa;hb=46cfccb1fef9095b35d4f6c37876a178361e3174;hpb=40be639bbfcaf20165f93d70d32de89f92d4186a

diff --git a/cmd.c b/cmd.c
index 7f2a113a..2e800754 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
 {
@@ -144,6 +145,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 +161,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 +182,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 +234,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)
@@ -225,12 +243,17 @@ void Cmd_StuffCmds_f (void)
 		return;
 	}
 
+	// no reason to run the commandline arguments twice
+	if (host_stuffcmdsrun)
+		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++];
@@ -241,20 +264,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);
 }
 
 
@@ -281,6 +308,15 @@ static void Cmd_Exec_f (void)
 	}
 	Con_DPrintf("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
+	// but Cbuf_InsertText inserts before, so this actually ends up after it.
+	if (!strcmp(Cmd_Argv(1), "default.cfg"))
+		Cbuf_InsertText("\ncvar_lockdefaults\n");
+
+	// insert newline after the text to make sure the last line is terminated (some text editors omit the trailing newline)
+	// (note: insertion order here is backwards from execution order, so this adds it after the text, by calling it before...)
+	Cbuf_InsertText ("\n");
 	Cbuf_InsertText (f);
 	Mem_Free(f);
 }
@@ -323,7 +359,7 @@ static void Cmd_Toggle_f(void)
 	{ // Correct Arguments Specified
 		// Acquire Potential CVar
 		cvar_t* cvCVar = Cvar_FindVar( Cmd_Argv(1) );
-		
+
 		if(cvCVar != NULL)
 		{ // Valid CVar
 			if(nNumArgs == 2)
@@ -395,6 +431,7 @@ static void Cmd_Alias_f (void)
 	char		cmd[MAX_INPUTLINE];
 	int			i, c;
 	const char		*s;
+	size_t		alloclen;
 
 	if (Cmd_Argc() == 1)
 	{
@@ -450,8 +487,9 @@ static void Cmd_Alias_f (void)
 	}
 	strlcat (cmd, "\n", sizeof (cmd));
 
-	a->value = (char *)Z_Malloc (strlen (cmd) + 1);
-	strcpy (a->value, cmd);
+	alloclen = strlen (cmd) + 1;
+	a->value = (char *)Z_Malloc (alloclen);
+	memcpy (a->value, cmd, alloclen);
 }
 
 /*
@@ -467,7 +505,8 @@ typedef struct cmd_function_s
 	struct cmd_function_s *next;
 	const char *name;
 	const char *description;
-	xcommand_t function;
+	xcommand_t consolefunction;
+	xcommand_t clientfunction;
 	qboolean csqcfunc;
 } cmd_function_t;
 
@@ -480,6 +519,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
 
@@ -487,8 +705,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 ) {
@@ -498,73 +717,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-).
+			//
+			// 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"
 			//
-			// 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
+			// 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 );
-				if ((cvar = Cvar_FindVar(&com_token[0]))) {
-					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++;
 		}
 	}
@@ -581,10 +825,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 );
 }
 
 /*
@@ -661,6 +911,11 @@ void Cmd_Init_Commands (void)
 	Cmd_AddCommand ("cmdlist", Cmd_List_f, "lists all console commands beginning with the specified prefix");
 	Cmd_AddCommand ("cvarlist", Cvar_List_f, "lists all console variables beginning with the specified prefix");
 
+	Cmd_AddCommand ("cvar_lockdefaults", Cvar_LockDefaults_f, "stores the current values of all cvars into their default values, only used once during startup after parsing default.cfg");
+	Cmd_AddCommand ("cvar_resettodefaults_all", Cvar_ResetToDefaults_All_f, "sets all cvars to their locked default values");
+	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)");
+
 	// 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)");
@@ -749,7 +1004,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)
@@ -760,7 +1015,7 @@ static void Cmd_TokenizeString (const char *text)
 				Con_Printf("Cmd_TokenizeString: ran out of %i character buffer space for command arguements\n", CMD_TOKENIZELENGTH);
 				break;
 			}
-			strcpy (cmd_tokenizebuffer + cmd_tokenizebufferpos, com_token);
+			memcpy (cmd_tokenizebuffer + cmd_tokenizebufferpos, com_token, l);
 			cmd_argv[cmd_argc] = cmd_tokenizebuffer + cmd_tokenizebufferpos;
 			cmd_tokenizebufferpos += l;
 			cmd_argc++;
@@ -774,7 +1029,7 @@ static void Cmd_TokenizeString (const char *text)
 Cmd_AddCommand
 ============
 */
-void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *description)
+void Cmd_AddCommand_WithClientCommand (const char *cmd_name, xcommand_t consolefunction, xcommand_t clientfunction, const char *description)
 {
 	cmd_function_t *cmd;
 	cmd_function_t *prev, *current;
@@ -791,7 +1046,7 @@ void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *desc
 	{
 		if (!strcmp (cmd_name, cmd->name))
 		{
-			if (function)
+			if (consolefunction || clientfunction)
 			{
 				Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name);
 				return;
@@ -806,9 +1061,10 @@ void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *desc
 
 	cmd = (cmd_function_t *)Mem_Alloc(cmd_mempool, sizeof(cmd_function_t));
 	cmd->name = cmd_name;
-	cmd->function = function;
+	cmd->consolefunction = consolefunction;
+	cmd->clientfunction = clientfunction;
 	cmd->description = description;
-	if(!function)			//[515]: csqc
+	if(!consolefunction && !clientfunction)			//[515]: csqc
 		cmd->csqcfunc = true;
 	cmd->next = cmd_functions;
 
@@ -823,6 +1079,11 @@ void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *desc
 	cmd->next = current;
 }
 
+void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *description)
+{
+	Cmd_AddCommand_WithClientCommand (cmd_name, function, NULL, description);
+}
+
 /*
 ============
 Cmd_Exists
@@ -1067,19 +1328,47 @@ void Cmd_ExecuteString (const char *text, cmd_source_t src)
 	{
 		if (!strcasecmp (cmd_argv[0],cmd->name))
 		{
-			if(cmd->function && !cmd->csqcfunc)
-				cmd->function ();
-			else
-				if(CL_VM_ConsoleCommand (text))	//[515]: csqc
-					return;
+			if (cmd->csqcfunc && CL_VM_ConsoleCommand (text))	//[515]: csqc
+				return;
+			switch (src)
+			{
+			case src_command:
+				if (cmd->consolefunction)
+					cmd->consolefunction ();
+				else if (cmd->clientfunction)
+				{
+					if (cls.state == ca_connected)
+					{
+						// forward remote commands to the server for execution
+						Cmd_ForwardToServer();
+					}
+					else
+						Con_Printf("Can not send command \"%s\", not connected.\n", Cmd_Argv(0));
+				}
 				else
-					if(cmd->function)
-						cmd->function ();
-			cmd_tokenizebufferpos = oldpos;
-			return;
+					Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(0));
+				cmd_tokenizebufferpos = oldpos;
+				return;
+			case src_client:
+				if (cmd->clientfunction)
+				{
+					cmd->clientfunction ();
+					cmd_tokenizebufferpos = oldpos;
+					return;
+				}
+				break;
+			}
+			break;
 		}
 	}
 
+	// 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);
+		return;
+	}
+
 // check alias
 	for (a=cmd_alias ; a ; a=a->next)
 	{
@@ -1108,6 +1397,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);
@@ -1124,7 +1414,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);
 }
 
 /*