// cmd.c -- Quake script command processing module
#include "quakedef.h"
-
-#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
-// 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 + MAX_ARGS)
+#include "thread.h"
typedef struct cmdalias_s
{
struct cmdalias_s *next;
char name[MAX_ALIAS_NAME];
char *value;
+ qboolean initstate; // indicates this command existed at init
+ char *initialvalue; // backup copy of value at init
} cmdalias_t;
static cmdalias_t *cmd_alias;
{
struct cmddeferred_s *next;
char *value;
- double time;
+ double delay;
} cmddeferred_t;
static cmddeferred_t *cmd_deferred_list = NULL;
{
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);
+ Con_Printf("-> In %9.2f: %s\n", next->delay, next->value);
next = next->next;
}
} else if(Cmd_Argc() == 2 && !strcasecmp("clear", Cmd_Argv(1)))
cmddeferred_t *defcmd = (cmddeferred_t*)Mem_Alloc(tempmempool, sizeof(*defcmd));
size_t len = strlen(value);
- defcmd->time = Sys_DoubleTime() + atof(Cmd_Argv(1));
+ defcmd->delay = atof(Cmd_Argv(1));
defcmd->value = (char*)Mem_Alloc(tempmempool, len+1);
memcpy(defcmd->value, value, len+1);
defcmd->next = NULL;
static sizebuf_t cmd_text;
static unsigned char cmd_text_buf[CMDBUFSIZE];
+void *cmd_text_mutex = NULL;
+
+#define Cbuf_LockThreadMutex() (void)(cmd_text_mutex ? Thread_LockMutex(cmd_text_mutex) : 0)
+#define Cbuf_UnlockThreadMutex() (void)(cmd_text_mutex ? Thread_UnlockMutex(cmd_text_mutex) : 0)
/*
============
{
int l;
- l = (int)strlen (text);
+ l = (int)strlen(text);
+ Cbuf_LockThreadMutex();
if (cmd_text.cursize + l >= cmd_text.maxsize)
- {
Con_Print("Cbuf_AddText: overflow\n");
- return;
- }
-
- SZ_Write (&cmd_text, (const unsigned char *)text, (int)strlen (text));
+ else
+ SZ_Write(&cmd_text, (const unsigned char *)text, l);
+ Cbuf_UnlockThreadMutex();
}
*/
void Cbuf_InsertText (const char *text)
{
- char *temp;
- int templen;
-
- // copy off any commands still remaining in the exec buffer
- templen = cmd_text.cursize;
- if (templen)
- {
- temp = (char *)Mem_Alloc (tempmempool, templen);
- memcpy (temp, cmd_text.data, templen);
- SZ_Clear (&cmd_text);
- }
+ size_t l = strlen(text);
+ Cbuf_LockThreadMutex();
+ // we need to memmove the existing text and stuff this in before it...
+ if (cmd_text.cursize + l >= (size_t)cmd_text.maxsize)
+ Con_Print("Cbuf_InsertText: overflow\n");
else
- temp = NULL;
-
- // add the entire text of the file
- Cbuf_AddText (text);
-
- // add the copied off data
- if (temp != NULL)
{
- SZ_Write (&cmd_text, (const unsigned char *)temp, templen);
- Mem_Free (temp);
+ // we don't have a SZ_Prepend, so...
+ memmove(cmd_text.data + l, cmd_text.data, cmd_text.cursize);
+ cmd_text.cursize += l;
+ memcpy(cmd_text.data, text, l);
}
+ Cbuf_UnlockThreadMutex();
}
/*
Cbuf_Execute_Deferred --blub
============
*/
-void Cbuf_Execute_Deferred (void)
+static void Cbuf_Execute_Deferred (void)
{
+ static double oldrealtime = 0;
cmddeferred_t *cmd, *prev;
- double time = Sys_DoubleTime();
+ double eat;
+ if (realtime - oldrealtime < 0 || realtime - oldrealtime > 1800) oldrealtime = realtime;
+ eat = realtime - oldrealtime;
+ if (eat < (1.0 / 120.0))
+ return;
+ oldrealtime = realtime;
prev = NULL;
cmd = cmd_deferred_list;
while(cmd)
{
- if(cmd->time <= time)
+ cmd->delay -= eat;
+ if(cmd->delay <= 0)
{
Cbuf_AddText(cmd->value);
Cbuf_AddText(";\n");
Cbuf_Execute
============
*/
-static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias );
+static qboolean Cmd_PreprocessString( const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias );
void Cbuf_Execute (void)
{
int i;
char line[MAX_INPUTLINE];
char preprocessed[MAX_INPUTLINE];
char *firstchar;
- qboolean quotes, comment;
+ qboolean quotes;
+ char *comment;
// 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
text = (char *)cmd_text.data;
quotes = false;
- comment = false;
+ comment = NULL;
for (i=0 ; i < cmd_text.cursize ; i++)
{
if(!comment)
}
else
{
- if(text[i] == '/' && text[i + 1] == '/')
- comment = true;
+ if(text[i] == '/' && text[i + 1] == '/' && (i == 0 || ISWHITESPACE(text[i-1])))
+ comment = &text[i];
if(text[i] == ';')
break; // don't break if inside a quoted string or comment
}
}
else
{
- memcpy (line, text, i);
- line[i] = 0;
+ memcpy (line, text, comment ? (comment - text) : i);
+ line[comment ? (comment - text) : i] = 0;
}
// delete the text from the command buffer and move remaining commands down
}
// execute the command line
- firstchar = line + strspn(line, " \t");
+ firstchar = line;
+ while(*firstchar && ISWHITESPACE(*firstchar))
+ ++firstchar;
if(
- (strncmp(firstchar, "alias", 5) || (firstchar[5] != ' ' && firstchar[5] != '\t'))
+ (strncmp(firstchar, "alias", 5) || !ISWHITESPACE(firstchar[5]))
&&
- (strncmp(firstchar, "bind", 4) || (firstchar[4] != ' ' && firstchar[4] != '\t'))
+ (strncmp(firstchar, "bind", 4) || !ISWHITESPACE(firstchar[4]))
&&
- (strncmp(firstchar, "in_bind", 7) || (firstchar[7] != ' ' && firstchar[7] != '\t'))
+ (strncmp(firstchar, "in_bind", 7) || !ISWHITESPACE(firstchar[7]))
)
{
- Cmd_PreprocessString( line, preprocessed, sizeof(preprocessed), NULL );
- Cmd_ExecuteString (preprocessed, src_command);
+ if(Cmd_PreprocessString( line, preprocessed, sizeof(preprocessed), NULL ))
+ Cmd_ExecuteString (preprocessed, src_command, false);
}
else
{
- Cmd_ExecuteString (line, src_command);
+ Cmd_ExecuteString (line, src_command, false);
}
if (cmd_wait)
}
}
+void Cbuf_Frame(void)
+{
+ Cbuf_Execute_Deferred();
+ if (cmd_text.cursize)
+ {
+ SV_LockThreadMutex();
+ Cbuf_Execute();
+ SV_UnlockThreadMutex();
+ }
+}
+
/*
==============================================================================
===============
*/
qboolean host_stuffcmdsrun = false;
-void Cmd_StuffCmds_f (void)
+static void Cmd_StuffCmds_f (void)
{
int i, j, l;
// this is for all commandline options combined (and is bounds checked)
Cbuf_InsertText (build);
}
-
-/*
-===============
-Cmd_Exec_f
-===============
-*/
-static void Cmd_Exec_f (void)
+static void Cmd_Exec(const char *filename)
{
char *f;
+ qboolean isdefaultcfg = strlen(filename) >= 11 && !strcmp(filename + strlen(filename) - 11, "default.cfg");
- if (Cmd_Argc () != 2)
+ if (!strcmp(filename, "config.cfg"))
{
- Con_Print("exec <filename> : execute a script file\n");
- return;
+ filename = CONFIGFILENAME;
+ if (COM_CheckParm("-noconfig"))
+ return; // don't execute config.cfg
}
- f = (char *)FS_LoadFile (Cmd_Argv(1), tempmempool, false, NULL);
+ f = (char *)FS_LoadFile (filename, tempmempool, false, NULL);
if (!f)
{
- Con_Printf("couldn't exec %s\n",Cmd_Argv(1));
+ Con_Printf("couldn't exec %s\n",filename);
return;
}
- Con_Printf("execing %s\n",Cmd_Argv(1));
+ Con_Printf("execing %s\n",filename);
// 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"))
+ if (isdefaultcfg)
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)
Cbuf_InsertText ("\n");
Cbuf_InsertText (f);
Mem_Free(f);
+
+ if (isdefaultcfg)
+ {
+ // special defaults for specific games go here, these execute before default.cfg
+ // Nehahra pushable crates malfunction in some levels if this is on
+ // Nehahra NPC AI is confused by blowupfallenzombies
+ if (gamemode == GAME_NEHAHRA)
+ Cbuf_InsertText("\nsv_gameplayfix_upwardvelocityclearsongroundflag 0\nsv_gameplayfix_blowupfallenzombies 0\n\n");
+ // hipnotic mission pack has issues in their 'friendly monster' ai, which seem to attempt to attack themselves for some reason when findradius() returns non-solid entities.
+ // hipnotic mission pack has issues with bobbing water entities 'jittering' between different heights on alternate frames at the default 0.0138889 ticrate, 0.02 avoids this issue
+ // hipnotic mission pack has issues in their proximity mine sticking code, which causes them to bounce off.
+ if (gamemode == GAME_HIPNOTIC)
+ Cbuf_InsertText("\nsv_gameplayfix_blowupfallenzombies 0\nsys_ticrate 0.02\nsv_gameplayfix_slidemoveprojectiles 0\n\n");
+ // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area
+ if (gamemode == GAME_ROGUE)
+ Cbuf_InsertText("\nsv_gameplayfix_findradiusdistancetobox 0\n\n");
+ if (gamemode == GAME_NEXUIZ)
+ Cbuf_InsertText("\nsv_gameplayfix_q2airaccelerate 1\nsv_gameplayfix_stepmultipletimes 1\n\n");
+ if (gamemode == GAME_TENEBRAE)
+ Cbuf_InsertText("\nr_shadow_gloss 2\nr_shadow_bumpscale_basetexture 4\n\n");
+ // Steel Storm: Burning Retribution csqc misinterprets CSQC_InputEvent if type is a value other than 0 or 1
+ if (gamemode == GAME_STEELSTORM)
+ Cbuf_InsertText("\ncl_csqc_generatemousemoveevents 0\n\n");
+ }
+}
+
+/*
+===============
+Cmd_Exec_f
+===============
+*/
+static void Cmd_Exec_f (void)
+{
+ fssearch_t *s;
+ int i;
+
+ if (Cmd_Argc () != 2)
+ {
+ Con_Print("exec <filename> : execute a script file\n");
+ return;
+ }
+
+ s = FS_Search(Cmd_Argv(1), true, true);
+ if(!s || !s->numfilenames)
+ {
+ Con_Printf("couldn't exec %s\n",Cmd_Argv(1));
+ return;
+ }
+
+ for(i = 0; i < s->numfilenames; ++i)
+ Cmd_Exec(s->filenames[i]);
+
+ FS_FreeSearch(s);
}
// copy the rest of the command line
cmd[0] = 0; // start out with a null string
c = Cmd_Argc();
- for (i=2 ; i< c ; i++)
+ for (i=2 ; i < c ; i++)
{
- strlcat (cmd, Cmd_Argv(i), sizeof (cmd));
- if (i != c)
+ if (i != 2)
strlcat (cmd, " ", sizeof (cmd));
+ strlcat (cmd, Cmd_Argv(i), sizeof (cmd));
}
strlcat (cmd, "\n", sizeof (cmd));
memcpy (a->value, cmd, alloclen);
}
+/*
+===============
+Cmd_UnAlias_f
+
+Remove existing aliases.
+===============
+*/
+static void Cmd_UnAlias_f (void)
+{
+ cmdalias_t *a, *p;
+ int i;
+ const char *s;
+
+ if(Cmd_Argc() == 1)
+ {
+ Con_Print("unalias: Usage: unalias alias1 [alias2 ...]\n");
+ return;
+ }
+
+ for(i = 1; i < Cmd_Argc(); ++i)
+ {
+ s = Cmd_Argv(i);
+ p = NULL;
+ for(a = cmd_alias; a; p = a, a = a->next)
+ {
+ if(!strcmp(s, a->name))
+ {
+ if (a->initstate) // we can not remove init aliases
+ continue;
+ if(a == cmd_alias)
+ cmd_alias = a->next;
+ if(p)
+ p->next = a->next;
+ Z_Free(a->value);
+ Z_Free(a);
+ break;
+ }
+ }
+ if(!a)
+ Con_Printf("unalias: %s alias not found\n", s);
+ }
+}
+
/*
=============================================================================
xcommand_t consolefunction;
xcommand_t clientfunction;
qboolean csqcfunc;
+ qboolean initstate; // indicates this command existed at init
} cmd_function_t;
static int cmd_argc;
cvar_t *cvar;
long argno;
char *endptr;
+ char vabuf[1024];
if(is_multiple)
*is_multiple = false;
*is_multiple = true;
return Cmd_Args();
}
+ else if(!strcmp(varname, "#"))
+ {
+ return va(vabuf, sizeof(vabuf), "%d", Cmd_Argc());
+ }
else if(varname[strlen(varname) - 1] == '-')
{
argno = strtol(varname, &endptr, 10);
return NULL;
}
-qboolean Cmd_QuoteString(char *out, size_t outlen, const char *in, const char *quoteset)
+qboolean Cmd_QuoteString(char *out, size_t outlen, const char *in, const char *quoteset, qboolean putquotes)
{
qboolean quote_quot = !!strchr(quoteset, '"');
qboolean quote_backslash = !!strchr(quoteset, '\\');
qboolean quote_dollar = !!strchr(quoteset, '$');
+ if(putquotes)
+ {
+ if(outlen <= 2)
+ {
+ *out++ = 0;
+ return false;
+ }
+ *out++ = '"'; --outlen;
+ --outlen;
+ }
+
while(*in)
{
if(*in == '"' && quote_quot)
{
if(outlen <= 2)
- {
- *out++ = 0;
- return false;
- }
+ goto fail;
*out++ = '\\'; --outlen;
*out++ = '"'; --outlen;
}
else if(*in == '\\' && quote_backslash)
{
if(outlen <= 2)
- {
- *out++ = 0;
- return false;
- }
+ goto fail;
*out++ = '\\'; --outlen;
*out++ = '\\'; --outlen;
}
else if(*in == '$' && quote_dollar)
{
if(outlen <= 2)
- {
- *out++ = 0;
- return false;
- }
+ goto fail;
*out++ = '$'; --outlen;
*out++ = '$'; --outlen;
}
else
{
if(outlen <= 1)
- {
- *out++ = 0;
- return false;
- }
+ goto fail;
*out++ = *in; --outlen;
}
++in;
}
+ if(putquotes)
+ *out++ = '"';
*out++ = 0;
return true;
+fail:
+ if(putquotes)
+ *out++ = '"';
+ *out++ = 0;
+ return false;
}
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;
+ static char varname[MAX_INPUTLINE]; // cmd_mutex
+ static char varval[MAX_INPUTLINE]; // cmd_mutex
+ const char *varstr = NULL;
char *varfunc;
+ qboolean required = false;
+ qboolean optional = false;
+ static char asis[] = "asis"; // just to suppress const char warnings
if(varlen >= MAX_INPUTLINE)
varlen = MAX_INPUTLINE - 1;
if(*var == 0)
{
// empty cvar name?
- return NULL;
+ if(alias)
+ Con_Printf("Warning: Could not expand $ in alias %s\n", alias->name);
+ else
+ Con_Printf("Warning: Could not expand $\n");
+ return "$";
}
- varstr = NULL;
+ if(varfunc)
+ {
+ char *p;
+ // ? means optional
+ while((p = strchr(varfunc, '?')))
+ {
+ optional = true;
+ memmove(p, p+1, strlen(p)); // with final NUL
+ }
+ // ! means required
+ while((p = strchr(varfunc, '!')))
+ {
+ required = true;
+ memmove(p, p+1, strlen(p)); // with final NUL
+ }
+ // kill spaces
+ while((p = strchr(varfunc, ' ')))
+ {
+ memmove(p, p+1, strlen(p)); // with final NUL
+ }
+ // if no function is left, NULL it
+ if(!*varfunc)
+ varfunc = NULL;
+ }
if(varname[0] == '$')
varstr = Cmd_GetDirectCvarValue(Cmd_GetDirectCvarValue(varname + 1, alias, NULL), alias, NULL);
varstr = Cmd_GetDirectCvarValue(varname, alias, &is_multiple);
if(is_multiple)
if(!varfunc)
- varfunc = "asis";
+ varfunc = asis;
}
if(!varstr)
{
- if(alias)
- Con_Printf("Warning: Could not expand $%s in alias %s\n", varname, alias->name);
+ if(required)
+ {
+ if(alias)
+ Con_Printf("Error: Could not expand $%s in alias %s\n", varname, alias->name);
+ else
+ Con_Printf("Error: Could not expand $%s\n", varname);
+ return NULL;
+ }
+ else if(optional)
+ {
+ return "";
+ }
else
- Con_Printf("Warning: Could not expand $%s\n", varname);
- return NULL;
+ {
+ 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);
+ dpsnprintf(varval, sizeof(varval), "$%s", varname);
+ return varval;
+ }
}
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, "\"\\");
+ Cmd_QuoteString(varval, sizeof(varval), varstr, "\"\\", false);
return varval;
}
else if(!strcmp(varfunc, "asis"))
/*
Cmd_PreprocessString
-Preprocesses strings and replaces $*, $param#, $cvar accordingly
+Preprocesses strings and replaces $*, $param#, $cvar accordingly. Also strips comments.
*/
-static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias ) {
+static qboolean Cmd_PreprocessString( const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias ) {
const char *in;
size_t eat, varlen;
unsigned outlen;
// don't crash if there's no room in the outtext buffer
if( maxoutlen == 0 ) {
- return;
+ return false;
}
maxoutlen--; // because of \0
// that way)
// - ${var asis} inserts the cvar value as is, without doing this
// quoting
+ // - ${var ?} silently expands to the empty string if
+ // $var does not exist
+ // - ${var !} fails expansion and executes nothing if
+ // $var does not exist
// - 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
// 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-).
+ // - ${* q} and ${n- q} force quoting anyway
//
// Note: when expanding an alias, cvar expansion is done in the SAME step
// as alias expansion so that alias parameters or cvar values containing
if(in[varlen + 1] == '}')
{
val = Cmd_GetCvarValue(in + 1, varlen, alias);
+ if(!val)
+ return false;
eat = varlen + 2;
}
else
eat = varlen + 1;
}
} else {
- varlen = strspn(in, "*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-");
+ varlen = strspn(in, "#*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-");
val = Cmd_GetCvarValue(in, varlen, alias);
+ if(!val)
+ return false;
eat = varlen;
}
if(val)
--eat;
}
}
- } else {
- outtext[outlen++] = *in++;
}
+ else
+ outtext[outlen++] = *in++;
}
outtext[outlen] = 0;
+ return true;
}
/*
*/
static void Cmd_ExecuteAlias (cmdalias_t *alias)
{
- static char buffer[ MAX_INPUTLINE ];
- static char buffer2[ MAX_INPUTLINE ];
- Cmd_PreprocessString( alias->value, buffer, sizeof(buffer) - 2, alias );
+ static char buffer[ MAX_INPUTLINE ]; // cmd_mutex
+ static char buffer2[ MAX_INPUTLINE ]; // cmd_mutex
+ qboolean ret = Cmd_PreprocessString( alias->value, buffer, sizeof(buffer) - 2, alias );
+ if(!ret)
+ return;
// insert at start of command buffer, so that aliases execute in order
// (fixes bug introduced by Black on 20050705)
// 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, "$");
+ Cmd_QuoteString(buffer2, sizeof(buffer2), buffer, "$", false);
Cbuf_InsertText( buffer2 );
}
cvar_t *cvar;
cmdalias_t *alias;
const char *partial;
- size_t len;
int count;
qboolean ispattern;
+ char vabuf[1024];
if (Cmd_Argc() > 1)
- {
partial = Cmd_Args();
- len = strlen(partial);
- }
else
{
Con_Printf("usage: apropos <string>\n");
ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
if(!ispattern)
- {
- partial = va("*%s*", partial);
- len += 2;
- }
+ partial = va(vabuf, sizeof(vabuf), "*%s*", partial);
count = 0;
for (cvar = cvar_vars; cvar; cvar = cvar->next)
}
for (alias = cmd_alias; alias; alias = alias->next)
{
+ // procede here a bit differently as an alias value always got a final \n
if (!matchpattern_with_separator(alias->name, partial, true, "", false))
- if (!matchpattern_with_separator(alias->value, partial, true, "", false))
+ if (!matchpattern_with_separator(alias->value, partial, true, "\n", false)) // when \n is as separator wildcards don't match it
continue;
- Con_Printf("alias ^5%s^7: %s", alias->name, alias->value);
+ Con_Printf("alias ^5%s^7: %s", alias->name, alias->value); // do not print an extra \n
count++;
}
Con_Printf("%i result%s\n\n", count, (count > 1) ? "s" : "");
cmd_text.data = cmd_text_buf;
cmd_text.maxsize = sizeof(cmd_text_buf);
cmd_text.cursize = 0;
+
+ if (Thread_HasThreads())
+ cmd_text_mutex = Thread_CreateMutex();
}
void Cmd_Init_Commands (void)
Cmd_AddCommand ("stuffcmds",Cmd_StuffCmds_f, "execute commandline parameters (must be present in quake.rc script)");
Cmd_AddCommand ("exec",Cmd_Exec_f, "execute a script file");
Cmd_AddCommand ("echo",Cmd_Echo_f, "print a message to the console (useful in scripts)");
- Cmd_AddCommand ("alias",Cmd_Alias_f, "create a script function (parameters are passed in as $1 through $9, and $* for all parameters)");
+ Cmd_AddCommand ("alias",Cmd_Alias_f, "create a script function (parameters are passed in as $X (being X a number), $* for all parameters, $X- for all parameters starting from $X). Without arguments show the list of all alias");
+ Cmd_AddCommand ("unalias",Cmd_UnAlias_f, "remove an alias");
Cmd_AddCommand ("cmd", Cmd_ForwardToServer, "send a console commandline to the server (used by some mods)");
Cmd_AddCommand ("wait", Cmd_Wait_f, "make script execution wait for next rendered frame");
Cmd_AddCommand ("set", Cvar_Set_f, "create or change the value of a console variable");
Cmd_AddCommand ("seta", Cvar_SetA_f, "create or change the value of a console variable that will be saved to config.cfg");
+ Cmd_AddCommand ("unset", Cvar_Del_f, "delete a cvar (does not work for static ones like _cl_name, or read-only ones)");
+#ifdef FILLALLCVARSWITHRUBBISH
+ Cmd_AddCommand ("fillallcvarswithrubbish", Cvar_FillAll_f, "fill all cvars with a specified number of characters to provoke buffer overruns");
+#endif /* FILLALLCVARSWITHRUBBISH */
// 2000-01-09 CmdList, CvarList commands By Matthias "Maddes" Buecher
// Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
- 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 ("cmdlist", Cmd_List_f, "lists all console commands beginning with the specified prefix or matching the specified wildcard pattern");
+ Cmd_AddCommand ("cvarlist", Cvar_List_f, "lists all console variables beginning with the specified prefix or matching the specified wildcard pattern");
Cmd_AddCommand ("apropos", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description");
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");
*/
void Cmd_Shutdown(void)
{
+ if (cmd_text_mutex)
+ {
+ // we usually have this locked when we get here from Host_Quit_f
+ Cbuf_UnlockThreadMutex();
+ Thread_DestroyMutex(cmd_text_mutex);
+ }
+ cmd_text_mutex = NULL;
+
Mem_FreePool(&cmd_mempool);
}
cmd->csqcfunc = false;
}
-qboolean CL_VM_ConsoleCommand (const char *cmd);
/*
============
Cmd_ExecuteString
FIXME: lookupnoadd the token to speed search?
============
*/
-void Cmd_ExecuteString (const char *text, cmd_source_t src)
+void Cmd_ExecuteString (const char *text, cmd_source_t src, qboolean lockmutex)
{
int oldpos;
int found;
// execute the command line
if (!Cmd_Argc())
- {
- cmd_tokenizebufferpos = oldpos;
- return; // no tokens
- }
+ goto done; // no tokens
// check functions
for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
if (!strcasecmp (cmd_argv[0],cmd->name))
{
if (cmd->csqcfunc && CL_VM_ConsoleCommand (text)) //[515]: csqc
- return;
+ goto done;
switch (src)
{
case src_command:
Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(0));
found = true;
goto command_found;
- break;
case src_client:
if (cmd->clientfunction)
{
cmd->clientfunction ();
- cmd_tokenizebufferpos = oldpos;
- return;
+ goto done;
}
break;
}
if (cmd_source == src_client)
{
Con_Printf("player \"%s\" tried to %s\n", host_client->name, text);
- cmd_tokenizebufferpos = oldpos;
- return;
+ goto done;
}
// check alias
if (!strcasecmp (cmd_argv[0], a->name))
{
Cmd_ExecuteAlias(a);
- cmd_tokenizebufferpos = oldpos;
- return;
+ goto done;
}
}
if(found) // if the command was hooked and found, all is good
- {
- cmd_tokenizebufferpos = oldpos;
- return;
- }
+ goto done;
// check cvars
if (!Cvar_Command () && host_framecount > 0)
Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(0));
+done:
cmd_tokenizebufferpos = oldpos;
}
void Cmd_ForwardToServer (void)
{
const char *s;
+ char vabuf[1024];
if (!strcasecmp(Cmd_Argv(0), "cmd"))
{
// we want to strip off "cmd", so just send the args
else
{
// we need to keep the command name, so send Cmd_Argv(0), a space and then Cmd_Args()
- s = va("%s %s", Cmd_Argv(0), Cmd_Argc() > 1 ? Cmd_Args() : "");
+ s = va(vabuf, sizeof(vabuf), "%s %s", Cmd_Argv(0), Cmd_Argc() > 1 ? Cmd_Args() : "");
}
// don't send an empty forward message if the user tries "cmd" by itself
if (!s || !*s)
return 0;
}
+
+
+void Cmd_SaveInitState(void)
+{
+ cmd_function_t *f;
+ cmdalias_t *a;
+ for (f = cmd_functions;f;f = f->next)
+ f->initstate = true;
+ for (a = cmd_alias;a;a = a->next)
+ {
+ a->initstate = true;
+ a->initialvalue = Mem_strdup(zonemempool, a->value);
+ }
+ Cvar_SaveInitState();
+}
+
+void Cmd_RestoreInitState(void)
+{
+ cmd_function_t *f, **fp;
+ cmdalias_t *a, **ap;
+ for (fp = &cmd_functions;(f = *fp);)
+ {
+ if (f->initstate)
+ fp = &f->next;
+ else
+ {
+ // destroy this command, it didn't exist at init
+ Con_DPrintf("Cmd_RestoreInitState: Destroying command %s\n", f->name);
+ *fp = f->next;
+ Z_Free(f);
+ }
+ }
+ for (ap = &cmd_alias;(a = *ap);)
+ {
+ if (a->initstate)
+ {
+ // restore this alias, it existed at init
+ if (strcmp(a->value ? a->value : "", a->initialvalue ? a->initialvalue : ""))
+ {
+ Con_DPrintf("Cmd_RestoreInitState: Restoring alias %s\n", a->name);
+ if (a->value)
+ Z_Free(a->value);
+ a->value = Mem_strdup(zonemempool, a->initialvalue);
+ }
+ ap = &a->next;
+ }
+ else
+ {
+ // free this alias, it didn't exist at init...
+ Con_DPrintf("Cmd_RestoreInitState: Destroying alias %s\n", a->name);
+ *ap = a->next;
+ if (a->value)
+ Z_Free(a->value);
+ Z_Free(a);
+ }
+ }
+ Cvar_RestoreInitState();
+}
projects / xonotic / darkplaces.git / blobdiff