X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cmd.c;h=f8baf9125d79974cb0062e00094f9a36ef889151;hp=a911fb346fd6de24a57f7af1912593cffa637ce3;hb=4dd30523a9fba5bb7bcc6f490250e49647d480a9;hpb=06acd3f5d014dcb2d5d984d2ebe916eb5e3aa78b diff --git a/cmd.c b/cmd.c index a911fb34..f8baf912 100644 --- a/cmd.c +++ b/cmd.c @@ -21,15 +21,6 @@ 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; @@ -62,6 +53,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 +233,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 @@ -144,29 +280,58 @@ void Cbuf_Execute (void) char *text; char line[MAX_INPUTLINE]; char preprocessed[MAX_INPUTLINE]; - int quotes; + char *firstchar; + 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 ( !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 @@ -178,12 +343,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 +395,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 +404,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 +425,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); } @@ -266,6 +454,7 @@ Cmd_Exec_f static void Cmd_Exec_f (void) { char *f; + const char *filename; if (Cmd_Argc () != 2) { @@ -273,18 +462,22 @@ 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; + + 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) @@ -386,7 +579,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) ); } } } @@ -410,7 +603,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; } @@ -461,10 +654,53 @@ static void Cmd_Alias_f (void) 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); + } +} + /* ============================================================================= @@ -478,7 +714,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; @@ -491,15 +728,200 @@ 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(!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); + 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) + if(!varfunc) + 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 -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; + 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 ) { @@ -509,76 +931,100 @@ 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 $ - // $ 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" + // + // 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" // - // 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 - // $ is replaced with an argument to this alias (or copied as-is if no such parameter exists), can be multiple digits + // because at definition time, $$ will get replaced to a single $. + if( *in == '$' ) { - outtext[outlen++] = *in++; - } else if( *in == '*' && alias ) { - const char *linein = Cmd_Args(); - - // include all parameters - if (linein) { - while( *linein && outlen < maxoutlen ) { - outtext[outlen++] = *linein++; - } + val = "$"; + eat = 1; + } else if(*in == '{') { + varlen = strcspn(in + 1, "}"); + if(in[varlen + 1] == '}') + { + val = Cmd_GetCvarValue(in + 1, varlen, alias); + eat = varlen + 2; } - - in++; - } else if( '0' <= *in && *in <= '9' && alias ) { - char *nexttoken; - int argnum; - - argnum = strtol( in, &nexttoken, 10 ); - - if( 0 <= argnum && argnum < Cmd_Argc() ) { - const char *param = Cmd_Argv( argnum ); - while( *param && outlen < maxoutlen ) { - outtext[outlen++] = *param++; - } - in = nexttoken; - } else if( argnum >= Cmd_Argc() ) { - Con_Printf( "Warning: Not enough parameters passed to alias '%s', at least %i expected:\n %s\n", alias->name, argnum, alias->value ); - outtext[outlen++] = '$'; + else + { + // ran out of data? + val = NULL; + eat = varlen + 1; } } else { - cvar_t *cvar; - const char *tempin = in; - - COM_ParseTokenConsole( &tempin ); - // don't expand rcon_password or similar cvars (CVAR_PRIVATE flag) - if ((cvar = Cvar_FindVar(&com_token[0])) && !(cvar->flags & CVAR_PRIVATE)) { - const char *cvarcontent = cvar->string; - while( *cvarcontent && outlen < maxoutlen ) { - outtext[outlen++] = *cvarcontent++; - } - in = tempin; - } else { - if( alias ) { - Con_Printf( "Warning: could not find cvar %s when expanding alias %s\n %s\n", com_token, alias->name, alias->value ); - } else { - Con_Printf( "Warning: could not find cvar %s\n", com_token ); - } - outtext[outlen++] = '$'; - } + varlen = strspn(in, "#*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-"); + val = Cmd_GetCvarValue(in, varlen, alias); + eat = varlen; } - } else { - if( *in == '"' ) { - inquote ^= 1; + 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; + } } - outtext[outlen++] = *in++; } + else + outtext[outlen++] = *in++; } outtext[outlen] = 0; } @@ -592,11 +1038,17 @@ 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 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) - 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 ); } /* @@ -612,12 +1064,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 { @@ -625,21 +1079,84 @@ 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; + size_t len; + int count; + qboolean ispattern; + + if (Cmd_Argc() > 1) + { + partial = Cmd_Args(); + len = strlen(partial); + } + else + { + Con_Printf("usage: apropos \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 @@ -662,22 +1179,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)"); @@ -744,7 +1270,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: @@ -766,7 +1292,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) @@ -791,7 +1317,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; @@ -808,7 +1334,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; @@ -823,9 +1349,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; @@ -840,6 +1367,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 @@ -945,7 +1477,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); } /* @@ -983,7 +1515,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); } @@ -1064,11 +1596,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); @@ -1084,18 +1618,48 @@ 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)); + found = true; + goto command_found; + case src_client: + if (cmd->clientfunction) + { + cmd->clientfunction (); + cmd_tokenizebufferpos = oldpos; + return; + } + break; + } + 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; + } // check alias for (a=cmd_alias ; a ; a=a->next) @@ -1108,6 +1672,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)); @@ -1125,6 +1695,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); @@ -1141,7 +1712,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); } /*