X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cmd.c;h=a395eed658b9a65d8c95517ed3fb53e0820de83a;hp=d94857655984e47d91cd23c2fe2c0b295c13edff;hb=aff7b9f6daa22f434d25c50a984abebad71a4f22;hpb=4fcf642ab8c87b9cd34580c69c2bccded2d8fd83 diff --git a/cmd.c b/cmd.c index d9485765..a395eed6 100644 --- a/cmd.c +++ b/cmd.c @@ -21,20 +21,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #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 -#define CMDBUFSIZE 32768 -// maximum number of parameters to a command -#define MAX_ARGS 80 -// maximum tokenizable commandline length (counting NUL terminations) -#define CMD_TOKENIZELENGTH (MAX_INPUTLINE + 80) - 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; @@ -62,6 +55,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 \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 +235,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 @@ -145,31 +283,58 @@ void Cbuf_Execute (void) char line[MAX_INPUTLINE]; char preprocessed[MAX_INPUTLINE]; char *firstchar; - int quotes; + 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 = 0; - for (i=0 ; i< cmd_text.cursize ; i++) + quotes = false; + comment = NULL; + 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 = &text[i]; + 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, comment ? (comment - text) : i); + line[comment ? (comment - text) : 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 @@ -181,17 +346,19 @@ 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 - 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 ); @@ -292,6 +459,7 @@ Cmd_Exec_f static void Cmd_Exec_f (void) { char *f; + const char *filename; if (Cmd_Argc () != 2) { @@ -299,18 +467,26 @@ static void Cmd_Exec_f (void) return; } - f = (char *)FS_LoadFile (Cmd_Argv(1), tempmempool, false, NULL); + filename = Cmd_Argv(1); + if (!strcmp(filename, "config.cfg")) + { + filename = CONFIGFILENAME; + if (COM_CheckParm("-noconfig")) + return; // don't execute config.cfg + } + + 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_DPrintf("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 (strlen(filename) >= 11 && !strcmp(filename + strlen(filename) - 11, "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) @@ -318,6 +494,24 @@ static void Cmd_Exec_f (void) Cbuf_InsertText ("\n"); Cbuf_InsertText (f); Mem_Free(f); + + // 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"); } @@ -412,7 +606,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) ); } } } @@ -436,7 +630,7 @@ static void Cmd_Alias_f (void) { 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; } @@ -478,19 +672,64 @@ static void Cmd_Alias_f (void) // 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)); 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->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); + } +} + /* ============================================================================= @@ -507,6 +746,7 @@ typedef struct cmd_function_s xcommand_t consolefunction; xcommand_t clientfunction; qboolean csqcfunc; + qboolean initstate; // indicates this command existed at init } cmd_function_t; static int cmd_argc; @@ -518,19 +758,53 @@ 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) +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(!strcmp(varname, "#")) + { + return va("%d", Cmd_Argc()); + } + 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 && ISWHITESPACE(*p);p++) + ; + + return p; + } + } + } else { argno = strtol(varname, &endptr, 10); @@ -550,13 +824,72 @@ static const char *Cmd_GetDirectCvarValue(const char *varname, cmdalias_t *alias return NULL; } +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) + goto fail; + *out++ = '\\'; --outlen; + *out++ = '"'; --outlen; + } + else if(*in == '\\' && quote_backslash) + { + if(outlen <= 2) + goto fail; + *out++ = '\\'; --outlen; + *out++ = '\\'; --outlen; + } + else if(*in == '$' && quote_dollar) + { + if(outlen <= 2) + goto fail; + *out++ = '$'; --outlen; + *out++ = '$'; --outlen; + } + else + { + if(outlen <= 1) + 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]; - char *p; const char *varstr; char *varfunc; +static char asis[] = "asis"; // just to suppress const char warnings if(varlen >= MAX_INPUTLINE) varlen = MAX_INPUTLINE - 1; @@ -578,14 +911,17 @@ static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t * varstr = NULL; - // Exception: $* doesn't use the quoted form by default - if(!strcmp(varname, "*")) - varfunc = "asis"; - if(varname[0] == '$') - varstr = Cmd_GetDirectCvarValue(Cmd_GetDirectCvarValue(varname + 1, alias), alias); + varstr = Cmd_GetDirectCvarValue(Cmd_GetDirectCvarValue(varname + 1, alias, NULL), alias, NULL); else - varstr = Cmd_GetDirectCvarValue(varname, alias); + { + 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) { @@ -599,34 +935,8 @@ static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t * 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 \" - p = varval; - while(*varstr) - { - if(*varstr == '"') - { - if(p - varval >= (ssize_t)(sizeof(varval) - 2)) - break; - *p++ = '\\'; - *p++ = '"'; - } - else if(*varstr == '\\') - { - if(p - varval >= (ssize_t)(sizeof(varval) - 2)) - break; - *p++ = '\\'; - *p++ = '\\'; - } - else - { - if(p - varval >= (ssize_t)(sizeof(varval) - 1)) - break; - *p++ = *varstr; - } - ++varstr; - } - *p++ = 0; - //Con_Printf("quoted form: %s\n", varval); + // we just need to replace " by \", and of course, double backslashes + Cmd_QuoteString(varval, sizeof(varval), varstr, "\"\\", false); return varval; } else if(!strcmp(varfunc, "asis")) @@ -642,7 +952,7 @@ static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t * /* 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; @@ -681,7 +991,8 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma // 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 + // 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 @@ -727,7 +1038,7 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma eat = varlen + 1; } } else { - varlen = strspn(in, "*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"); + varlen = strspn(in, "#*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-"); val = Cmd_GetCvarValue(in, varlen, alias); eat = varlen; } @@ -748,9 +1059,9 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma --eat; } } - } else { - outtext[outlen++] = *in++; } + else + outtext[outlen++] = *in++; } outtext[outlen] = 0; } @@ -764,25 +1075,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 ]; - char *q; - const char *p; + 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. - for(p = buffer, q = buffer2; *p; ) - { - if(*p == '$') - *q++ = '$'; - *q++ = *p++; - } - *q++ = 0; - + Cmd_QuoteString(buffer2, sizeof(buffer2), buffer, "$", false); Cbuf_InsertText( buffer2 ); } @@ -799,12 +1101,14 @@ static void Cmd_List_f (void) { 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 { @@ -812,21 +1116,78 @@ static void Cmd_List_f (void) 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; + int count; + qboolean ispattern; + + if (Cmd_Argc() > 1) + partial = Cmd_Args(); + else + { + Con_Printf("usage: apropos \n"); + return; + } + + ispattern = partial && (strchr(partial, '*') || strchr(partial, '?')); + if(!ispattern) + partial = va("*%s*", partial); + + 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) + { + // 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, "\n", false)) // when \n is as separator wildcards don't match it + continue; + 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_Init @@ -849,22 +1210,31 @@ 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"); 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)"); @@ -931,7 +1301,7 @@ static void Cmd_TokenizeString (const char *text) 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: @@ -1138,7 +1508,7 @@ void Cmd_CompleteCommandPrint (const char *partial) // 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); } /* @@ -1176,7 +1546,7 @@ void Cmd_CompleteAliasPrint (const char *partial) // 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); } @@ -1257,11 +1627,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); @@ -1296,8 +1668,8 @@ 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; case src_client: if (cmd->clientfunction) { @@ -1310,11 +1682,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; } @@ -1329,6 +1703,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)); @@ -1517,3 +1897,61 @@ int Cmd_CheckParm (const char *parm) 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(); +}