X-Git-Url: http://git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cmd.c;h=abc512eef3a4e547ba72e24e07e1aaad43cbe961;hp=4d615f1a23c9b1dcc8aed5cf04d85ef7ba077118;hb=f50a1192fbe86bfdd69d3372620db0b661db5f20;hpb=462ee906731d1e2ee79707aaee0365ad717231ce diff --git a/cmd.c b/cmd.c index 4d615f1a..abc512ee 100644 --- a/cmd.c +++ b/cmd.c @@ -22,26 +22,37 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "quakedef.h" #include "thread.h" -typedef struct cmdalias_s -{ - struct cmdalias_s *next; - char name[MAX_ALIAS_NAME]; - char *value; - qboolean initstate; // indicates this command existed at init - char *initialvalue; // backup copy of value at init -} cmdalias_t; +cmd_state_t *cmd_local; +cmd_state_t *cmd_serverfromclient; + +cmd_userdefined_t cmd_userdefined_all; +cmd_userdefined_t cmd_userdefined_null; -static cmdalias_t *cmd_alias; +typedef struct cmd_iter_s { + cmd_state_t *cmd; +} +cmd_iter_t; -static qboolean cmd_wait; +static cmd_iter_t *cmd_iter_all; -static mempool_t *cmd_mempool; +mempool_t *cbuf_mempool; -static char cmd_tokenizebuffer[CMD_TOKENIZELENGTH]; -static int cmd_tokenizebufferpos = 0; +// we only run the +whatever commandline arguments once +qbool host_stuffcmdsrun = false; //============================================================================= +void Cbuf_Lock(cmd_buf_t *cbuf) +{ + Thread_LockMutex(cbuf->lock); +} + +void Cbuf_Unlock(cmd_buf_t *cbuf) +{ + Thread_UnlockMutex(cbuf->lock); +} + + /* ============ Cmd_Wait_f @@ -51,20 +62,11 @@ next frame. This allows commands like: bind g "impulse 5 ; +attack ; wait ; -attack ; impulse 2" ============ */ -static void Cmd_Wait_f (void) +static void Cmd_Wait_f (cmd_state_t *cmd) { - cmd_wait = true; + cmd->cbuf->wait = true; } -typedef struct cmddeferred_s -{ - struct cmddeferred_s *next; - char *value; - double delay; -} cmddeferred_t; - -static cmddeferred_t *cmd_deferred_list = NULL; - /* ============ Cmd_Defer_f @@ -72,50 +74,47 @@ Cmd_Defer_f Cause a command to be executed after a delay. ============ */ -static void Cmd_Defer_f (void) +static cmd_input_t *Cbuf_LinkGet(cmd_buf_t *cbuf, cmd_input_t *existing); +static void Cmd_Defer_f (cmd_state_t *cmd) { - if(Cmd_Argc() == 1) + 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, list) + Con_Printf("-> In %9.2f: %s\n", current->delay, current->text); } - } else if(Cmd_Argc() == 2 && !strcasecmp("clear", Cmd_Argv(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 *cmd = cmd_deferred_list; - cmd_deferred_list = cmd->next; - Mem_Free(cmd->value); - Mem_Free(cmd); + current->text = (char *)Mem_Realloc(cbuf_mempool, current->text, current->length + 1); + current->size = current->length; } - } 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->delay = atof(Cmd_Argv(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; @@ -129,20 +128,20 @@ Cmd_Centerprint_f Print something to the center of the screen using SCR_Centerprint ============ */ -static void Cmd_Centerprint_f (void) +static void Cmd_Centerprint_f (cmd_state_t *cmd) { char msg[MAX_INPUTLINE]; unsigned int i, c, p; - c = Cmd_Argc(); + c = Cmd_Argc(cmd); if(c >= 2) { - strlcpy(msg, Cmd_Argv(1), sizeof(msg)); + strlcpy(msg, Cmd_Argv(cmd,1), sizeof(msg)); for(i = 2; i < c; ++i) { strlcat(msg, " ", sizeof(msg)); - strlcat(msg, Cmd_Argv(i), sizeof(msg)); + strlcat(msg, Cmd_Argv(cmd, i), sizeof(msg)); } - c = strlen(msg); + c = (unsigned int)strlen(msg); for(p = 0, i = 0; i < c; ++i) { if(msg[i] == '\\') @@ -173,12 +172,180 @@ static void Cmd_Centerprint_f (void) ============================================================================= */ -static sizebuf_t cmd_text; -static unsigned char cmd_text_buf[CMDBUFSIZE]; -void *cmd_text_mutex = NULL; +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); + } -#define Cbuf_LockThreadMutex() (void)(cmd_text_mutex ? Thread_LockMutex(cmd_text_mutex) : 0) -#define Cbuf_UnlockThreadMutex() (void)(cmd_text_mutex ? Thread_UnlockMutex(cmd_text_mutex) : 0) + totalsize += newsize; + } + else if (current == existing && !totalsize) + current->pending = false; + current = NULL; + } + + cbuf->size += totalsize; +} /* ============ @@ -187,45 +354,52 @@ Cbuf_AddText Adds command text at the end of the buffer ============ */ -void Cbuf_AddText (const char *text) +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_LockThreadMutex(); - if (cmd_text.cursize + l >= cmd_text.maxsize) + if (cbuf->maxsize - cbuf->size <= l) Con_Print("Cbuf_AddText: overflow\n"); else - SZ_Write(&cmd_text, (const unsigned char *)text, l); - Cbuf_UnlockThreadMutex(); + { + 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 (const char *text) +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_LockThreadMutex(); + + 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 += l; - memcpy(cmd_text.data, text, l); + Cbuf_LinkCreate(cmd, &llist, List_Entry(cbuf->start.next, cmd_input_t, list), text); + if(!List_Is_Empty(&llist)) + List_Splice(&llist, &cbuf->start); } - Cbuf_UnlockThreadMutex(); + + Cbuf_Unlock(cbuf); } /* @@ -233,40 +407,28 @@ void Cbuf_InsertText (const char *text) Cbuf_Execute_Deferred --blub ============ */ -static void Cbuf_Execute_Deferred (void) +static void Cbuf_Execute_Deferred (cmd_buf_t *cbuf) { - static double oldrealtime = 0; - cmddeferred_t *cmd, *prev; + cmd_input_t *current; double eat; - if (realtime - oldrealtime < 0 || realtime - oldrealtime > 1800) oldrealtime = realtime; - eat = realtime - 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; - oldrealtime = realtime; - prev = NULL; - cmd = cmd_deferred_list; - while(cmd) + cbuf->deferred_oldtime = host.realtime; + + List_For_Each_Entry(current, &cbuf->deferred, list) { - cmd->delay -= eat; - if(cmd->delay <= 0) + current->delay -= eat; + if(current->delay <= 0) { - 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; + 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 = cmd; - cmd = cmd->next; } } @@ -275,117 +437,98 @@ static void Cbuf_Execute_Deferred (void) Cbuf_Execute ============ */ -static qboolean Cmd_PreprocessString( const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias ); -void Cbuf_Execute (void) +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; - // LordHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes - cmd_tokenizebufferpos = 0; + // LadyHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes + 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_Printf("Warning: console input buffer had an overlong line. Ignored.\n"); - line[0] = 0; - } - else - { - memcpy (line, text, comment ? (comment - text) : i); - line[comment ? (comment - text) : i] = 0; - } - -// delete the text from the command buffer and move remaining commands down -// this is necessary because commands (exec, alias) can insert data at the -// 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( line, preprocessed, sizeof(preprocessed), NULL )) - Cmd_ExecuteString (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 (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(void) +/* +=================== +Cbuf_Frame_Input + +Add them exactly as if they had been typed at the console +=================== +*/ +static void Cbuf_Frame_Input(void) { - Cbuf_Execute_Deferred(); - 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(); + Cbuf_Execute(cbuf); SV_UnlockThreadMutex(); } + +// R_TimeReport("console"); } /* @@ -406,14 +549,13 @@ quake +prog jctest.qp +cmd amlev1 quake -nosound +cmd amlev1 =============== */ -qboolean host_stuffcmdsrun = false; -static void Cmd_StuffCmds_f (void) +static void Cmd_StuffCmds_f (cmd_state_t *cmd) { int i, j, l; // this is for all commandline options combined (and is bounds checked) char build[MAX_INPUTLINE]; - if (Cmd_Argc () != 1) + if (Cmd_Argc (cmd) != 1) { Con_Print("stuffcmds : execute command line parameters\n"); return; @@ -426,28 +568,28 @@ static void Cmd_StuffCmds_f (void) 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'; @@ -457,19 +599,21 @@ static void Cmd_StuffCmds_f (void) // 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); + Cbuf_InsertText (cmd, build); } -static void Cmd_Exec(const char *filename) +static void Cmd_Exec(cmd_state_t *cmd, const char *filename) { char *f; size_t filenameLen = strlen(filename); - qboolean isdefaultcfg = filenameLen >= 11 && !strcmp(filename + filenameLen - 11, "default.cfg"); + 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 } @@ -485,12 +629,9 @@ static void Cmd_Exec(const char *filename) // 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 (isdefaultcfg) - Cbuf_InsertText("\ncvar_lockdefaults\n"); + 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 ("\n"); - Cbuf_InsertText (f); + Cbuf_InsertText (cmd, f); Mem_Free(f); if (isdefaultcfg) @@ -498,23 +639,222 @@ static void Cmd_Exec(const char *filename) // special defaults for specific games go here, these execute before default.cfg // Nehahra pushable crates malfunction in some levels if this is on // Nehahra NPC AI is confused by blowupfallenzombies - if (gamemode == GAME_NEHAHRA) - Cbuf_InsertText("\nsv_gameplayfix_upwardvelocityclearsongroundflag 0\nsv_gameplayfix_blowupfallenzombies 0\n\n"); + switch(gamemode) + { + case GAME_NORMAL: + Cbuf_InsertText(cmd, "\n" +"sv_gameplayfix_blowupfallenzombies 0\n" +"sv_gameplayfix_findradiusdistancetobox 0\n" +"sv_gameplayfix_grenadebouncedownslopes 0\n" +"sv_gameplayfix_slidemoveprojectiles 0\n" +"sv_gameplayfix_upwardvelocityclearsongroundflag 0\n" +"sv_gameplayfix_setmodelrealbox 0\n" +"sv_gameplayfix_droptofloorstartsolid 0\n" +"sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n" +"sv_gameplayfix_noairborncorpse 0\n" +"sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n" +"sv_gameplayfix_easierwaterjump 0\n" +"sv_gameplayfix_delayprojectiles 0\n" +"sv_gameplayfix_multiplethinksperframe 0\n" +"sv_gameplayfix_fixedcheckwatertransition 0\n" +"sv_gameplayfix_q1bsptracelinereportstexture 0\n" +"sv_gameplayfix_swiminbmodels 0\n" +"sv_gameplayfix_downtracesupportsongroundflag 0\n" +"sys_ticrate 0.01388889\n" +"r_shadow_gloss 1\n" +"r_shadow_bumpscale_basetexture 0\n" +"csqc_polygons_defaultmaterial_nocullface 0\n" + ); + break; + case GAME_NEHAHRA: + Cbuf_InsertText(cmd, "\n" +"sv_gameplayfix_blowupfallenzombies 0\n" +"sv_gameplayfix_findradiusdistancetobox 0\n" +"sv_gameplayfix_grenadebouncedownslopes 0\n" +"sv_gameplayfix_slidemoveprojectiles 0\n" +"sv_gameplayfix_upwardvelocityclearsongroundflag 0\n" +"sv_gameplayfix_setmodelrealbox 0\n" +"sv_gameplayfix_droptofloorstartsolid 0\n" +"sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n" +"sv_gameplayfix_noairborncorpse 0\n" +"sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n" +"sv_gameplayfix_easierwaterjump 0\n" +"sv_gameplayfix_delayprojectiles 0\n" +"sv_gameplayfix_multiplethinksperframe 0\n" +"sv_gameplayfix_fixedcheckwatertransition 0\n" +"sv_gameplayfix_q1bsptracelinereportstexture 0\n" +"sv_gameplayfix_swiminbmodels 0\n" +"sv_gameplayfix_downtracesupportsongroundflag 0\n" +"sys_ticrate 0.01388889\n" +"r_shadow_gloss 1\n" +"r_shadow_bumpscale_basetexture 0\n" +"csqc_polygons_defaultmaterial_nocullface 0\n" + ); + break; // hipnotic mission pack has issues in their 'friendly monster' ai, which seem to attempt to attack themselves for some reason when findradius() returns non-solid entities. // hipnotic mission pack has issues with bobbing water entities 'jittering' between different heights on alternate frames at the default 0.0138889 ticrate, 0.02 avoids this issue // hipnotic mission pack has issues in their proximity mine sticking code, which causes them to bounce off. - if (gamemode == GAME_HIPNOTIC) - Cbuf_InsertText("\nsv_gameplayfix_blowupfallenzombies 0\nsys_ticrate 0.02\nsv_gameplayfix_slidemoveprojectiles 0\n\n"); + case GAME_HIPNOTIC: + case GAME_QUOTH: + Cbuf_InsertText(cmd, "\n" +"sv_gameplayfix_blowupfallenzombies 0\n" +"sv_gameplayfix_findradiusdistancetobox 0\n" +"sv_gameplayfix_grenadebouncedownslopes 0\n" +"sv_gameplayfix_slidemoveprojectiles 0\n" +"sv_gameplayfix_upwardvelocityclearsongroundflag 0\n" +"sv_gameplayfix_setmodelrealbox 0\n" +"sv_gameplayfix_droptofloorstartsolid 0\n" +"sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n" +"sv_gameplayfix_noairborncorpse 0\n" +"sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n" +"sv_gameplayfix_easierwaterjump 0\n" +"sv_gameplayfix_delayprojectiles 0\n" +"sv_gameplayfix_multiplethinksperframe 0\n" +"sv_gameplayfix_fixedcheckwatertransition 0\n" +"sv_gameplayfix_q1bsptracelinereportstexture 0\n" +"sv_gameplayfix_swiminbmodels 0\n" +"sv_gameplayfix_downtracesupportsongroundflag 0\n" +"sys_ticrate 0.02\n" +"r_shadow_gloss 1\n" +"r_shadow_bumpscale_basetexture 0\n" +"csqc_polygons_defaultmaterial_nocullface 0\n" + ); + break; // rogue mission pack has a guardian boss that does not wake up if findradius returns one of the entities around its spawn area - if (gamemode == GAME_ROGUE) - Cbuf_InsertText("\nsv_gameplayfix_findradiusdistancetobox 0\n\n"); - if (gamemode == GAME_NEXUIZ) - Cbuf_InsertText("\nsv_gameplayfix_q2airaccelerate 1\nsv_gameplayfix_stepmultipletimes 1\n\n"); - if (gamemode == GAME_TENEBRAE) - Cbuf_InsertText("\nr_shadow_gloss 2\nr_shadow_bumpscale_basetexture 4\n\n"); + case GAME_ROGUE: + Cbuf_InsertText(cmd, "\n" +"sv_gameplayfix_blowupfallenzombies 0\n" +"sv_gameplayfix_findradiusdistancetobox 0\n" +"sv_gameplayfix_grenadebouncedownslopes 0\n" +"sv_gameplayfix_slidemoveprojectiles 0\n" +"sv_gameplayfix_upwardvelocityclearsongroundflag 0\n" +"sv_gameplayfix_setmodelrealbox 0\n" +"sv_gameplayfix_droptofloorstartsolid 0\n" +"sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n" +"sv_gameplayfix_noairborncorpse 0\n" +"sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n" +"sv_gameplayfix_easierwaterjump 0\n" +"sv_gameplayfix_delayprojectiles 0\n" +"sv_gameplayfix_multiplethinksperframe 0\n" +"sv_gameplayfix_fixedcheckwatertransition 0\n" +"sv_gameplayfix_q1bsptracelinereportstexture 0\n" +"sv_gameplayfix_swiminbmodels 0\n" +"sv_gameplayfix_downtracesupportsongroundflag 0\n" +"sys_ticrate 0.01388889\n" +"r_shadow_gloss 1\n" +"r_shadow_bumpscale_basetexture 0\n" +"csqc_polygons_defaultmaterial_nocullface 0\n" + ); + break; + case GAME_TENEBRAE: + Cbuf_InsertText(cmd, "\n" +"sv_gameplayfix_blowupfallenzombies 0\n" +"sv_gameplayfix_findradiusdistancetobox 0\n" +"sv_gameplayfix_grenadebouncedownslopes 0\n" +"sv_gameplayfix_slidemoveprojectiles 0\n" +"sv_gameplayfix_upwardvelocityclearsongroundflag 0\n" +"sv_gameplayfix_setmodelrealbox 0\n" +"sv_gameplayfix_droptofloorstartsolid 0\n" +"sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 0\n" +"sv_gameplayfix_noairborncorpse 0\n" +"sv_gameplayfix_noairborncorpse_allowsuspendeditems 0\n" +"sv_gameplayfix_easierwaterjump 0\n" +"sv_gameplayfix_delayprojectiles 0\n" +"sv_gameplayfix_multiplethinksperframe 0\n" +"sv_gameplayfix_fixedcheckwatertransition 0\n" +"sv_gameplayfix_q1bsptracelinereportstexture 0\n" +"sv_gameplayfix_swiminbmodels 0\n" +"sv_gameplayfix_downtracesupportsongroundflag 0\n" +"sys_ticrate 0.01388889\n" +"r_shadow_gloss 2\n" +"r_shadow_bumpscale_basetexture 4\n" +"csqc_polygons_defaultmaterial_nocullface 0\n" + ); + break; + case GAME_NEXUIZ: + Cbuf_InsertText(cmd, "\n" +"sv_gameplayfix_blowupfallenzombies 1\n" +"sv_gameplayfix_findradiusdistancetobox 1\n" +"sv_gameplayfix_grenadebouncedownslopes 1\n" +"sv_gameplayfix_slidemoveprojectiles 1\n" +"sv_gameplayfix_upwardvelocityclearsongroundflag 1\n" +"sv_gameplayfix_setmodelrealbox 1\n" +"sv_gameplayfix_droptofloorstartsolid 1\n" +"sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 1\n" +"sv_gameplayfix_noairborncorpse 1\n" +"sv_gameplayfix_noairborncorpse_allowsuspendeditems 1\n" +"sv_gameplayfix_easierwaterjump 1\n" +"sv_gameplayfix_delayprojectiles 1\n" +"sv_gameplayfix_multiplethinksperframe 1\n" +"sv_gameplayfix_fixedcheckwatertransition 1\n" +"sv_gameplayfix_q1bsptracelinereportstexture 1\n" +"sv_gameplayfix_swiminbmodels 1\n" +"sv_gameplayfix_downtracesupportsongroundflag 1\n" +"sys_ticrate 0.01388889\n" +"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: + case GAME_VORETOURNAMENT: + // 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 - if (gamemode == GAME_STEELSTORM) - Cbuf_InsertText("\ncl_csqc_generatemousemoveevents 0\n\n"); + case GAME_STEELSTORM: + Cbuf_InsertText(cmd, "\n" +"sv_gameplayfix_blowupfallenzombies 1\n" +"sv_gameplayfix_findradiusdistancetobox 1\n" +"sv_gameplayfix_grenadebouncedownslopes 1\n" +"sv_gameplayfix_slidemoveprojectiles 1\n" +"sv_gameplayfix_upwardvelocityclearsongroundflag 1\n" +"sv_gameplayfix_setmodelrealbox 1\n" +"sv_gameplayfix_droptofloorstartsolid 1\n" +"sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 1\n" +"sv_gameplayfix_noairborncorpse 1\n" +"sv_gameplayfix_noairborncorpse_allowsuspendeditems 1\n" +"sv_gameplayfix_easierwaterjump 1\n" +"sv_gameplayfix_delayprojectiles 1\n" +"sv_gameplayfix_multiplethinksperframe 1\n" +"sv_gameplayfix_fixedcheckwatertransition 1\n" +"sv_gameplayfix_q1bsptracelinereportstexture 1\n" +"sv_gameplayfix_swiminbmodels 1\n" +"sv_gameplayfix_downtracesupportsongroundflag 1\n" +"sys_ticrate 0.01388889\n" +"cl_csqc_generatemousemoveevents 0\n" +"csqc_polygons_defaultmaterial_nocullface 1\n" + ); + break; + default: + Cbuf_InsertText(cmd, "\n" +"sv_gameplayfix_blowupfallenzombies 1\n" +"sv_gameplayfix_findradiusdistancetobox 1\n" +"sv_gameplayfix_grenadebouncedownslopes 1\n" +"sv_gameplayfix_slidemoveprojectiles 1\n" +"sv_gameplayfix_upwardvelocityclearsongroundflag 1\n" +"sv_gameplayfix_setmodelrealbox 1\n" +"sv_gameplayfix_droptofloorstartsolid 1\n" +"sv_gameplayfix_droptofloorstartsolid_nudgetocorrect 1\n" +"sv_gameplayfix_noairborncorpse 1\n" +"sv_gameplayfix_noairborncorpse_allowsuspendeditems 1\n" +"sv_gameplayfix_easierwaterjump 1\n" +"sv_gameplayfix_delayprojectiles 1\n" +"sv_gameplayfix_multiplethinksperframe 1\n" +"sv_gameplayfix_fixedcheckwatertransition 1\n" +"sv_gameplayfix_q1bsptracelinereportstexture 1\n" +"sv_gameplayfix_swiminbmodels 1\n" +"sv_gameplayfix_downtracesupportsongroundflag 1\n" +"sys_ticrate 0.01388889\n" +"csqc_polygons_defaultmaterial_nocullface 0\n" + ); + break; + } } } @@ -523,26 +863,26 @@ static void Cmd_Exec(const char *filename) Cmd_Exec_f =============== */ -static void Cmd_Exec_f (void) +static void Cmd_Exec_f (cmd_state_t *cmd) { fssearch_t *s; int i; - if (Cmd_Argc () != 2) + if (Cmd_Argc(cmd) != 2) { Con_Print("exec : execute a script file\n"); return; } - s = FS_Search(Cmd_Argv(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(1)); + Con_Printf("couldn't exec %s\n",Cmd_Argv(cmd, 1)); return; } for(i = 0; i < s->numfilenames; ++i) - Cmd_Exec(s->filenames[i]); + Cmd_Exec(cmd, s->filenames[i]); FS_FreeSearch(s); } @@ -555,12 +895,12 @@ Cmd_Echo_f Just prints the rest of the line to the console =============== */ -static void Cmd_Echo_f (void) +static void Cmd_Echo_f (cmd_state_t *cmd) { int i; - for (i=1 ; icvars, Cmd_Argv(cmd, 1), cmd->cvars_flagsmask); if(cvCVar != NULL) { // Valid CVar @@ -598,13 +938,13 @@ static void Cmd_Toggle_f(void) else if(nNumArgs == 3) { // 0 and Specified Usage - if(cvCVar->integer == atoi(Cmd_Argv(2) ) ) + if(cvCVar->integer == atoi(Cmd_Argv(cmd, 2) ) ) // CVar is Specified Value; // Reset to 0 Cvar_SetValueQuick(cvCVar, 0); else if(cvCVar->integer == 0) // CVar is 0; Specify Value - Cvar_SetQuick(cvCVar, Cmd_Argv(2) ); + Cvar_SetQuick(cvCVar, Cmd_Argv(cmd, 2) ); else // CVar does not match; Reset to 0 Cvar_SetValueQuick(cvCVar, 0); @@ -616,14 +956,14 @@ static void Cmd_Toggle_f(void) for(nCnt = 2; nCnt < nNumArgs; nCnt++) { // Cycle through Values - if( strcmp(cvCVar->string, Cmd_Argv(nCnt) ) == 0) + if( strcmp(cvCVar->string, Cmd_Argv(cmd, nCnt) ) == 0) { // Current Value Located; Increment to Next if( (nCnt + 1) == nNumArgs) // Max Value Reached; Reset - Cvar_SetQuick(cvCVar, Cmd_Argv(2) ); + Cvar_SetQuick(cvCVar, Cmd_Argv(cmd, 2) ); else // Next Value - Cvar_SetQuick(cvCVar, Cmd_Argv(nCnt + 1) ); + Cvar_SetQuick(cvCVar, Cmd_Argv(cmd, nCnt + 1) ); // End Loop nCnt = nNumArgs; @@ -633,13 +973,13 @@ static void Cmd_Toggle_f(void) } if(!bFound) // Value not Found; Reset to Original - Cvar_SetQuick(cvCVar, Cmd_Argv(2) ); + Cvar_SetQuick(cvCVar, Cmd_Argv(cmd, 2) ); } } else { // Invalid CVar - Con_Printf("ERROR : CVar '%s' not found\n", Cmd_Argv(1) ); + Con_Printf("ERROR : CVar '%s' not found\n", Cmd_Argv(cmd, 1) ); } } } @@ -651,23 +991,23 @@ Cmd_Alias_f Creates a new command that executes a command string (possibly ; seperated) =============== */ -static void Cmd_Alias_f (void) +static void Cmd_Alias_f (cmd_state_t *cmd) { - cmdalias_t *a; - char cmd[MAX_INPUTLINE]; + cmd_alias_t *a; + char line[MAX_INPUTLINE]; int i, c; const char *s; size_t alloclen; - if (Cmd_Argc() == 1) + if (Cmd_Argc(cmd) == 1) { Con_Print("Current alias commands:\n"); - for (a = cmd_alias ; a ; a=a->next) + for (a = cmd->userdefined->alias ; a ; a=a->next) Con_Printf("%s : %s", a->name, a->value); return; } - s = Cmd_Argv(1); + s = Cmd_Argv(cmd, 1); if (strlen(s) >= MAX_ALIAS_NAME) { Con_Print("Alias name is too long\n"); @@ -675,7 +1015,7 @@ static void Cmd_Alias_f (void) } // if the alias already exists, reuse it - for (a = cmd_alias ; a ; a=a->next) + for (a = cmd->userdefined->alias ; a ; a=a->next) { if (!strcmp(s, a->name)) { @@ -686,38 +1026,38 @@ static void Cmd_Alias_f (void) 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_alias ; current && strcmp( current->name, a->name ) < 0 ; prev = current, current = current->next ) + for( prev = NULL, current = cmd->userdefined->alias ; current && strcmp( current->name, a->name ) < 0 ; prev = current, current = current->next ) ; if( prev ) { prev->next = a; } else { - cmd_alias = a; + cmd->userdefined->alias = a; } a->next = current; } // copy the rest of the command line - cmd[0] = 0; // start out with a null string - c = Cmd_Argc(); + line[0] = 0; // start out with a null string + c = Cmd_Argc(cmd); for (i=2 ; i < c ; i++) { if (i != 2) - strlcat (cmd, " ", sizeof (cmd)); - strlcat (cmd, Cmd_Argv(i), sizeof (cmd)); + strlcat (line, " ", sizeof (line)); + strlcat (line, Cmd_Argv(cmd, i), sizeof (line)); } - strlcat (cmd, "\n", sizeof (cmd)); + strlcat (line, "\n", sizeof (line)); - alloclen = strlen (cmd) + 1; + alloclen = strlen (line) + 1; if(alloclen >= 2) - cmd[alloclen - 2] = '\n'; // to make sure a newline is appended even if too long + line[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); + memcpy (a->value, line, alloclen); } /* @@ -727,30 +1067,30 @@ Cmd_UnAlias_f Remove existing aliases. =============== */ -static void Cmd_UnAlias_f (void) +static void Cmd_UnAlias_f (cmd_state_t *cmd) { - cmdalias_t *a, *p; + cmd_alias_t *a, *p; int i; const char *s; - if(Cmd_Argc() == 1) + if(Cmd_Argc(cmd) == 1) { Con_Print("unalias: Usage: unalias alias1 [alias2 ...]\n"); return; } - for(i = 1; i < Cmd_Argc(); ++i) + for(i = 1; i < Cmd_Argc(cmd); ++i) { - s = Cmd_Argv(i); + s = Cmd_Argv(cmd, i); p = NULL; - for(a = cmd_alias; a; p = a, a = a->next) + for(a = cmd->userdefined->alias; a; p = a, a = a->next) { if(!strcmp(s, a->name)) { if (a->initstate) // we can not remove init aliases continue; - if(a == cmd_alias) - cmd_alias = a->next; + if(a == cmd->userdefined->alias) + cmd->userdefined->alias = a->next; if(p) p->next = a->next; Z_Free(a->value); @@ -771,32 +1111,12 @@ static void Cmd_UnAlias_f (void) ============================================================================= */ -typedef struct cmd_function_s -{ - struct cmd_function_s *next; - const char *name; - const char *description; - xcommand_t consolefunction; - xcommand_t clientfunction; - qboolean csqcfunc; - qboolean initstate; // indicates this command existed at init -} cmd_function_t; - -static int cmd_argc; -static const char *cmd_argv[MAX_ARGS]; -static const char *cmd_null_string = ""; -static const char *cmd_args; -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) +static const char *Cmd_GetDirectCvarValue(cmd_state_t *cmd, const char *varname, cmd_alias_t *alias, qbool *is_multiple) { cvar_t *cvar; long argno; char *endptr; - char vabuf[1024]; + static char vabuf[1024]; // cmd_mutex if(is_multiple) *is_multiple = false; @@ -810,11 +1130,11 @@ static const char *Cmd_GetDirectCvarValue(const char *varname, cmdalias_t *alias { if(is_multiple) *is_multiple = true; - return Cmd_Args(); + return Cmd_Args(cmd); } else if(!strcmp(varname, "#")) { - return va(vabuf, sizeof(vabuf), "%d", Cmd_Argc()); + return va(vabuf, sizeof(vabuf), "%d", Cmd_Argc(cmd)); } else if(varname[strlen(varname) - 1] == '-') { @@ -822,7 +1142,7 @@ static const char *Cmd_GetDirectCvarValue(const char *varname, cmdalias_t *alias if(endptr == varname + strlen(varname) - 1) { // whole string is a number, apart from the - - const char *p = Cmd_Args(); + const char *p = Cmd_Args(cmd); for(; argno > 1; --argno) if(!COM_ParseToken_Console(&p)) break; @@ -846,23 +1166,23 @@ static const char *Cmd_GetDirectCvarValue(const char *varname, cmdalias_t *alias { // 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(argno >= 0 && argno < Cmd_Argc(cmd)) + return Cmd_Argv(cmd, argno); } } } - if((cvar = Cvar_FindVar(varname)) && !(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) { @@ -917,14 +1237,14 @@ fail: return false; } -static const char *Cmd_GetCvarValue(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) @@ -943,9 +1263,9 @@ static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t * { // empty cvar name? if(alias) - Con_Printf("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_Printf("Warning: Could not expand $\n"); + Con_Printf(CON_WARN "Warning: Could not expand $\n"); return "$"; } @@ -975,12 +1295,12 @@ static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t * } if(varname[0] == '$') - varstr = Cmd_GetDirectCvarValue(Cmd_GetDirectCvarValue(varname + 1, alias, NULL), alias, NULL); + 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(varname, alias, &is_multiple); + varstr = Cmd_GetDirectCvarValue(cmd, varname, alias, &is_multiple); if(is_multiple) if(!varfunc) varfunc = asis; @@ -991,9 +1311,9 @@ static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t * if(required) { if(alias) - Con_Printf("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_Printf("Error: Could not expand $%s\n", varname); + Con_Printf(CON_ERROR "Error: Could not expand $%s\n", varname); return NULL; } else if(optional) @@ -1003,9 +1323,9 @@ static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t * else { if(alias) - Con_Printf("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_Printf("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; } @@ -1033,7 +1353,7 @@ Cmd_PreprocessString Preprocesses strings and replaces $*, $param#, $cvar accordingly. Also strips comments. */ -static qboolean Cmd_PreprocessString( 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; @@ -1112,7 +1432,7 @@ static qboolean Cmd_PreprocessString( const char *intext, char *outtext, unsigne varlen = strcspn(in + 1, "}"); if(in[varlen + 1] == '}') { - val = Cmd_GetCvarValue(in + 1, varlen, alias); + val = Cmd_GetCvarValue(cmd, in + 1, varlen, alias); if(!val) return false; eat = varlen + 2; @@ -1125,7 +1445,7 @@ static qboolean Cmd_PreprocessString( const char *intext, char *outtext, unsigne } } else { varlen = strspn(in, "#*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-"); - val = Cmd_GetCvarValue(in, varlen, alias); + val = Cmd_GetCvarValue(cmd, in, varlen, alias); if(!val) return false; eat = varlen; @@ -1162,11 +1482,11 @@ Cmd_ExecuteAlias Called for aliases and fills in the alias into the cbuffer ============ */ -static void Cmd_ExecuteAlias (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( 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 @@ -1176,7 +1496,7 @@ static void Cmd_ExecuteAlias (cmdalias_t *alias) // 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, "$", false); - Cbuf_InsertText( buffer2 ); + Cbuf_InsertText(cmd, buffer2); } /* @@ -1188,17 +1508,17 @@ Cmd_List ======== */ -static void Cmd_List_f (void) +static void Cmd_List_f (cmd_state_t *cmd) { - cmd_function_t *cmd; + cmd_function_t *func; const char *partial; size_t len; int count; - qboolean ispattern; + qbool ispattern; - if (Cmd_Argc() > 1) + if (Cmd_Argc(cmd) > 1) { - partial = Cmd_Argv (1); + partial = Cmd_Argv(cmd, 1); len = strlen(partial); ispattern = (strchr(partial, '*') || strchr(partial, '?')); } @@ -1210,11 +1530,18 @@ static void Cmd_List_f (void) } count = 0; - for (cmd = cmd_functions; cmd; cmd = cmd->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) { - if (partial && (ispattern ? !matchpattern_with_separator(cmd->name, partial, false, "", false) : strncmp(partial, cmd->name, len))) + if (partial && (ispattern ? !matchpattern_with_separator(func->name, partial, false, "", false) : strncmp(partial, func->name, len))) continue; - Con_Printf("%s : %s\n", cmd->name, cmd->description); + Con_Printf("%s : %s\n", func->name, func->description); + count++; + } + for (func = cmd->engine_functions; func; func = func->next) + { + if (partial && (ispattern ? !matchpattern_with_separator(func->name, partial, false, "", false) : strncmp(partial, func->name, len))) + continue; + Con_Printf("%s : %s\n", func->name, func->description); count++; } @@ -1229,21 +1556,21 @@ static void Cmd_List_f (void) Con_Printf("%i Command%s\n\n", count, (count > 1) ? "s" : ""); } -static void Cmd_Apropos_f(void) +static void Cmd_Apropos_f(cmd_state_t *cmd) { - cmd_function_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() > 1) - partial = Cmd_Args(); + 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; } @@ -1252,23 +1579,42 @@ static void Cmd_Apropos_f(void) partial = va(vabuf, sizeof(vabuf), "*%s*", partial); count = 0; - for (cvar = cvar_vars; cvar; cvar = cvar->next) + for (cvar = cmd->cvars->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); + 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->qc_functions; func; func = func->next) + { + if (!matchpattern_with_separator(func->name, partial, true, "", false)) + if (!matchpattern_with_separator(func->description, partial, true, "", false)) + continue; + Con_Printf("command ^2%s^7: %s\n", func->name, func->description); count++; } - for (cmd = cmd_functions; cmd; cmd = cmd->next) + for (func = cmd->engine_functions; func; func = func->next) { - if (!matchpattern_with_separator(cmd->name, partial, true, "", false)) - if (!matchpattern_with_separator(cmd->description, partial, true, "", false)) + if (!matchpattern_with_separator(func->name, partial, true, "", false)) + if (!matchpattern_with_separator(func->description, partial, true, "", false)) continue; - Con_Printf("command ^2%s^7: %s\n", cmd->name, cmd->description); + Con_Printf("command ^2%s^7: %s\n", func->name, func->description); count++; } - for (alias = cmd_alias; alias; alias = alias->next) + for (alias = cmd->userdefined->alias; alias; alias = alias->next) { // procede here a bit differently as an alias value always got a final \n if (!matchpattern_with_separator(alias->name, partial, true, "", false)) @@ -1280,59 +1626,95 @@ static void Cmd_Apropos_f(void) Con_Printf("%i result%s\n\n", count, (count > 1) ? "s" : ""); } -/* -============ -Cmd_Init -============ -*/ -void Cmd_Init (void) +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_mempool = Mem_AllocPool("commands", 0, NULL); + 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_text.data = cmd_text_buf; - cmd_text.maxsize = sizeof(cmd_text_buf); - cmd_text.cursize = 0; + cmd->cbuf = cbuf; + cmd->null_string = ""; + + cmd->cvars = cvars; + cmd->cvars_flagsmask = cvars_flagsmask; + cmd->cmd_flags = cmds_flagsmask; + cmd->userdefined = userdefined; - if (Thread_HasThreads()) - cmd_text_mutex = Thread_CreateMutex(); + return cmd; } -void Cmd_Init_Commands (void) +/* +============ +Cmd_Init +============ +*/ +void Cmd_Init(void) { + 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_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; + + cmd_iter_all[2].cmd = NULL; // // register our commands // - 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 $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)"); + // client-only commands + 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(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(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 ("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 ("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(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 ("cprint", Cmd_Centerprint_f, "print something at the screen center"); - Cmd_AddCommand ("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( "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)"); } /* @@ -1342,15 +1724,19 @@ Cmd_Shutdown */ void Cmd_Shutdown(void) { - if (cmd_text_mutex) + cmd_iter_t *cmd_iter; + for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++) { - // we usually have this locked when we get here from Host_Quit_f - Cbuf_UnlockThreadMutex(); - Thread_DestroyMutex(cmd_text_mutex); - } - cmd_text_mutex = NULL; + cmd_state_t *cmd = cmd_iter->cmd; + + if (cmd->cbuf->lock) + { + // we usually have this locked when we get here from Host_Quit_f + Cbuf_Unlock(cmd->cbuf); + } - Mem_FreePool(&cmd_mempool); + Mem_FreePool(&cmd->mempool); + } } /* @@ -1358,9 +1744,9 @@ void Cmd_Shutdown(void) Cmd_Argc ============ */ -int Cmd_Argc (void) +int Cmd_Argc (cmd_state_t *cmd) { - return cmd_argc; + return cmd->argc; } /* @@ -1368,11 +1754,11 @@ int Cmd_Argc (void) Cmd_Argv ============ */ -const char *Cmd_Argv (int arg) +const char *Cmd_Argv(cmd_state_t *cmd, int arg) { - if (arg >= cmd_argc ) - return cmd_null_string; - return cmd_argv[arg]; + if (arg >= cmd->argc ) + return cmd->null_string; + return cmd->argv[arg]; } /* @@ -1380,12 +1766,11 @@ const char *Cmd_Argv (int arg) Cmd_Args ============ */ -const char *Cmd_Args (void) +const char *Cmd_Args (cmd_state_t *cmd) { - return cmd_args; + return cmd->args; } - /* ============ Cmd_TokenizeString @@ -1394,12 +1779,13 @@ Parses the given string into command line tokens. ============ */ // AK: This function should only be called from ExcuteString because the current design is a bit of an hack -static void Cmd_TokenizeString (const char *text) +static void Cmd_TokenizeString (cmd_state_t *cmd, const char *text) { int l; - cmd_argc = 0; - cmd_args = NULL; + cmd->argc = 0; + cmd->args = NULL; + cmd->cmdline = NULL; while (1) { @@ -1423,24 +1809,26 @@ static void Cmd_TokenizeString (const char *text) if (!*text) return; - if (cmd_argc == 1) - cmd_args = text; + if(!cmd->argc) + cmd->cmdline = text; + if (cmd->argc == 1) + cmd->args = text; if (!COM_ParseToken_Console(&text)) return; - if (cmd_argc < MAX_ARGS) + 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; - cmd_argc++; + 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++; } } } @@ -1451,59 +1839,89 @@ static void Cmd_TokenizeString (const char *text) Cmd_AddCommand ============ */ -void Cmd_AddCommand_WithClientCommand (const char *cmd_name, xcommand_t consolefunction, xcommand_t clientfunction, const char *description) +void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const char *description) { - cmd_function_t *cmd; + 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_name )) - { - Con_Printf("Cmd_AddCommand: %s already defined as a var\n", cmd_name); - return; - } - -// fail if the command already exists - for (cmd=cmd_functions ; cmd ; cmd=cmd->next) + for (i = 0; i < 2; i++) { - if (!strcmp (cmd_name, cmd->name)) + cmd = cmd_iter_all[i].cmd; + if (flags & cmd->cmd_flags) { - if (consolefunction || clientfunction) + // 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; } - else //[515]: csqc + + if (function) { - cmd->csqcfunc = true; - 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; + } + } - cmd = (cmd_function_t *)Mem_Alloc(cmd_mempool, sizeof(cmd_function_t)); - cmd->name = cmd_name; - cmd->consolefunction = consolefunction; - cmd->clientfunction = clientfunction; - cmd->description = description; - if(!consolefunction && !clientfunction) //[515]: csqc - cmd->csqcfunc = true; - cmd->next = cmd_functions; - -// insert it at the right alphanumeric position - for( prev = NULL, current = cmd_functions ; current && strcmp( current->name, cmd->name ) < 0 ; prev = current, current = current->next ) - ; - if( prev ) { - prev->next = cmd; - } else { - cmd_functions = cmd; - } - cmd->next = current; -} -void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *description) -{ - Cmd_AddCommand_WithClientCommand (cmd_name, function, NULL, description); + 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->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; + } + } + } } /* @@ -1511,12 +1929,16 @@ void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *desc Cmd_Exists ============ */ -qboolean Cmd_Exists (const char *cmd_name) +qbool Cmd_Exists (cmd_state_t *cmd, const char *cmd_name) { - cmd_function_t *cmd; + cmd_function_t *func; + + for (func = cmd->userdefined->qc_functions; func; func = func->next) + if (!strcmp(cmd_name, func->name)) + return true; - for (cmd=cmd_functions ; cmd ; cmd=cmd->next) - if (!strcmp (cmd_name,cmd->name)) + for (func=cmd->engine_functions ; func ; func=func->next) + if (!strcmp (cmd_name,func->name)) return true; return false; @@ -1528,9 +1950,9 @@ qboolean Cmd_Exists (const char *cmd_name) Cmd_CompleteCommand ============ */ -const char *Cmd_CompleteCommand (const char *partial) +const char *Cmd_CompleteCommand (cmd_state_t *cmd, const char *partial) { - cmd_function_t *cmd; + cmd_function_t *func; size_t len; len = strlen(partial); @@ -1539,9 +1961,13 @@ const char *Cmd_CompleteCommand (const char *partial) return NULL; // check functions - for (cmd = cmd_functions; cmd; cmd = cmd->next) - if (!strncasecmp(partial, cmd->name, len)) - return cmd->name; + for (func = cmd->userdefined->qc_functions; func; func = func->next) + if (!strncasecmp(partial, func->name, len)) + return func->name; + + for (func = cmd->engine_functions; func; func = func->next) + if (!strncasecmp(partial, func->name, len)) + return func->name; return NULL; } @@ -1555,9 +1981,9 @@ const char *Cmd_CompleteCommand (const char *partial) Thanks to taniwha */ -int Cmd_CompleteCountPossible (const char *partial) +int Cmd_CompleteCountPossible (cmd_state_t *cmd, const char *partial) { - cmd_function_t *cmd; + cmd_function_t *func; size_t len; int h; @@ -1568,8 +1994,12 @@ int Cmd_CompleteCountPossible (const char *partial) return 0; // Loop through the command list and count all partial matches - for (cmd = cmd_functions; cmd; cmd = cmd->next) - if (!strncasecmp(partial, cmd->name, len)) + for (func = cmd->userdefined->qc_functions; func; func = func->next) + if (!strncasecmp(partial, func->name, len)) + h++; + + for (func = cmd->engine_functions; func; func = func->next) + if (!strncasecmp(partial, func->name, len)) h++; return h; @@ -1584,34 +2014,40 @@ int Cmd_CompleteCountPossible (const char *partial) Thanks to taniwha */ -const char **Cmd_CompleteBuildList (const char *partial) +const char **Cmd_CompleteBuildList (cmd_state_t *cmd, const char *partial) { - cmd_function_t *cmd; + cmd_function_t *func; size_t len = 0; size_t bpos = 0; - size_t sizeofbuf = (Cmd_CompleteCountPossible (partial) + 1) * sizeof (const char *); + size_t sizeofbuf = (Cmd_CompleteCountPossible (cmd, partial) + 1) * sizeof (const char *); const char **buf; len = strlen(partial); buf = (const char **)Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *)); - // Loop through the alias list and print all matches - for (cmd = cmd_functions; cmd; cmd = cmd->next) - if (!strncasecmp(partial, cmd->name, len)) - buf[bpos++] = cmd->name; + // Loop through the functions lists and print all matches + 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) + if (!strncasecmp(partial, func->name, len)) + buf[bpos++] = func->name; buf[bpos] = NULL; return buf; } -// written by LordHavoc -void Cmd_CompleteCommandPrint (const char *partial) +// written by LadyHavoc +void Cmd_CompleteCommandPrint (cmd_state_t *cmd, const char *partial) { - cmd_function_t *cmd; + cmd_function_t *func; size_t len = strlen(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("^2%s^7: %s\n", cmd->name, cmd->description); + 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) + if (!strncasecmp(partial, func->name, len)) + Con_Printf("^2%s^7: %s\n", func->name, func->description); } /* @@ -1623,9 +2059,9 @@ void Cmd_CompleteCommandPrint (const char *partial) Thanks to taniwha */ -const char *Cmd_CompleteAlias (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); @@ -1634,20 +2070,20 @@ const char *Cmd_CompleteAlias (const char *partial) return NULL; // Check functions - for (alias = cmd_alias; alias; alias = alias->next) + for (alias = cmd->userdefined->alias; alias; alias = alias->next) if (!strncasecmp(partial, alias->name, len)) return alias->name; return NULL; } -// written by LordHavoc -void Cmd_CompleteAliasPrint (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_alias; alias; alias = alias->next) + for (alias = cmd->userdefined->alias; alias; alias = alias->next) if (!strncasecmp(partial, alias->name, len)) Con_Printf("^5%s^7: %s", alias->name, alias->value); } @@ -1662,9 +2098,9 @@ void Cmd_CompleteAliasPrint (const char *partial) Thanks to taniwha */ -int Cmd_CompleteAliasCountPossible (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; @@ -1676,7 +2112,7 @@ int Cmd_CompleteAliasCountPossible (const char *partial) return 0; // Loop through the command list and count all partial matches - for (alias = cmd_alias; alias; alias = alias->next) + for (alias = cmd->userdefined->alias; alias; alias = alias->next) if (!strncasecmp(partial, alias->name, len)) h++; @@ -1692,18 +2128,18 @@ int Cmd_CompleteAliasCountPossible (const char *partial) Thanks to taniwha */ -const char **Cmd_CompleteAliasBuildList (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 (partial) + 1) * sizeof (const char *); + size_t sizeofbuf = (Cmd_CompleteAliasCountPossible (cmd, partial) + 1) * sizeof (const char *); const char **buf; len = strlen(partial); buf = (const char **)Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *)); // Loop through the alias list and print all matches - for (alias = cmd_alias; alias; alias = alias->next) + for (alias = cmd->userdefined->alias; alias; alias = alias->next) if (!strncasecmp(partial, alias->name, len)) buf[bpos++] = alias->name; @@ -1711,13 +2147,92 @@ const char **Cmd_CompleteAliasBuildList (const char *partial) return buf; } -void Cmd_ClearCsqcFuncs (void) +// TODO: Make this more generic? +void Cmd_ClearCSQCCommands (cmd_state_t *cmd) +{ + cmd_function_t *func; + cmd_function_t **next = &cmd->userdefined->qc_functions; + + while(*next) + { + func = *next; + *next = func->next; + Z_Free(func); + } +} + +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) { - cmd_function_t *cmd; - for (cmd=cmd_functions ; cmd ; cmd=cmd->next) - cmd->csqcfunc = false; + // 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 @@ -1726,246 +2241,67 @@ A complete command line has been parsed, so try to execute it FIXME: lookupnoadd the token to speed search? ============ */ -void Cmd_ExecuteString (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; - int found; - cmd_function_t *cmd; - cmdalias_t *a; - - oldpos = cmd_tokenizebufferpos; - cmd_source = src; - found = false; + cmd_function_t *func; + cmd_alias_t *a; + if (lockmutex) + Cbuf_Lock(cmd->cbuf); + oldpos = cmd->cbuf->tokenizebufferpos; + cmd->source = src; - Cmd_TokenizeString (text); + Cmd_TokenizeString (cmd, text); // execute the command line - if (!Cmd_Argc()) + if (!Cmd_Argc(cmd)) goto done; // no tokens // check functions - for (cmd=cmd_functions ; cmd ; cmd=cmd->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) { - if (!strcasecmp (cmd_argv[0],cmd->name)) + if (!strcasecmp(cmd->argv[0], func->name)) { - if (cmd->csqcfunc && CL_VM_ConsoleCommand (text)) //[515]: csqc + if(cmd->Handle(cmd, func, text, src)) goto done; - 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 - 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 (); - goto done; - } - break; - } - break; } } -command_found: - // if it's a client command and no command was found, say so. - if (cmd_source == src_client) + for (func = cmd->engine_functions; func; func=func->next) { - Con_Printf("player \"%s\" tried to %s\n", host_client->name, text); - goto done; - } - -// check alias - for (a=cmd_alias ; a ; a=a->next) - { - if (!strcasecmp (cmd_argv[0], a->name)) + if (!strcasecmp (cmd->argv[0], func->name)) { - Cmd_ExecuteAlias(a); - goto done; + if(cmd->Handle(cmd, func, text, src)) + goto done; } } - if(found) // if the command was hooked and found, all is good - goto done; - -// check cvars - if (!Cvar_Command () && host_framecount > 0) - Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(0)); - -done: - cmd_tokenizebufferpos = oldpos; -} - - -/* -=================== -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) + // if it's a client command and no command was found, say so. + if(cmd->NotFound) { - Con_Printf("Can't \"%s\", not connected\n", s); - return; + if(cmd->NotFound(cmd, func, text, src)) + goto done; } - if (!cls.netcon) - return; - - // LordHavoc: 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) +// check alias + for (a=cmd->userdefined->alias ; a ; a=a->next) { - // say/say_team commands can replace % character codes with status info - while (*s) + if (!strcasecmp (cmd->argv[0], a->name)) { - 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++; + Cmd_ExecuteAlias(cmd, a); + goto done; } - 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 (void) -{ - const char *s; - char vabuf[1024]; - if (!strcasecmp(Cmd_Argv(0), "cmd")) - { - // we want to strip off "cmd", so just send the args - s = Cmd_Argc() > 1 ? Cmd_Args() : ""; - } - else - { - // we need to keep the command name, so send Cmd_Argv(0), a space and then Cmd_Args() - s = va(vabuf, sizeof(vabuf), "%s %s", Cmd_Argv(0), Cmd_Argc() > 1 ? Cmd_Args() : ""); - } - // don't send an empty forward message if the user tries "cmd" by itself - if (!s || !*s) - return; - Cmd_ForwardStringToServer(s); +// check cvars + if (!Cvar_Command(cmd) && host.framecount > 0) + Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(cmd, 0)); +done: + cmd->cbuf->tokenizebufferpos = oldpos; + if (lockmutex) + Cbuf_Unlock(cmd->cbuf); } - /* ================ Cmd_CheckParm @@ -1975,7 +2311,7 @@ where the given parameter apears, or 0 if not present ================ */ -int Cmd_CheckParm (const char *parm) +int Cmd_CheckParm (cmd_state_t *cmd, const char *parm) { int i; @@ -1985,8 +2321,8 @@ int Cmd_CheckParm (const char *parm) return 0; } - for (i = 1; i < Cmd_Argc (); i++) - if (!strcasecmp (parm, Cmd_Argv (i))) + for (i = 1; i < Cmd_Argc (cmd); i++) + if (!strcasecmp (parm, Cmd_Argv(cmd, i))) return i; return 0; @@ -1996,57 +2332,85 @@ int Cmd_CheckParm (const char *parm) void Cmd_SaveInitState(void) { - cmd_function_t *f; - cmdalias_t *a; - for (f = cmd_functions;f;f = f->next) - f->initstate = true; - for (a = cmd_alias;a;a = a->next) + cmd_iter_t *cmd_iter; + for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++) { - a->initstate = true; - a->initialvalue = Mem_strdup(zonemempool, a->value); + cmd_state_t *cmd = cmd_iter->cmd; + cmd_function_t *f; + 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; + for (a = cmd->userdefined->alias; a; a = a->next) + { + a->initstate = true; + a->initialvalue = Mem_strdup(zonemempool, a->value); + } } - Cvar_SaveInitState(); + Cvar_SaveInitState(&cvars_all); } void Cmd_RestoreInitState(void) { - cmd_function_t *f, **fp; - cmdalias_t *a, **ap; - for (fp = &cmd_functions;(f = *fp);) + cmd_iter_t *cmd_iter; + for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++) { - if (f->initstate) - fp = &f->next; - else + cmd_state_t *cmd = cmd_iter->cmd; + cmd_function_t *f, **fp; + cmd_alias_t *a, **ap; + for (fp = &cmd->userdefined->qc_functions; (f = *fp);) { - // destroy this command, it didn't exist at init - Con_DPrintf("Cmd_RestoreInitState: Destroying command %s\n", f->name); - *fp = f->next; - Z_Free(f); + if (f->initstate) + fp = &f->next; + else + { + // destroy this command, it didn't exist at init + Con_DPrintf("Cmd_RestoreInitState: Destroying command %s\n", f->name); + *fp = f->next; + Z_Free(f); + } } - } - for (ap = &cmd_alias;(a = *ap);) - { - if (a->initstate) + for (fp = &cmd->engine_functions; (f = *fp);) { - // restore this alias, it existed at init - if (strcmp(a->value ? a->value : "", a->initialvalue ? a->initialvalue : "")) + if (f->initstate) + fp = &f->next; + else { - Con_DPrintf("Cmd_RestoreInitState: Restoring alias %s\n", a->name); - if (a->value) - Z_Free(a->value); - a->value = Mem_strdup(zonemempool, a->initialvalue); + // destroy this command, it didn't exist at init + Con_DPrintf("Cmd_RestoreInitState: Destroying command %s\n", f->name); + *fp = f->next; + Z_Free(f); } - ap = &a->next; } - else + for (ap = &cmd->userdefined->alias; (a = *ap);) { - // free this alias, it didn't exist at init... - Con_DPrintf("Cmd_RestoreInitState: Destroying alias %s\n", a->name); - *ap = a->next; - if (a->value) - Z_Free(a->value); - Z_Free(a); + if (a->initstate) + { + // restore this alias, it existed at init + if (strcmp(a->value ? a->value : "", a->initialvalue ? a->initialvalue : "")) + { + Con_DPrintf("Cmd_RestoreInitState: Restoring alias %s\n", a->name); + if (a->value) + Z_Free(a->value); + a->value = Mem_strdup(zonemempool, a->initialvalue); + } + ap = &a->next; + } + else + { + // free this alias, it didn't exist at init... + Con_DPrintf("Cmd_RestoreInitState: Destroying alias %s\n", a->name); + *ap = a->next; + if (a->value) + Z_Free(a->value); + Z_Free(a); + } } } - Cvar_RestoreInitState(); + Cvar_RestoreInitState(&cvars_all); +} + +void Cmd_NoOperation_f(cmd_state_t *cmd) +{ }