#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)
-
typedef struct cmdalias_s
{
struct cmdalias_s *next;
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);
+ }
+}
+
/*
=============================================================================
}
}
+/*
+============
+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
char line[MAX_INPUTLINE];
char preprocessed[MAX_INPUTLINE];
char *firstchar;
- int quotes;
+ qboolean quotes, 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 = 0;
- for (i=0 ; i< cmd_text.cursize ; i++)
+ quotes = false;
+ comment = false;
+ for (i=0 ; i < cmd_text.cursize ; i++)
{
- 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(!comment)
+ {
+ if (text[i] == '"')
+ quotes = !quotes;
+
+ if(quotes)
+ {
+ // 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++;
+ }
+ else
+ {
+ if(text[i] == '/' && text[i + 1] == '/' && (i == 0 || ISWHITESPACE(text[i-1])))
+ comment = true;
+ if(text[i] == ';')
+ break; // don't break if inside a quoted string or comment
+ }
+ }
+
if (text[i] == '\r' || text[i] == '\n')
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
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
}
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) );
}
}
}
{
Con_Print("Current alias commands:\n");
for (a = cmd_alias ; a ; a=a->next)
- Con_Printf("%s : %s\n", a->name, a->value);
+ Con_Printf("%s : %s", a->name, a->value);
return;
}
strlcat (cmd, "\n", sizeof (cmd));
alloclen = strlen (cmd) + 1;
+ if(alloclen >= 2)
+ cmd[alloclen - 2] = '\n'; // to make sure a newline is appended even if too long
a->value = (char *)Z_Malloc (alloclen);
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 == 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);
+ }
+}
+
/*
=============================================================================
*is_multiple = true;
// kill pre-argument whitespace
- for (;*p && *p <= ' ';p++)
+ for (;*p && ISWHITESPACE(*p);p++)
;
return p;
// Exception: $* and $n- don't use the quoted form by default
varstr = Cmd_GetDirectCvarValue(varname, alias, &is_multiple);
if(is_multiple)
- varfunc = "asis";
+ if(!varfunc)
+ varfunc = "asis";
}
if(!varstr)
/*
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 ) {
const char *in;
--eat;
}
}
- } else {
- outtext[outlen++] = *in++;
}
+ else
+ outtext[outlen++] = *in++;
}
outtext[outlen] = 0;
}
*/
static void Cmd_ExecuteAlias (cmdalias_t *alias)
{
- static char buffer[ MAX_INPUTLINE + 2 ];
- static char buffer2[ MAX_INPUTLINE * 2 + 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)
-
+
// 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_function_t *cmd;
const char *partial;
- int len, count;
+ size_t len;
+ int count;
+ qboolean ispattern;
if (Cmd_Argc() > 1)
{
partial = Cmd_Argv (1);
- len = (int)strlen(partial);
+ len = strlen(partial);
}
else
{
len = 0;
}
+ ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
+
count = 0;
for (cmd = cmd_functions; cmd; cmd = cmd->next)
{
- if (partial && strncmp(partial, cmd->name, len))
+ if (partial && (ispattern ? !matchpattern_with_separator(cmd->name, partial, false, "", false) : strncmp(partial, cmd->name, len)))
continue;
Con_Printf("%s : %s\n", cmd->name, cmd->description);
count++;
}
- if (partial)
- Con_Printf("%i Command%s beginning with \"%s\"\n\n", count, (count > 1) ? "s" : "", partial);
+ if (len)
+ {
+ if(ispattern)
+ Con_Printf("%i Command%s matching \"%s\"\n\n", count, (count > 1) ? "s" : "", partial);
+ else
+ Con_Printf("%i Command%s beginning with \"%s\"\n\n", count, (count > 1) ? "s" : "", partial);
+ }
else
Con_Printf("%i Command%s\n\n", count, (count > 1) ? "s" : "");
}
+static void Cmd_Apropos_f(void)
+{
+ cmd_function_t *cmd;
+ cvar_t *cvar;
+ cmdalias_t *alias;
+ const char *partial;
+ size_t len;
+ int count;
+ qboolean ispattern;
+
+ if (Cmd_Argc() > 1)
+ {
+ partial = Cmd_Args();
+ len = strlen(partial);
+ }
+ else
+ {
+ Con_Printf("usage: apropos <string>\n");
+ return;
+ }
+
+ ispattern = partial && (strchr(partial, '*') || strchr(partial, '?'));
+ if(!ispattern)
+ {
+ partial = va("*%s*", partial);
+ len += 2;
+ }
+
+ count = 0;
+ for (cvar = cvar_vars; cvar; cvar = cvar->next)
+ {
+ if (!matchpattern_with_separator(cvar->name, partial, true, "", false))
+ if (!matchpattern_with_separator(cvar->description, partial, true, "", false))
+ continue;
+ Con_Printf ("cvar ^3%s^7 is \"%s\" [\"%s\"] %s\n", cvar->name, cvar->string, cvar->defstring, cvar->description);
+ count++;
+ }
+ for (cmd = cmd_functions; cmd; cmd = cmd->next)
+ {
+ if (!matchpattern_with_separator(cmd->name, partial, true, "", false))
+ if (!matchpattern_with_separator(cmd->description, partial, true, "", false))
+ continue;
+ Con_Printf("command ^2%s^7: %s\n", cmd->name, cmd->description);
+ count++;
+ }
+ for (alias = cmd_alias; alias; alias = alias->next)
+ {
+ if (!matchpattern_with_separator(alias->name, partial, true, "", false))
+ if (!matchpattern_with_separator(alias->value, partial, true, "", false))
+ continue;
+ Con_Printf("alias ^5%s^7: %s", alias->name, alias->value);
+ count++;
+ }
+ Con_Printf("%i result%s\n\n", count, (count > 1) ? "s" : "");
+}
+
/*
============
Cmd_Init
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");
+#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");
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)");
+ 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)");
while (1)
{
// skip whitespace up to a /n
- while (*text && *text <= ' ' && *text != '\r' && *text != '\n')
+ while (*text && ISWHITESPACE(*text) && *text != '\r' && *text != '\n')
text++;
// line endings:
// Loop through the command list and print all matches
for (cmd = cmd_functions; cmd; cmd = cmd->next)
if (!strncasecmp(partial, cmd->name, len))
- Con_Printf("%s : %s\n", cmd->name, cmd->description);
+ Con_Printf("^2%s^7: %s\n", cmd->name, cmd->description);
}
/*
// Loop through the alias list and print all matches
for (alias = cmd_alias; alias; alias = alias->next)
if (!strncasecmp(partial, alias->name, len))
- Con_Printf("%s : %s\n", alias->name, alias->value);
+ Con_Printf("^5%s^7: %s", alias->name, alias->value);
}
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);
}
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)
{
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;
}
}
}
+ 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));
projects / xonotic / darkplaces.git / blobdiff