X-Git-Url: http://git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cmd.c;h=a12fae8ea0c4fa52839d66a46267e73b927936bf;hp=fecc7bd939c87dd3a9a857ca0e20c3503a182ecb;hb=97820be04836873cca98fddf52c1901e430d9bee;hpb=9d3d8793d40ef7323a09a6858ecc73b5be11b64a diff --git a/cmd.c b/cmd.c index fecc7bd9..a12fae8e 100644 --- a/cmd.c +++ b/cmd.c @@ -22,10 +22,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "quakedef.h" #include "thread.h" -cmd_state_t cmd_client; -cmd_state_t cmd_clientfromserver; -cmd_state_t cmd_server; -cmd_state_t cmd_serverfromclient; +cmd_state_t *cmd_local; +cmd_state_t *cmd_serverfromclient; cmd_userdefined_t cmd_userdefined_all; cmd_userdefined_t cmd_userdefined_null; @@ -35,28 +33,23 @@ typedef struct cmd_iter_s { } cmd_iter_t; -static cmd_iter_t cmd_iter_all[] = { - {&cmd_client}, - {&cmd_clientfromserver}, - {&cmd_server}, - {&cmd_serverfromclient}, - {NULL}, -}; +static cmd_iter_t *cmd_iter_all; +mempool_t *cbuf_mempool; // we only run the +whatever commandline arguments once -qboolean host_stuffcmdsrun = false; +qbool host_stuffcmdsrun = false; //============================================================================= -void Cbuf_Lock(cmd_state_t *cmd) +void Cbuf_Lock(cmd_buf_t *cbuf) { - Thread_AtomicLock(&cmd->text_lock); + Thread_LockMutex(cbuf->lock); } -void Cbuf_Unlock(cmd_state_t *cmd) +void Cbuf_Unlock(cmd_buf_t *cbuf) { - Thread_AtomicUnlock(&cmd->text_lock); + Thread_UnlockMutex(cbuf->lock); } @@ -71,7 +64,7 @@ bind g "impulse 5 ; +attack ; wait ; -attack ; impulse 2" */ static void Cmd_Wait_f (cmd_state_t *cmd) { - cmd->wait = true; + cmd->cbuf->wait = true; } /* @@ -81,50 +74,47 @@ Cmd_Defer_f Cause a command to be executed after a delay. ============ */ +static cmd_input_t *Cbuf_LinkGet(cmd_buf_t *cbuf, cmd_input_t *existing); static void Cmd_Defer_f (cmd_state_t *cmd) { + cmd_input_t *current; + cmd_buf_t *cbuf = cmd->cbuf; + if(Cmd_Argc(cmd) == 1) { - cmddeferred_t *next = cmd->deferred_list; - if(!next) + if(List_Is_Empty(&cbuf->deferred)) Con_Printf("No commands are pending.\n"); - while(next) + else { - Con_Printf("-> In %9.2f: %s\n", next->delay, next->value); - next = next->next; + List_For_Each_Entry(current, &cbuf->deferred, cmd_input_t, list) + Con_Printf("-> In %9.2f: %s\n", current->delay, current->text); } - } else if(Cmd_Argc(cmd) == 2 && !strcasecmp("clear", Cmd_Argv(cmd, 1))) + } + else if(Cmd_Argc(cmd) == 2 && !strcasecmp("clear", Cmd_Argv(cmd, 1))) + { + while(!List_Is_Empty(&cbuf->deferred)) + List_Move_Tail(cbuf->deferred.next, &cbuf->free); + } + else if(Cmd_Argc(cmd) == 3) { - while(cmd->deferred_list) + const char *text = Cmd_Argv(cmd, 2); + current = Cbuf_LinkGet(cbuf, NULL); + current->length = strlen(text); + current->source = cmd; + current->delay = atof(Cmd_Argv(cmd, 1)); + + if(current->size < current->length) { - cmddeferred_t *defcmd = cmd->deferred_list; - cmd->deferred_list = defcmd->next; - Mem_Free(defcmd->value); - Mem_Free(defcmd); + current->text = (char *)Mem_Realloc(cbuf_mempool, current->text, current->length + 1); + current->size = current->length; } - } else if(Cmd_Argc(cmd) == 3) - { - const char *value = Cmd_Argv(cmd, 2); - cmddeferred_t *defcmd = (cmddeferred_t*)Mem_Alloc(tempmempool, sizeof(*defcmd)); - size_t len = strlen(value); - defcmd->delay = atof(Cmd_Argv(cmd, 1)); - defcmd->value = (char*)Mem_Alloc(tempmempool, len+1); - memcpy(defcmd->value, value, len+1); - defcmd->next = NULL; + strlcpy(current->text, text, current->length + 1); - 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 { + List_Move_Tail(¤t->list, &cbuf->deferred); + } + else + { Con_Printf("usage: defer \n" " defer clear\n"); return; @@ -182,6 +172,181 @@ static void Cmd_Centerprint_f (cmd_state_t *cmd) ============================================================================= */ +static cmd_input_t *Cbuf_LinkGet(cmd_buf_t *cbuf, cmd_input_t *existing) +{ + cmd_input_t *ret = NULL; + if(existing && existing->pending) + ret = existing; + else if(!List_Is_Empty(&cbuf->free)) + { + ret = List_Entry(cbuf->free.next, cmd_input_t, list); + ret->length = 0; + ret->pending = false; + } + return ret; +} + +static cmd_input_t *Cmd_AllocInputNode(void) +{ + cmd_input_t *node = (cmd_input_t *)Mem_Alloc(cbuf_mempool, sizeof(cmd_input_t)); + node->list.prev = node->list.next = &node->list; + node->size = node->length = node->pending = 0; + return node; +} + + +// Cloudwalk FIXME: The entire design of this thing is overly complicated. +// We could very much safely have one input node per line whether or not +// the command was terminated. We don't need to split up input nodes per command +// executed. +static size_t Cmd_ParseInput (cmd_input_t **output, char **input) +{ + size_t pos, cmdsize = 0, start = 0; + qbool command = false, lookahead = false; + qbool quotes = false, comment = false; + qbool escaped = false; + + /* + * The Quake command-line is super basic. It can be entered in the console + * or in config files. A semicolon is used to terminate a command and chain + * them together. Otherwise, a newline delineates command input. + * + * In most engines, the Quake command-line is a simple linear text buffer that + * is parsed when it executes. In Darkplaces, we use a linked list of command + * input and parse the input on the spot. + * + * This was done because Darkplaces allows multiple command interpreters on the + * same thread. Previously, each interpreter maintained its own buffer and this + * caused problems related to execution order, and maintaining a single simple + * buffer for all interpreters makes it non-trivial to keep track of which + * command should execute on which interpreter. + */ + + // Run until command and lookahead are both true, or until we run out of input. + for (pos = 0; (*input)[pos]; pos++) + { + // Look for newlines and semicolons. Ignore semicolons in quotes. + switch((*input)[pos]) + { + case '\r': + case '\n': + command = false; + comment = false; + break; + default: + if(!comment) // Not a newline so far. Still not a valid command yet. + { + if(!quotes && (*input)[pos] == ';') // Ignore semicolons in quotes. + command = false; + else if (ISCOMMENT((*input), pos)) // Comments + { + comment = true; + command = false; + } + else + { + command = true; + if(!lookahead) + { + if(!cmdsize) + start = pos; + cmdsize++; + } + + switch((*input)[pos]) + { + case '"': + if (!escaped) + quotes = !quotes; + else + escaped = false; + break; + case '\\': + if (!escaped && quotes) + escaped = true; + else if (escaped) + escaped = false; + break; + } + } + } + } + if(cmdsize && !command) + lookahead = true; + + if(command && lookahead) + break; + } + + if(cmdsize) + { + size_t offset = 0; + + if(!*output) + *output = Cmd_AllocInputNode(); + + // Append, since this input line hasn't closed yet. + if((*output)->pending) + offset = (*output)->length; + + (*output)->length += cmdsize; + + if((*output)->size < (*output)->length) + { + (*output)->text = (char *)Mem_Realloc(cbuf_mempool, (*output)->text, (*output)->length + 1); + (*output)->size = (*output)->length; + } + + strlcpy(&(*output)->text[offset], &(*input)[start], cmdsize + 1); + + /* + * If we were still looking ahead by the time we broke from the loop, the command input + * hasn't terminated yet and we're still expecting more, so keep this node open for appending later. + */ + (*output)->pending = !lookahead; + } + + // Set input to its new position. Can be NULL. + *input = &(*input)[pos]; + + return cmdsize; +} + +// Cloudwalk: Not happy with this, but it works. +static void Cbuf_LinkCreate(cmd_state_t *cmd, llist_t *head, cmd_input_t *existing, const char *text) +{ + char *in = (char *)&text[0]; + cmd_buf_t *cbuf = cmd->cbuf; + size_t totalsize = 0, newsize = 0; + cmd_input_t *current = NULL; + + // Slide the pointer down until we reach the end + while(*in) + { + // Check if the current node is still accepting input (input line hasn't terminated) + current = Cbuf_LinkGet(cbuf, existing); + newsize = Cmd_ParseInput(¤t, &in); + + // Valid command + if(newsize) + { + // current will match existing if the input line hasn't terminated yet + if(current != existing) + { + current->source = cmd; + List_Move_Tail(¤t->list, head); + } + + totalsize += newsize; + } + else if (current == existing && !totalsize) + current->pending = false; + current = NULL; + } + + cbuf->size += totalsize; +} + /* ============ Cbuf_AddText @@ -191,43 +356,50 @@ Adds command text at the end of the buffer */ void Cbuf_AddText (cmd_state_t *cmd, const char *text) { - int l; + size_t l = strlen(text); + cmd_buf_t *cbuf = cmd->cbuf; + llist_t llist = {&llist, &llist}; - l = (int)strlen(text); + Cbuf_Lock(cbuf); - Cbuf_Lock(cmd); - if (cmd->text.maxsize - cmd->text.cursize <= l) + if (cbuf->maxsize - cbuf->size <= l) Con_Print("Cbuf_AddText: overflow\n"); else - SZ_Write(&cmd->text, (const unsigned char *)text, l); - Cbuf_Unlock(cmd); + { + Cbuf_LinkCreate(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.prev, cmd_input_t, list)), text); + if(!List_Is_Empty(&llist)) + List_Splice_Tail(&llist, &cbuf->start); + } + Cbuf_Unlock(cbuf); } - /* ============ Cbuf_InsertText Adds command text immediately after the current command -Adds a \n to the text FIXME: actually change the command buffer to do less copying ============ */ void Cbuf_InsertText (cmd_state_t *cmd, const char *text) { + cmd_buf_t *cbuf = cmd->cbuf; + llist_t llist = {&llist, &llist}; size_t l = strlen(text); - Cbuf_Lock(cmd); + + Cbuf_Lock(cbuf); + // we need to memmove the existing text and stuff this in before it... - if (cmd->text.cursize + l >= (size_t)cmd->text.maxsize) + if (cbuf->size + l >= cbuf->maxsize) Con_Print("Cbuf_InsertText: overflow\n"); else { - // we don't have a SZ_Prepend, so... - memmove(cmd->text.data + l, cmd->text.data, cmd->text.cursize); - cmd->text.cursize += (int)l; - memcpy(cmd->text.data, text, l); + Cbuf_LinkCreate(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.next, cmd_input_t, list)), text); + if(!List_Is_Empty(&llist)) + List_Splice(&llist, &cbuf->start); } - Cbuf_Unlock(cmd); + + Cbuf_Unlock(cbuf); } /* @@ -235,39 +407,28 @@ void Cbuf_InsertText (cmd_state_t *cmd, const char *text) Cbuf_Execute_Deferred --blub ============ */ -static void Cbuf_Execute_Deferred (cmd_state_t *cmd) +static void Cbuf_Execute_Deferred (cmd_buf_t *cbuf) { - cmddeferred_t *defcmd, *prev; + cmd_input_t *current; double eat; - if (realtime - cmd->deferred_oldrealtime < 0 || realtime - cmd->deferred_oldrealtime > 1800) cmd->deferred_oldrealtime = realtime; - eat = realtime - cmd->deferred_oldrealtime; + + if (host.realtime - cbuf->deferred_oldtime < 0 || host.realtime - cbuf->deferred_oldtime > 1800) + cbuf->deferred_oldtime = host.realtime; + eat = host.realtime - cbuf->deferred_oldtime; if (eat < (1.0 / 120.0)) return; - cmd->deferred_oldrealtime = realtime; - prev = NULL; - defcmd = cmd->deferred_list; - while(defcmd) + cbuf->deferred_oldtime = host.realtime; + + List_For_Each_Entry(current, &cbuf->deferred, cmd_input_t, list) { - defcmd->delay -= eat; - if(defcmd->delay <= 0) + current->delay -= eat; + if(current->delay <= 0) { - Cbuf_AddText(cmd, defcmd->value); - Cbuf_AddText(cmd, ";\n"); - Mem_Free(defcmd->value); - - if(prev) { - prev->next = defcmd->next; - Mem_Free(defcmd); - defcmd = prev->next; - } else { - cmd->deferred_list = defcmd->next; - Mem_Free(defcmd); - defcmd = cmd->deferred_list; - } - continue; + cbuf->size += current->length; + List_Move(¤t->list, &cbuf->start); + // We must return and come back next frame or the engine will freeze. Fragile... like glass :3 + return; } - prev = defcmd; - defcmd = defcmd->next; } } @@ -276,117 +437,98 @@ static void Cbuf_Execute_Deferred (cmd_state_t *cmd) Cbuf_Execute ============ */ -static qboolean Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias ); -void Cbuf_Execute (cmd_state_t *cmd) +static qbool Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmd_alias_t *alias ); +void Cbuf_Execute (cmd_buf_t *cbuf) { - int i; - char *text; - char line[MAX_INPUTLINE]; + cmd_input_t *current; char preprocessed[MAX_INPUTLINE]; char *firstchar; - qboolean quotes; - char *comment; // LadyHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes - cmd->tokenizebufferpos = 0; + cbuf->tokenizebufferpos = 0; - while (cmd->text.cursize) + while (!List_Is_Empty(&cbuf->start)) { -// find a \n or ; line break - text = (char *)cmd->text.data; - - quotes = false; - comment = NULL; - for (i=0 ; i < cmd->text.cursize ; i++) - { - 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; - } - - // better than CRASHING on overlong input lines that may SOMEHOW enter the buffer - if(i >= MAX_INPUTLINE) - { - Con_Warnf("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 -// beginning of the text buffer - - if (i == cmd->text.cursize) - cmd->text.cursize = 0; - else - { - i++; - cmd->text.cursize -= i; - memmove (cmd->text.data, text+i, cmd->text.cursize); - } - -// execute the command line - firstchar = line; + /* + * Delete the text from the command buffer and move remaining + * commands down. This is necessary because commands (exec, alias) + * can insert data at the beginning of the text buffer + */ + current = List_Entry(cbuf->start.next, cmd_input_t, list); + + // Recycle memory so using WASD doesn't cause a malloc and free + List_Move_Tail(¤t->list, &cbuf->free); + + /* + * Assume we're rolling with the current command-line and + * always set this false because alias expansion or cbuf insertion + * without a newline may set this true, and cause weirdness. + */ + current->pending = false; + + cbuf->size -= current->length; + + firstchar = current->text; while(*firstchar && ISWHITESPACE(*firstchar)) ++firstchar; - if( - (strncmp(firstchar, "alias", 5) || !ISWHITESPACE(firstchar[5])) - && - (strncmp(firstchar, "bind", 4) || !ISWHITESPACE(firstchar[4])) - && - (strncmp(firstchar, "in_bind", 7) || !ISWHITESPACE(firstchar[7])) - ) + if((strncmp(firstchar, "alias", 5) || !ISWHITESPACE(firstchar[5])) && + (strncmp(firstchar, "bind", 4) || !ISWHITESPACE(firstchar[4])) && + (strncmp(firstchar, "in_bind", 7) || !ISWHITESPACE(firstchar[7]))) { - if(Cmd_PreprocessString( cmd, line, preprocessed, sizeof(preprocessed), NULL )) - Cmd_ExecuteString (cmd, preprocessed, src_command, false); + if(Cmd_PreprocessString(current->source, current->text, preprocessed, sizeof(preprocessed), NULL )) + Cmd_ExecuteString(current->source, preprocessed, src_local, false); } else { - Cmd_ExecuteString (cmd, line, src_command, false); + Cmd_ExecuteString (current->source, current->text, src_local, false); } - if (cmd->wait) - { // skip out while text still remains in buffer, leaving it - // for next frame - cmd->wait = false; + current = NULL; + + if (cbuf->wait) + { + /* + * Skip out while text still remains in + * buffer, leaving it for next frame + */ + cbuf->wait = false; break; } } } -void Cbuf_Frame(cmd_state_t *cmd) +/* +=================== +Cbuf_Frame_Input + +Add them exactly as if they had been typed at the console +=================== +*/ +static void Cbuf_Frame_Input(void) { - Cbuf_Execute_Deferred(cmd); - if (cmd->text.cursize) + char *line; + + while ((line = Sys_ConsoleInput())) + Cbuf_AddText(cmd_local, line); +} + +void Cbuf_Frame(cmd_buf_t *cbuf) +{ + // check for commands typed to the host + Cbuf_Frame_Input(); + +// R_TimeReport("preconsole"); + + // execute commands queued with the defer command + Cbuf_Execute_Deferred(cbuf); + if (cbuf->size) { SV_LockThreadMutex(); - Cbuf_Execute(cmd); + Cbuf_Execute(cbuf); SV_UnlockThreadMutex(); } + +// R_TimeReport("console"); } /* @@ -397,8 +539,6 @@ void Cbuf_Frame(cmd_state_t *cmd) ============================================================================== */ -extern qboolean host_init; - /* =============== Cmd_StuffCmds_f @@ -415,10 +555,6 @@ static void Cmd_StuffCmds_f (cmd_state_t *cmd) // this is for all commandline options combined (and is bounds checked) char build[MAX_INPUTLINE]; - // come back later so we don't crash - if(host_init) - return; - if (Cmd_Argc (cmd) != 1) { Con_Print("stuffcmds : execute command line parameters\n"); @@ -432,28 +568,28 @@ static void Cmd_StuffCmds_f (cmd_state_t *cmd) host_stuffcmdsrun = true; build[0] = 0; l = 0; - for (i = 0;i < com_argc;i++) + for (i = 0;i < sys.argc;i++) { - 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) + if (sys.argv[i] && sys.argv[i][0] == '+' && (sys.argv[i][1] < '0' || sys.argv[i][1] > '9') && l + strlen(sys.argv[i]) - 1 <= sizeof(build) - 1) { j = 1; - while (com_argv[i][j]) - build[l++] = com_argv[i][j++]; + while (sys.argv[i][j]) + build[l++] = sys.argv[i][j++]; i++; - for (;i < com_argc;i++) + for (;i < sys.argc;i++) { - if (!com_argv[i]) + if (!sys.argv[i]) continue; - if ((com_argv[i][0] == '+' || com_argv[i][0] == '-') && (com_argv[i][1] < '0' || com_argv[i][1] > '9')) + if ((sys.argv[i][0] == '+' || sys.argv[i][0] == '-') && (sys.argv[i][1] < '0' || sys.argv[i][1] > '9')) break; - if (l + strlen(com_argv[i]) + 4 > sizeof(build) - 1) + if (l + strlen(sys.argv[i]) + 4 > sizeof(build) - 1) break; build[l++] = ' '; - if (strchr(com_argv[i], ' ')) + if (strchr(sys.argv[i], ' ')) build[l++] = '\"'; - for (j = 0;com_argv[i][j];j++) - build[l++] = com_argv[i][j]; - if (strchr(com_argv[i], ' ')) + for (j = 0;sys.argv[i][j];j++) + build[l++] = sys.argv[i][j]; + if (strchr(sys.argv[i], ' ')) build[l++] = '\"'; } build[l++] = '\n'; @@ -470,14 +606,14 @@ static void Cmd_Exec(cmd_state_t *cmd, const char *filename) { char *f; size_t filenameLen = strlen(filename); - qboolean isdefaultcfg = + qbool isdefaultcfg = !strcmp(filename, "default.cfg") || (filenameLen >= 12 && !strcmp(filename + filenameLen - 12, "/default.cfg")); if (!strcmp(filename, "config.cfg")) { filename = CONFIGFILENAME; - if (COM_CheckParm("-noconfig")) + if (Sys_CheckParm("-noconfig")) return; // don't execute config.cfg } @@ -495,9 +631,6 @@ static void Cmd_Exec(cmd_state_t *cmd, const char *filename) if (isdefaultcfg) Cbuf_InsertText(cmd, "\ncvar_lockdefaults\n"); - // insert newline after the text to make sure the last line is terminated (some text editors omit the trailing newline) - // (note: insertion order here is backwards from execution order, so this adds it after the text, by calling it before...) - Cbuf_InsertText (cmd, "\n"); Cbuf_InsertText (cmd, f); Mem_Free(f); @@ -661,6 +794,7 @@ static void Cmd_Exec(cmd_state_t *cmd, const char *filename) "sv_gameplayfix_q2airaccelerate 1\n" "sv_gameplayfix_stepmultipletimes 1\n" "csqc_polygons_defaultmaterial_nocullface 1\n" +"con_chatsound_team_mask 13\n" ); break; case GAME_XONOTIC: @@ -668,6 +802,8 @@ static void Cmd_Exec(cmd_state_t *cmd, const char *filename) // compatibility for versions prior to 2020-05-25, this can be overridden in newer versions to get the default behavior and be consistent with FTEQW engine Cbuf_InsertText(cmd, "\n" "csqc_polygons_defaultmaterial_nocullface 1\n" +"con_chatsound_team_mask 13\n" +"sv_gameplayfix_customstats 1\n" ); break; // Steel Storm: Burning Retribution csqc misinterprets CSQC_InputEvent if type is a value other than 0 or 1 @@ -738,7 +874,7 @@ static void Cmd_Exec_f (cmd_state_t *cmd) return; } - s = FS_Search(Cmd_Argv(cmd, 1), true, true); + s = FS_Search(Cmd_Argv(cmd, 1), true, true, NULL); if(!s || !s->numfilenames) { Con_Printf("couldn't exec %s\n",Cmd_Argv(cmd, 1)); @@ -788,7 +924,7 @@ static void Cmd_Toggle_f(cmd_state_t *cmd) else { // Correct Arguments Specified // Acquire Potential CVar - cvar_t* cvCVar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 1), cmd->cvars_flagsmask, false); + cvar_t* cvCVar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 1), cmd->cvars_flagsmask); if(cvCVar != NULL) { // Valid CVar @@ -857,7 +993,7 @@ Creates a new command that executes a command string (possibly ; seperated) */ static void Cmd_Alias_f (cmd_state_t *cmd) { - cmdalias_t *a; + cmd_alias_t *a; char line[MAX_INPUTLINE]; int i, c; const char *s; @@ -890,9 +1026,9 @@ static void Cmd_Alias_f (cmd_state_t *cmd) if (!a) { - cmdalias_t *prev, *current; + cmd_alias_t *prev, *current; - a = (cmdalias_t *)Z_Malloc (sizeof(cmdalias_t)); + a = (cmd_alias_t *)Z_Malloc (sizeof(cmd_alias_t)); strlcpy (a->name, s, sizeof (a->name)); // insert it at the right alphanumeric position for( prev = NULL, current = cmd->userdefined->alias ; current && strcmp( current->name, a->name ) < 0 ; prev = current, current = current->next ) @@ -933,7 +1069,7 @@ Remove existing aliases. */ static void Cmd_UnAlias_f (cmd_state_t *cmd) { - cmdalias_t *a, *p; + cmd_alias_t *a, *p; int i; const char *s; @@ -975,7 +1111,7 @@ static void Cmd_UnAlias_f (cmd_state_t *cmd) ============================================================================= */ -static const char *Cmd_GetDirectCvarValue(cmd_state_t *cmd, const char *varname, cmdalias_t *alias, qboolean *is_multiple) +static const char *Cmd_GetDirectCvarValue(cmd_state_t *cmd, const char *varname, cmd_alias_t *alias, qbool *is_multiple) { cvar_t *cvar; long argno; @@ -1036,17 +1172,17 @@ static const char *Cmd_GetDirectCvarValue(cmd_state_t *cmd, const char *varname, } } - if((cvar = Cvar_FindVar(cmd->cvars, varname, cmd->cvars_flagsmask, false)) && !(cvar->flags & CVAR_PRIVATE)) + if((cvar = Cvar_FindVar(cmd->cvars, varname, cmd->cvars_flagsmask)) && !(cvar->flags & CF_PRIVATE)) return cvar->string; return NULL; } -qboolean Cmd_QuoteString(char *out, size_t outlen, const char *in, const char *quoteset, qboolean putquotes) +qbool Cmd_QuoteString(char *out, size_t outlen, const char *in, const char *quoteset, qbool putquotes) { - qboolean quote_quot = !!strchr(quoteset, '"'); - qboolean quote_backslash = !!strchr(quoteset, '\\'); - qboolean quote_dollar = !!strchr(quoteset, '$'); + qbool quote_quot = !!strchr(quoteset, '"'); + qbool quote_backslash = !!strchr(quoteset, '\\'); + qbool quote_dollar = !!strchr(quoteset, '$'); if(putquotes) { @@ -1101,14 +1237,14 @@ fail: return false; } -static const char *Cmd_GetCvarValue(cmd_state_t *cmd, const char *var, size_t varlen, cmdalias_t *alias) +static const char *Cmd_GetCvarValue(cmd_state_t *cmd, const char *var, size_t varlen, cmd_alias_t *alias) { 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; + qbool required = false; + qbool optional = false; static char asis[] = "asis"; // just to suppress const char warnings if(varlen >= MAX_INPUTLINE) @@ -1127,9 +1263,9 @@ static const char *Cmd_GetCvarValue(cmd_state_t *cmd, const char *var, size_t va { // empty cvar name? if(alias) - Con_Warnf("Warning: Could not expand $ in alias %s\n", alias->name); + Con_Printf(CON_WARN "Warning: Could not expand $ in alias %s\n", alias->name); else - Con_Warnf("Warning: Could not expand $\n"); + Con_Printf(CON_WARN "Warning: Could not expand $\n"); return "$"; } @@ -1162,7 +1298,7 @@ static const char *Cmd_GetCvarValue(cmd_state_t *cmd, const char *var, size_t va varstr = Cmd_GetDirectCvarValue(cmd, Cmd_GetDirectCvarValue(cmd, varname + 1, alias, NULL), alias, NULL); else { - qboolean is_multiple = false; + qbool is_multiple = false; // Exception: $* and $n- don't use the quoted form by default varstr = Cmd_GetDirectCvarValue(cmd, varname, alias, &is_multiple); if(is_multiple) @@ -1175,9 +1311,9 @@ static const char *Cmd_GetCvarValue(cmd_state_t *cmd, const char *var, size_t va if(required) { if(alias) - Con_Errorf("Error: Could not expand $%s in alias %s\n", varname, alias->name); + Con_Printf(CON_ERROR "Error: Could not expand $%s in alias %s\n", varname, alias->name); else - Con_Errorf("Error: Could not expand $%s\n", varname); + Con_Printf(CON_ERROR "Error: Could not expand $%s\n", varname); return NULL; } else if(optional) @@ -1187,9 +1323,9 @@ static const char *Cmd_GetCvarValue(cmd_state_t *cmd, const char *var, size_t va else { if(alias) - Con_Warnf("Warning: Could not expand $%s in alias %s\n", varname, alias->name); + Con_Printf(CON_WARN "Warning: Could not expand $%s in alias %s\n", varname, alias->name); else - Con_Warnf("Warning: Could not expand $%s\n", varname); + Con_Printf(CON_WARN "Warning: Could not expand $%s\n", varname); dpsnprintf(varval, sizeof(varval), "$%s", varname); return varval; } @@ -1217,7 +1353,7 @@ Cmd_PreprocessString Preprocesses strings and replaces $*, $param#, $cvar accordingly. Also strips comments. */ -static qboolean Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias ) { +static qbool Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmd_alias_t *alias ) { const char *in; size_t eat, varlen; unsigned outlen; @@ -1346,11 +1482,11 @@ Cmd_ExecuteAlias Called for aliases and fills in the alias into the cbuffer ============ */ -static void Cmd_ExecuteAlias (cmd_state_t *cmd, cmdalias_t *alias) +static void Cmd_ExecuteAlias (cmd_state_t *cmd, cmd_alias_t *alias) { static char buffer[ MAX_INPUTLINE ]; // cmd_mutex static char buffer2[ MAX_INPUTLINE ]; // cmd_mutex - qboolean ret = Cmd_PreprocessString( cmd, alias->value, buffer, sizeof(buffer) - 2, alias ); + qbool ret = Cmd_PreprocessString( cmd, alias->value, buffer, sizeof(buffer) - 2, alias ); if(!ret) return; // insert at start of command buffer, so that aliases execute in order @@ -1378,7 +1514,7 @@ static void Cmd_List_f (cmd_state_t *cmd) const char *partial; size_t len; int count; - qboolean ispattern; + qbool ispattern; if (Cmd_Argc(cmd) > 1) { @@ -1394,7 +1530,7 @@ static void Cmd_List_f (cmd_state_t *cmd) } count = 0; - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) { if (partial && (ispattern ? !matchpattern_with_separator(func->name, partial, false, "", false) : strncmp(partial, func->name, len))) continue; @@ -1424,17 +1560,17 @@ static void Cmd_Apropos_f(cmd_state_t *cmd) { cmd_function_t *func; cvar_t *cvar; - cmdalias_t *alias; + cmd_alias_t *alias; const char *partial; int count; - qboolean ispattern; + qbool ispattern; char vabuf[1024]; if (Cmd_Argc(cmd) > 1) partial = Cmd_Args(cmd); else { - Con_Printf("usage: apropos \n"); + Con_Printf("usage: %s \n",Cmd_Argv(cmd, 0)); return; } @@ -1445,16 +1581,24 @@ static void Cmd_Apropos_f(cmd_state_t *cmd) count = 0; for (cvar = cmd->cvars->vars; cvar; cvar = cvar->next) { - if (!matchpattern_with_separator(cvar->name, partial, true, "", false)) - continue; - if (!(cvar->flags & CVAR_ALIAS)) - if (!matchpattern_with_separator(cvar->description, partial, true, "", false)) - continue; - Con_Printf ("cvar "); - Cvar_PrintHelp(cvar, true); - count++; + if (matchpattern_with_separator(cvar->name, partial, true, "", false) || + matchpattern_with_separator(cvar->description, partial, true, "", false)) + { + Con_Printf ("cvar "); + Cvar_PrintHelp(cvar, cvar->name, true); + count++; + } + for (char **cvar_alias = cvar->aliases; cvar_alias && *cvar_alias; cvar_alias++) + { + if (matchpattern_with_separator(*cvar_alias, partial, true, "", false)) + { + Con_Printf ("cvar "); + Cvar_PrintHelp(cvar, *cvar_alias, true); + count++; + } + } } - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) { if (!matchpattern_with_separator(func->name, partial, true, "", false)) if (!matchpattern_with_separator(func->description, partial, true, "", false)) @@ -1482,6 +1626,23 @@ static void Cmd_Apropos_f(cmd_state_t *cmd) Con_Printf("%i result%s\n\n", count, (count > 1) ? "s" : ""); } +static cmd_state_t *Cmd_AddInterpreter(cmd_buf_t *cbuf, cvar_state_t *cvars, int cvars_flagsmask, int cmds_flagsmask, cmd_userdefined_t *userdefined) +{ + cmd_state_t *cmd = (cmd_state_t *)Mem_Alloc(tempmempool, sizeof(cmd_state_t)); + + cmd->mempool = Mem_AllocPool("commands", 0, NULL); + // space for commands and script files + cmd->cbuf = cbuf; + cmd->null_string = ""; + + cmd->cvars = cvars; + cmd->cvars_flagsmask = cvars_flagsmask; + cmd->cmd_flags = cmds_flagsmask; + cmd->userdefined = userdefined; + + return cmd; +} + /* ============ Cmd_Init @@ -1489,103 +1650,71 @@ Cmd_Init */ void Cmd_Init(void) { - cmd_iter_t *cmd_iter; - for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++) - { - cmd_state_t *cmd = cmd_iter->cmd; - cmd->mempool = Mem_AllocPool("commands", 0, NULL); - // space for commands and script files - cmd->text.data = cmd->text_buf; - cmd->text.maxsize = sizeof(cmd->text_buf); - cmd->text.cursize = 0; - cmd->null_string = ""; - } - // client console can see server cvars because the user may start a server - cmd_client.cvars = &cvars_all; - cmd_client.cvars_flagsmask = CVAR_CLIENT | CVAR_SERVER; - cmd_client.userdefined = &cmd_userdefined_all; - // stuffcmd from server has access to the reasonable client things, but it probably doesn't need to access the client's server-only cvars - cmd_clientfromserver.cvars = &cvars_all; - cmd_clientfromserver.cvars_flagsmask = CVAR_CLIENT; - cmd_clientfromserver.userdefined = &cmd_userdefined_all; - // dedicated server console can only see server cvars, there is no client - cmd_server.cvars = &cvars_all; - cmd_server.cvars_flagsmask = CVAR_SERVER; - cmd_server.userdefined = &cmd_userdefined_all; + cmd_buf_t *cbuf; + cbuf_mempool = Mem_AllocPool("Command buffer", 0, NULL); + cbuf = (cmd_buf_t *)Mem_Alloc(cbuf_mempool, sizeof(cmd_buf_t)); + cbuf->maxsize = 655360; + cbuf->lock = Thread_CreateMutex(); + cbuf->wait = false; + host.cbuf = cbuf; + + cbuf->start.prev = cbuf->start.next = &(cbuf->start); + cbuf->deferred.prev = cbuf->deferred.next = &(cbuf->deferred); + cbuf->free.prev = cbuf->free.next = &(cbuf->free); + + // FIXME: Get rid of cmd_iter_all eventually. This is just a hack to reduce the amount of work to make the interpreters dynamic. + cmd_iter_all = (cmd_iter_t *)Mem_Alloc(tempmempool, sizeof(cmd_iter_t) * 3); + + // local console + cmd_iter_all[0].cmd = cmd_local = Cmd_AddInterpreter(cbuf, &cvars_all, CF_CLIENT | CF_SERVER, CF_CLIENT | CF_CLIENT_FROM_SERVER | CF_SERVER_FROM_CLIENT, &cmd_userdefined_all); + cmd_local->Handle = Cmd_CL_Callback; + cmd_local->NotFound = NULL; + // server commands received from clients have no reason to access cvars, cvar expansion seems perilous. - cmd_serverfromclient.cvars = &cvars_null; - cmd_serverfromclient.cvars_flagsmask = 0; - cmd_serverfromclient.userdefined = &cmd_userdefined_null; -} + cmd_iter_all[1].cmd = cmd_serverfromclient = Cmd_AddInterpreter(cbuf, &cvars_null, 0, CF_SERVER_FROM_CLIENT | CF_USERINFO, &cmd_userdefined_null); + cmd_serverfromclient->Handle = Cmd_SV_Callback; + cmd_serverfromclient->NotFound = Cmd_SV_NotFound; -void Cmd_Init_Commands(qboolean dedicated_server) -{ + cmd_iter_all[2].cmd = NULL; // // register our commands // // client-only commands - Cmd_AddCommand(&cmd_client, "cmd", Cmd_ForwardToServer_f, "send a console commandline to the server (used by some mods)"); - Cmd_AddCommand(&cmd_clientfromserver, "cmd", Cmd_ForwardToServer_f, "send a console commandline to the server (used by some mods)"); - Cmd_AddCommand(&cmd_client, "wait", Cmd_Wait_f, "make script execution wait for next rendered frame"); - Cmd_AddCommand(&cmd_client, "cprint", Cmd_Centerprint_f, "print something at the screen center"); + Cmd_AddCommand(CF_SHARED, "wait", Cmd_Wait_f, "make script execution wait for next rendered frame"); + Cmd_AddCommand(CF_CLIENT, "cprint", Cmd_Centerprint_f, "print something at the screen center"); // maintenance commands used for upkeep of cvars and saved configs - Cmd_AddCommand(&cmd_client, "stuffcmds", Cmd_StuffCmds_f, "execute commandline parameters (must be present in quake.rc script)"); - Cmd_AddCommand(&cmd_client, "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(&cmd_client, "cvar_resettodefaults_all", Cvar_ResetToDefaults_All_f, "sets all cvars to their locked default values"); - Cmd_AddCommand(&cmd_client, "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(&cmd_client, "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(&cmd_server, "stuffcmds", Cmd_StuffCmds_f, "execute commandline parameters (must be present in quake.rc script)"); - Cmd_AddCommand(&cmd_server, "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(&cmd_server, "cvar_resettodefaults_all", Cvar_ResetToDefaults_All_f, "sets all cvars to their locked default values"); - Cmd_AddCommand(&cmd_server, "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(&cmd_server, "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(CF_SHARED, "stuffcmds", Cmd_StuffCmds_f, "execute commandline parameters (must be present in quake.rc script)"); + Cmd_AddCommand(CF_SHARED, "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(CF_SHARED, "cvar_resettodefaults_all", Cvar_ResetToDefaults_All_f, "sets all cvars to their locked default values"); + Cmd_AddCommand(CF_SHARED, "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(CF_SHARED, "cvar_resettodefaults_saveonly", Cvar_ResetToDefaults_SaveOnly_f, "sets all saved cvars to their locked default values (variables that will be saved to config.cfg)"); // general console commands used in multiple environments - Cmd_AddCommand(&cmd_client, "exec", Cmd_Exec_f, "execute a script file"); - Cmd_AddCommand(&cmd_client, "echo",Cmd_Echo_f, "print a message to the console (useful in scripts)"); - Cmd_AddCommand(&cmd_client, "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(&cmd_client, "unalias",Cmd_UnAlias_f, "remove an alias"); - Cmd_AddCommand(&cmd_client, "set", Cvar_Set_f, "create or change the value of a console variable"); - Cmd_AddCommand(&cmd_client, "seta", Cvar_SetA_f, "create or change the value of a console variable that will be saved to config.cfg"); - Cmd_AddCommand(&cmd_client, "unset", Cvar_Del_f, "delete a cvar (does not work for static ones like _cl_name, or read-only ones)"); - Cmd_AddCommand(&cmd_clientfromserver, "exec", Cmd_Exec_f, "execute a script file"); - Cmd_AddCommand(&cmd_clientfromserver, "echo", Cmd_Echo_f, "print a message to the console (useful in scripts)"); - Cmd_AddCommand(&cmd_clientfromserver, "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(&cmd_clientfromserver, "unalias", Cmd_UnAlias_f, "remove an alias"); - Cmd_AddCommand(&cmd_clientfromserver, "set", Cvar_Set_f, "create or change the value of a console variable"); - Cmd_AddCommand(&cmd_clientfromserver, "seta", Cvar_SetA_f, "create or change the value of a console variable that will be saved to config.cfg"); - Cmd_AddCommand(&cmd_clientfromserver, "unset", Cvar_Del_f, "delete a cvar (does not work for static ones like _cl_name, or read-only ones)"); - Cmd_AddCommand(&cmd_server, "exec", Cmd_Exec_f, "execute a script file"); - Cmd_AddCommand(&cmd_server, "echo", Cmd_Echo_f, "print a message to the console (useful in scripts)"); - Cmd_AddCommand(&cmd_server, "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(&cmd_server, "unalias", Cmd_UnAlias_f, "remove an alias"); - Cmd_AddCommand(&cmd_server, "set", Cvar_Set_f, "create or change the value of a console variable"); - Cmd_AddCommand(&cmd_server, "seta", Cvar_SetA_f, "create or change the value of a console variable that will be saved to config.cfg"); - Cmd_AddCommand(&cmd_server, "unset", Cvar_Del_f, "delete a cvar (does not work for static ones like _cl_name, or read-only ones)"); + Cmd_AddCommand(CF_SHARED, "exec", Cmd_Exec_f, "execute a script file"); + Cmd_AddCommand(CF_SHARED, "echo",Cmd_Echo_f, "print a message to the console (useful in scripts)"); + Cmd_AddCommand(CF_SHARED, "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(CF_SHARED, "unalias",Cmd_UnAlias_f, "remove an alias"); + Cmd_AddCommand(CF_SHARED, "set", Cvar_Set_f, "create or change the value of a console variable"); + Cmd_AddCommand(CF_SHARED, "seta", Cvar_SetA_f, "create or change the value of a console variable that will be saved to config.cfg"); + Cmd_AddCommand(CF_SHARED, "unset", Cvar_Del_f, "delete a cvar (does not work for static ones like _cl_name, or read-only ones)"); #ifdef FILLALLCVARSWITHRUBBISH - Cmd_AddCommand(&cmd_client, "fillallcvarswithrubbish", Cvar_FillAll_f, "fill all cvars with a specified number of characters to provoke buffer overruns"); - Cmd_AddCommand(&cmd_server, "fillallcvarswithrubbish", Cvar_FillAll_f, "fill all cvars with a specified number of characters to provoke buffer overruns"); + Cmd_AddCommand(CF_SHARED, "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(&cmd_client, "cmdlist", Cmd_List_f, "lists all console commands beginning with the specified prefix or matching the specified wildcard pattern"); - Cmd_AddCommand(&cmd_client, "cvarlist", Cvar_List_f, "lists all console variables beginning with the specified prefix or matching the specified wildcard pattern"); - Cmd_AddCommand(&cmd_client, "apropos", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description"); - Cmd_AddCommand(&cmd_server, "cmdlist", Cmd_List_f, "lists all console commands beginning with the specified prefix or matching the specified wildcard pattern"); - Cmd_AddCommand(&cmd_server, "cvarlist", Cvar_List_f, "lists all console variables beginning with the specified prefix or matching the specified wildcard pattern"); - Cmd_AddCommand(&cmd_server, "apropos", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description"); + Cmd_AddCommand(CF_SHARED, "cmdlist", Cmd_List_f, "lists all console commands beginning with the specified prefix or matching the specified wildcard pattern"); + Cmd_AddCommand(CF_SHARED, "cvarlist", Cvar_List_f, "lists all console variables beginning with the specified prefix or matching the specified wildcard pattern"); + Cmd_AddCommand(CF_SHARED, "apropos", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description"); + Cmd_AddCommand(CF_SHARED, "find", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description"); - Cmd_AddCommand(&cmd_client, "defer", Cmd_Defer_f, "execute a command in the future"); - Cmd_AddCommand(&cmd_server, "defer", Cmd_Defer_f, "execute a command in the future"); + Cmd_AddCommand(CF_SHARED, "defer", Cmd_Defer_f, "execute a command in the future"); // DRESK - 5/14/06 // Support Doom3-style Toggle Command - Cmd_AddCommand(&cmd_client, "toggle", Cmd_Toggle_f, "toggles a console variable's values (use for more info)"); - Cmd_AddCommand(&cmd_server, "toggle", Cmd_Toggle_f, "toggles a console variable's values (use for more info)"); - Cmd_AddCommand(&cmd_clientfromserver, "toggle", Cmd_Toggle_f, "toggles a console variable's values (use for more info)"); + Cmd_AddCommand(CF_SHARED | CF_CLIENT_FROM_SERVER, "toggle", Cmd_Toggle_f, "toggles a console variable's values (use for more info)"); } /* @@ -1600,10 +1729,10 @@ void Cmd_Shutdown(void) { cmd_state_t *cmd = cmd_iter->cmd; - if (cmd->text_lock) + if (cmd->cbuf->lock) { // we usually have this locked when we get here from Host_Quit_f - Cbuf_Unlock(cmd); + Cbuf_Unlock(cmd->cbuf); } Mem_FreePool(&cmd->mempool); @@ -1642,7 +1771,6 @@ const char *Cmd_Args (cmd_state_t *cmd) return cmd->args; } - /* ============ Cmd_TokenizeString @@ -1657,6 +1785,7 @@ static void Cmd_TokenizeString (cmd_state_t *cmd, const char *text) cmd->argc = 0; cmd->args = NULL; + cmd->cmdline = NULL; while (1) { @@ -1680,6 +1809,8 @@ static void Cmd_TokenizeString (cmd_state_t *cmd, const char *text) if (!*text) return; + if(!cmd->argc) + cmd->cmdline = text; if (cmd->argc == 1) cmd->args = text; @@ -1689,14 +1820,14 @@ static void Cmd_TokenizeString (cmd_state_t *cmd, const char *text) if (cmd->argc < MAX_ARGS) { l = (int)strlen(com_token) + 1; - if (cmd->tokenizebufferpos + l > CMD_TOKENIZELENGTH) + if (cmd->cbuf->tokenizebufferpos + l > CMD_TOKENIZELENGTH) { - Con_Printf("Cmd_TokenizeString: ran out of %i character buffer space for command arguements\n", CMD_TOKENIZELENGTH); + Con_Printf("Cmd_TokenizeString: ran out of %i character buffer space for command arguments\n", CMD_TOKENIZELENGTH); break; } - memcpy (cmd->tokenizebuffer + cmd->tokenizebufferpos, com_token, l); - cmd->argv[cmd->argc] = cmd->tokenizebuffer + cmd->tokenizebufferpos; - cmd->tokenizebufferpos += l; + memcpy (cmd->cbuf->tokenizebuffer + cmd->cbuf->tokenizebufferpos, com_token, l); + cmd->argv[cmd->argc] = cmd->cbuf->tokenizebuffer + cmd->cbuf->tokenizebufferpos; + cmd->cbuf->tokenizebufferpos += l; cmd->argc++; } } @@ -1708,77 +1839,88 @@ static void Cmd_TokenizeString (cmd_state_t *cmd, const char *text) Cmd_AddCommand ============ */ -void Cmd_AddCommand(cmd_state_t *cmd, const char *cmd_name, xcommand_t function, const char *description) +void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const char *description) { cmd_function_t *func; cmd_function_t *prev, *current; + cmd_state_t *cmd; + int i; -// fail if the command is a variable name - if (Cvar_FindVar(cmd->cvars, cmd_name, ~0, true)) - { - Con_Printf("Cmd_AddCommand: %s already defined as a var\n", cmd_name); - return; - } - - if (function) + for (i = 0; i < 2; i++) { - // fail if the command already exists in this interpreter - for (func = cmd->engine_functions; func; func = func->next) + cmd = cmd_iter_all[i].cmd; + if (flags & cmd->cmd_flags) { - if (!strcmp(cmd_name, func->name)) + // fail if the command is a variable name + if (Cvar_FindVar(cmd->cvars, cmd_name, ~0)) { - Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name); + Con_Printf("Cmd_AddCommand: %s already defined as a var\n", cmd_name); return; } - } - func = (cmd_function_t *)Mem_Alloc(cmd->mempool, sizeof(cmd_function_t)); - func->name = cmd_name; - func->function = function; - func->description = description; - func->next = cmd->engine_functions; - - // insert it at the right alphanumeric position - for (prev = NULL, current = cmd->engine_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next) - ; - if (prev) { - prev->next = func; - } - else { - cmd->engine_functions = func; - } - func->next = current; - } - else - { - // mark csqcfunc if the function already exists in the csqc_functions list - for (func = cmd->userdefined->csqc_functions; func; func = func->next) - { - if (!strcmp(cmd_name, func->name)) + if (function) { - func->csqcfunc = true; //[515]: csqc - return; + // fail if the command already exists in this interpreter + for (func = cmd->engine_functions; func; func = func->next) + { + if (!strcmp(cmd_name, func->name)) + { + Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name); + continue; + } + } + + func = (cmd_function_t *)Mem_Alloc(cmd->mempool, sizeof(cmd_function_t)); + func->flags = flags; + func->name = cmd_name; + func->function = function; + func->description = description; + func->next = cmd->engine_functions; + + // insert it at the right alphanumeric position + for (prev = NULL, current = cmd->engine_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next) + ; + if (prev) { + prev->next = func; + } + else { + cmd->engine_functions = func; + } + func->next = current; } - } + else + { + // mark qcfunc if the function already exists in the qc_functions list + for (func = cmd->userdefined->qc_functions; func; func = func->next) + { + if (!strcmp(cmd_name, func->name)) + { + func->qcfunc = true; //[515]: csqc + continue; + } + } - func = (cmd_function_t *)Mem_Alloc(cmd->mempool, sizeof(cmd_function_t)); - func->name = cmd_name; - func->function = function; - func->description = description; - func->csqcfunc = true; //[515]: csqc - func->next = cmd->userdefined->csqc_functions; + func = (cmd_function_t *)Mem_Alloc(cmd->mempool, sizeof(cmd_function_t)); + func->flags = flags; + func->name = cmd_name; + func->function = function; + func->description = description; + func->qcfunc = true; //[515]: csqc + func->next = cmd->userdefined->qc_functions; - // insert it at the right alphanumeric position - for (prev = NULL, current = cmd->userdefined->csqc_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next) - ; - if (prev) { - prev->next = func; - } - else { - cmd->userdefined->csqc_functions = func; + // insert it at the right alphanumeric position + for (prev = NULL, current = cmd->userdefined->qc_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next) + ; + if (prev) { + prev->next = func; + } + else { + cmd->userdefined->qc_functions = func; + } + func->next = current; + } } - func->next = current; } } @@ -1787,11 +1929,11 @@ void Cmd_AddCommand(cmd_state_t *cmd, const char *cmd_name, xcommand_t function, Cmd_Exists ============ */ -qboolean Cmd_Exists (cmd_state_t *cmd, const char *cmd_name) +qbool Cmd_Exists (cmd_state_t *cmd, const char *cmd_name) { cmd_function_t *func; - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) if (!strcmp(cmd_name, func->name)) return true; @@ -1819,7 +1961,7 @@ const char *Cmd_CompleteCommand (cmd_state_t *cmd, const char *partial) return NULL; // check functions - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) if (!strncasecmp(partial, func->name, len)) return func->name; @@ -1852,7 +1994,7 @@ int Cmd_CompleteCountPossible (cmd_state_t *cmd, const char *partial) return 0; // Loop through the command list and count all partial matches - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) if (!strncasecmp(partial, func->name, len)) h++; @@ -1883,7 +2025,7 @@ const char **Cmd_CompleteBuildList (cmd_state_t *cmd, const char *partial) len = strlen(partial); buf = (const char **)Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *)); // Loop through the functions lists and print all matches - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) if (!strncasecmp(partial, func->name, len)) buf[bpos++] = func->name; for (func = cmd->engine_functions; func; func = func->next) @@ -1900,7 +2042,7 @@ void Cmd_CompleteCommandPrint (cmd_state_t *cmd, const char *partial) cmd_function_t *func; size_t len = strlen(partial); // Loop through the command list and print all matches - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) if (!strncasecmp(partial, func->name, len)) Con_Printf("^2%s^7: %s\n", func->name, func->description); for (func = cmd->engine_functions; func; func = func->next) @@ -1919,7 +2061,7 @@ void Cmd_CompleteCommandPrint (cmd_state_t *cmd, const char *partial) */ const char *Cmd_CompleteAlias (cmd_state_t *cmd, const char *partial) { - cmdalias_t *alias; + cmd_alias_t *alias; size_t len; len = strlen(partial); @@ -1938,7 +2080,7 @@ const char *Cmd_CompleteAlias (cmd_state_t *cmd, const char *partial) // written by LadyHavoc void Cmd_CompleteAliasPrint (cmd_state_t *cmd, const char *partial) { - cmdalias_t *alias; + cmd_alias_t *alias; size_t len = strlen(partial); // Loop through the alias list and print all matches for (alias = cmd->userdefined->alias; alias; alias = alias->next) @@ -1958,7 +2100,7 @@ void Cmd_CompleteAliasPrint (cmd_state_t *cmd, const char *partial) */ int Cmd_CompleteAliasCountPossible (cmd_state_t *cmd, const char *partial) { - cmdalias_t *alias; + cmd_alias_t *alias; size_t len; int h; @@ -1988,7 +2130,7 @@ int Cmd_CompleteAliasCountPossible (cmd_state_t *cmd, const char *partial) */ const char **Cmd_CompleteAliasBuildList (cmd_state_t *cmd, const char *partial) { - cmdalias_t *alias; + cmd_alias_t *alias; size_t len = 0; size_t bpos = 0; size_t sizeofbuf = (Cmd_CompleteAliasCountPossible (cmd, partial) + 1) * sizeof (const char *); @@ -2009,7 +2151,7 @@ const char **Cmd_CompleteAliasBuildList (cmd_state_t *cmd, const char *partial) void Cmd_ClearCSQCCommands (cmd_state_t *cmd) { cmd_function_t *func; - cmd_function_t **next = &cmd->userdefined->csqc_functions; + cmd_function_t **next = &cmd->userdefined->qc_functions; while(*next) { @@ -2019,6 +2161,78 @@ void Cmd_ClearCSQCCommands (cmd_state_t *cmd) } } +extern cvar_t sv_cheats; + +/* + * Cloudwalk FIXME: This idea sounded great in my head but... + * How do we handle commands that can be received by the client, + * but which the server can also execute locally? + * + * If we create a callback where the engine will forward to server + * but try to execute the command locally if it's dedicated, + * we're back to intermixing client and server code which I'm + * trying to avoid. There's no other way I can think of to + * implement that behavior that doesn't involve an #ifdef, or + * making a mess of hooks. + */ +qbool Cmd_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src) +{ + if (func->function) + func->function(cmd); + else + Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(cmd, 0)); + return true; +} + +qbool Cmd_CL_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src) +{ + // TODO: Assign these functions to QC commands directly? + if(func->qcfunc) + { + if(((func->flags & CF_CLIENT) && CL_VM_ConsoleCommand(text)) || + ((func->flags & CF_SERVER) && SV_VM_ConsoleCommand(text))) + return true; + } + if (func->flags & CF_SERVER_FROM_CLIENT) + { + if(host_isclient.integer) + { + CL_ForwardToServer_f(cmd); + return true; + } + else if(!(func->flags & CF_SERVER)) + { + Con_Printf("Cannot execute client commands from a dedicated server console.\n"); + return true; + } + } + return Cmd_Callback(cmd, func, text, src); +} + +qbool Cmd_SV_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src) +{ + if(func->qcfunc && (func->flags & CF_SERVER)) + return SV_VM_ConsoleCommand(text); + else if (src == src_client) + { + if((func->flags & CF_CHEAT) && !sv_cheats.integer) + SV_ClientPrintf("No cheats allowed. The server must have sv_cheats set to 1\n"); + else + func->function(cmd); + return true; + } + return false; +} + +qbool Cmd_SV_NotFound(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src) +{ + if (cmd->source == src_client) + { + Con_Printf("Client \"%s\" tried to execute \"%s\"\n", host_client->name, text); + return true; + } + return false; +} /* ============ Cmd_ExecuteString @@ -2027,14 +2241,14 @@ A complete command line has been parsed, so try to execute it FIXME: lookupnoadd the token to speed search? ============ */ -void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qboolean lockmutex) +void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qbool lockmutex) { int oldpos; cmd_function_t *func; - cmdalias_t *a; + cmd_alias_t *a; if (lockmutex) - Cbuf_Lock(cmd); - oldpos = cmd->tokenizebufferpos; + Cbuf_Lock(cmd->cbuf); + oldpos = cmd->cbuf->tokenizebufferpos; cmd->source = src; Cmd_TokenizeString (cmd, text); @@ -2044,13 +2258,12 @@ void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qb goto done; // no tokens // check functions - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) { if (!strcasecmp(cmd->argv[0], func->name)) { - if (func->csqcfunc && CL_VM_ConsoleCommand(text)) //[515]: csqc + if(cmd->Handle(cmd, func, text, src)) goto done; - break; } } @@ -2058,30 +2271,16 @@ void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qb { if (!strcasecmp (cmd->argv[0], func->name)) { - switch (src) - { - case src_command: - if (func->function) - func->function(cmd); - else - Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(cmd, 0)); + if(cmd->Handle(cmd, func, text, src)) goto done; - case src_client: - if (func->function) - { - func->function(cmd); - goto done; - } - } - break; } } // if it's a client command and no command was found, say so. - if (cmd->source == src_client) + if(cmd->NotFound) { - Con_Printf("Client \"%s\" tried to execute \"%s\"\n", host_client->name, text); - goto done; + if(cmd->NotFound(cmd, func, text, src)) + goto done; } // check alias @@ -2095,175 +2294,14 @@ void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qb } // check cvars - if (!Cvar_Command(cmd) && host_framecount > 0) { - if (cmd == &cmd_clientfromserver) { - Con_Printf("Server tried to execute \"%s\"\n", Cmd_Argv(cmd, 0)); - } else { - Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(cmd, 0)); - } - } + if (!Cvar_Command(cmd) && host.framecount > 0) + Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(cmd, 0)); done: - cmd->tokenizebufferpos = oldpos; + cmd->cbuf->tokenizebufferpos = oldpos; if (lockmutex) - Cbuf_Unlock(cmd); + Cbuf_Unlock(cmd->cbuf); } - -/* -=================== -Cmd_ForwardStringToServer - -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); - return; - } - - if (!cls.netcon) - return; - - // LadyHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my - // attention, it has been eradicated from here, its only (former) use in - // all of darkplaces. - if (cls.protocol == PROTOCOL_QUAKEWORLD) - MSG_WriteByte(&cls.netcon->message, qw_clc_stringcmd); - else - MSG_WriteByte(&cls.netcon->message, clc_stringcmd); - 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, (int)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); -} - -/* -=================== -Cmd_ForwardToServer - -Sends the entire command line over to the server -=================== -*/ -void Cmd_ForwardToServer_f (cmd_state_t *cmd) -{ - const char *s; - char vabuf[1024]; - if (!strcasecmp(Cmd_Argv(cmd, 0), "cmd")) - { - // we want to strip off "cmd", so just send the args - s = Cmd_Argc(cmd) > 1 ? Cmd_Args(cmd) : ""; - } - else - { - // we need to keep the command name, so send Cmd_Argv(cmd, 0), a space and then Cmd_Args(cmd) - s = va(vabuf, sizeof(vabuf), "%s %s", Cmd_Argv(cmd, 0), Cmd_Argc(cmd) > 1 ? Cmd_Args(cmd) : ""); - } - // don't send an empty forward message if the user tries "cmd" by itself - if (!s || !*s) - return; - Cmd_ForwardStringToServer(s); -} - - /* ================ Cmd_CheckParm @@ -2299,8 +2337,8 @@ void Cmd_SaveInitState(void) { cmd_state_t *cmd = cmd_iter->cmd; cmd_function_t *f; - cmdalias_t *a; - for (f = cmd->userdefined->csqc_functions; f; f = f->next) + cmd_alias_t *a; + for (f = cmd->userdefined->qc_functions; f; f = f->next) f->initstate = true; for (f = cmd->engine_functions; f; f = f->next) f->initstate = true; @@ -2320,8 +2358,8 @@ void Cmd_RestoreInitState(void) { cmd_state_t *cmd = cmd_iter->cmd; cmd_function_t *f, **fp; - cmdalias_t *a, **ap; - for (fp = &cmd->userdefined->csqc_functions; (f = *fp);) + cmd_alias_t *a, **ap; + for (fp = &cmd->userdefined->qc_functions; (f = *fp);) { if (f->initstate) fp = &f->next; @@ -2372,3 +2410,7 @@ void Cmd_RestoreInitState(void) } Cvar_RestoreInitState(&cvars_all); } + +void Cmd_NoOperation_f(cmd_state_t *cmd) +{ +}