X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=cmd.c;h=6230fa021854d31fd72fb6535b664e3ddd196446;hb=aa1c1c80669d14260da64518ca05abc4529354d5;hp=eca5bf3d2bbf788e3ec7cd85eea0751f56c6d6ea;hpb=7c656ac03a03a5fa910f9cad3c4735ed62f7ab69;p=xonotic%2Fdarkplaces.git diff --git a/cmd.c b/cmd.c index eca5bf3d..6230fa02 100644 --- a/cmd.c +++ b/cmd.c @@ -22,9 +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_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; @@ -34,12 +33,7 @@ typedef struct cmd_iter_s { } cmd_iter_t; -static cmd_iter_t cmd_iter_all[] = { - {&cmd_client}, - {&cmd_server}, - {&cmd_serverfromclient}, - {NULL}, -}; +static cmd_iter_t *cmd_iter_all; mempool_t *cbuf_mempool; @@ -80,48 +74,40 @@ 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 Cbuf_ParseText(cmd_state_t *cmd, llist_t *head, cmd_input_t *existing, const char *text, qbool allowpending); +static void Cbuf_LinkString(cmd_state_t *cmd, llist_t *head, cmd_input_t *existing, const char *text, qbool leavepending, unsigned int cmdsize); static void Cmd_Defer_f (cmd_state_t *cmd) { cmd_input_t *current; cmd_buf_t *cbuf = cmd->cbuf; + unsigned int cmdsize; if(Cmd_Argc(cmd) == 1) { - if(List_IsEmpty(&cbuf->deferred)) + if(List_Is_Empty(&cbuf->deferred)) Con_Printf("No commands are pending.\n"); else { - llist_t *pos; - List_ForEach(pos, &cbuf->deferred) - { - current = List_Container(*pos, cmd_input_t, list); + 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))) { - while(!List_IsEmpty(&cbuf->deferred)) + while(!List_Is_Empty(&cbuf->deferred)) + { + cbuf->size -= List_Entry(cbuf->deferred.next, cmd_input_t, list)->length; List_Move_Tail(cbuf->deferred.next, &cbuf->free); + } } - else if(Cmd_Argc(cmd) == 3) + else if(Cmd_Argc(cmd) == 3 && (cmdsize = strlen(Cmd_Argv(cmd, 2))) ) { - 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) - { - current->text = (char *)Mem_Realloc(cbuf_mempool, current->text, current->length + 1); - current->size = current->length; - } + Cbuf_Lock(cbuf); - strlcpy(current->text, text, current->length + 1); + Cbuf_LinkString(cmd, &cbuf->deferred, NULL, Cmd_Argv(cmd, 2), false, cmdsize); + List_Entry(cbuf->deferred.prev, cmd_input_t, list)->delay = atof(Cmd_Argv(cmd, 1)); - List_Move_Tail(¤t->list, &cbuf->deferred); + Cbuf_Unlock(cbuf); } else { @@ -179,169 +165,135 @@ static void Cmd_Centerprint_f (cmd_state_t *cmd) COMMAND BUFFER + * 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. + ============================================================================= */ -static cmd_input_t *Cbuf_LinkGet(cmd_buf_t *cbuf, cmd_input_t *existing) +/* +============ +Cbuf_NodeGet + +Returns an existing buffer node for appending or reuse, or allocates a new one +============ +*/ +static cmd_input_t *Cbuf_NodeGet(cmd_buf_t *cbuf, cmd_input_t *existing) { - cmd_input_t *ret = NULL; + cmd_input_t *node; if(existing && existing->pending) - ret = existing; - else if(!List_IsEmpty(&cbuf->free)) + node = existing; + else if(!List_Is_Empty(&cbuf->free)) { - ret = List_Container(*cbuf->free.next, cmd_input_t, list); - ret->length = 0; - ret->pending = false; + node = List_Entry(cbuf->free.next, cmd_input_t, list); + node->length = node->pending = 0; + } + else + { + 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 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; } -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++; - } +/* +============ +Cbuf_LinkString - 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; +Copies a command string into a buffer node +============ +*/ +static void Cbuf_LinkString(cmd_state_t *cmd, llist_t *head, cmd_input_t *existing, const char *text, qbool leavepending, unsigned int cmdsize) +{ + cmd_buf_t *cbuf = cmd->cbuf; + cmd_input_t *node = Cbuf_NodeGet(cbuf, existing); + unsigned int offset = node->length; // > 0 if(pending) - if(command && lookahead) - break; + // node will match existing if its text was pending continuation + if(node != existing) + { + node->source = cmd; + List_Move_Tail(&node->list, head); } - if(cmdsize) + node->length += cmdsize; + if(node->size < node->length) { - size_t offset = 0; - - if(!*output) - *output = Cmd_AllocInputNode(); - - 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); - (*output)->pending = !lookahead; + node->text = (char *)Mem_Realloc(cbuf_mempool, node->text, node->length + 1); + node->size = node->length; } + cbuf->size += cmdsize; - // Set input to its new position. Can be NULL. - *input = &(*input)[pos]; - - return cmdsize; + strlcpy(&node->text[offset], text, cmdsize + 1); // always sets the last char to \0 + //Con_Printf("^5Cbuf_LinkString(): %s `^7%s^5`\n", node->pending ? "append" : "new", &node->text[offset]); + node->pending = leavepending; } -// 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) +/* +============ +Cbuf_ParseText + +Parses text to isolate command strings for linking into the buffer +separators: \n \r or unquoted and uncommented ';' +============ +*/ +static void Cbuf_ParseText(cmd_state_t *cmd, llist_t *head, cmd_input_t *existing, const char *text, qbool allowpending) { - char *in = (char *)&text[0]; - cmd_buf_t *cbuf = cmd->cbuf; - size_t totalsize = 0, newsize = 0; - cmd_input_t *current = NULL; + unsigned int cmdsize = 0, start = 0, pos; + qbool quotes = false, comment = false; - // Slide the pointer down until we reach the end - while(*in) + for (pos = 0; text[pos]; ++pos) { - current = Cbuf_LinkGet(cbuf, existing); - newsize = Cmd_ParseInput(¤t, &in); - - // Valid command - if(newsize) + switch(text[pos]) { - if(current != existing) - { - current->source = cmd; - List_Move_Tail(¤t->list, head); - } + case ';': + if (comment || quotes) + break; + case '\r': + case '\n': + comment = false; + quotes = false; // matches div0-stable + if (cmdsize) + { + Cbuf_LinkString(cmd, head, existing, &text[start], false, cmdsize); + cmdsize = 0; + } + else if (existing && existing->pending) // all I got was this lousy \n + existing->pending = false; + continue; // don't increment cmdsize - totalsize += newsize; + case '/': + if (!quotes && text[pos + 1] == '/' && (pos == 0 || ISWHITESPACE(text[pos - 1]))) + comment = true; + break; + case '"': + if (!comment && (pos == 0 || text[pos - 1] != '\\')) + quotes = !quotes; + break; + } + + if (!comment) + { + if (!cmdsize) + start = pos; + ++cmdsize; } - else if (current == existing && !totalsize) - current->pending = false; - current = NULL; } - cbuf->size += totalsize; + if (cmdsize) // the line didn't end yet but we do have a string + Cbuf_LinkString(cmd, head, existing, &text[start], allowpending, cmdsize); } /* @@ -363,9 +315,9 @@ void Cbuf_AddText (cmd_state_t *cmd, const char *text) Con_Print("Cbuf_AddText: overflow\n"); else { - Cbuf_LinkCreate(cmd, &llist, (List_IsEmpty(&cbuf->start) ? NULL : List_Container(*cbuf->start.prev, cmd_input_t, list)), text); - if(!List_IsEmpty(&llist)) - List_Splice_Tail(&llist, &cbuf->start); + // If the string terminates but the (last) line doesn't, the node will be left in the pending state (to be continued). + Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.prev, cmd_input_t, list)), text, true); + List_Splice_Tail(&llist, &cbuf->start); } Cbuf_Unlock(cbuf); } @@ -375,7 +327,6 @@ void Cbuf_AddText (cmd_state_t *cmd, const char *text) Cbuf_InsertText Adds command text immediately after the current command -FIXME: actually change the command buffer to do less copying ============ */ void Cbuf_InsertText (cmd_state_t *cmd, const char *text) @@ -386,14 +337,15 @@ void Cbuf_InsertText (cmd_state_t *cmd, const char *text) Cbuf_Lock(cbuf); - // we need to memmove the existing text and stuff this in before it... if (cbuf->size + l >= cbuf->maxsize) Con_Print("Cbuf_InsertText: overflow\n"); else { - Cbuf_LinkCreate(cmd, &llist, List_Container(*cbuf->start.next, cmd_input_t, list), text); - if(!List_IsEmpty(&llist)) - List_Splice(&llist, &cbuf->start); + // bones_was_here assertion: when prepending to the buffer it never makes sense to leave node(s) in the `pending` state, + // it would have been impossible to append to such text later in the old raw text buffer, + // and allowing it causes bugs when .cfg files lack \n at EOF (see: https://gitlab.com/xonotic/darkplaces/-/issues/378). + Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.next, cmd_input_t, list)), text, false); + List_Splice(&llist, &cbuf->start); } Cbuf_Unlock(cbuf); @@ -406,27 +358,25 @@ Cbuf_Execute_Deferred --blub */ static void Cbuf_Execute_Deferred (cmd_buf_t *cbuf) { - llist_t *pos; - cmd_input_t *current; - double eat; + cmd_input_t *current, *n; + vec_t eat; 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)) + if (eat < 1/128) return; cbuf->deferred_oldtime = host.realtime; - List_ForEach(pos, &cbuf->deferred) + List_For_Each_Entry_Safe(current, n, &cbuf->deferred, cmd_input_t, list) { - current = List_Container(*pos, cmd_input_t, list); current->delay -= eat; if(current->delay <= 0) { - cbuf->size += current->length; - List_Move(pos, &cbuf->start); - // We must return and come back next frame or the engine will freeze. Fragile... like glass :3 - return; + Cbuf_AddText(current->source, current->text); // parse deferred string and append its cmdstring(s) + List_Entry(cbuf->start.prev, cmd_input_t, list)->pending = false; // faster than div0-stable's Cbuf_AddText(";\n"); + List_Move_Tail(¤t->list, &cbuf->free); // make deferred string memory available for reuse + cbuf->size -= current->length; } } } @@ -436,24 +386,26 @@ static void Cbuf_Execute_Deferred (cmd_buf_t *cbuf) Cbuf_Execute ============ */ +extern qbool prvm_runawaycheck; 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) { cmd_input_t *current; char preprocessed[MAX_INPUTLINE]; char *firstchar; + unsigned int i = 0; // LadyHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes cbuf->tokenizebufferpos = 0; - while (!List_IsEmpty(&cbuf->start)) + while (!List_Is_Empty(&cbuf->start)) { /* * 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_Container(*cbuf->start.next, cmd_input_t, list); + 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); @@ -493,11 +445,42 @@ void Cbuf_Execute (cmd_buf_t *cbuf) cbuf->wait = false; break; } + + if (++i == 1000000 && prvm_runawaycheck) + { + Con_Printf(CON_WARN "Cbuf_Execute: runaway loop counter hit limit of %d commands, clearing command buffers!\n", i); + while (!List_Is_Empty(&cbuf->start)) + List_Move_Tail(cbuf->start.next, &cbuf->free); + while (!List_Is_Empty(&cbuf->deferred)) + List_Move_Tail(cbuf->deferred.next, &cbuf->free); + cbuf->size = 0; + } } } +/* +=================== +Cbuf_Frame_Input + +Add them exactly as if they had been typed at the console +=================== +*/ +static void Cbuf_Frame_Input(void) +{ + 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) { @@ -505,6 +488,8 @@ void Cbuf_Frame(cmd_buf_t *cbuf) Cbuf_Execute(cbuf); SV_UnlockThreadMutex(); } + +// R_TimeReport("console"); } /* @@ -780,6 +765,7 @@ static void Cmd_Exec(cmd_state_t *cmd, const char *filename) "csqc_polygons_defaultmaterial_nocullface 1\n" "con_chatsound_team_mask 13\n" "sv_gameplayfix_customstats 1\n" +"mod_q1bsp_zero_hullsize_cutoff 8.03125\n" ); break; // Steel Storm: Burning Retribution csqc misinterprets CSQC_InputEvent if type is a value other than 0 or 1 @@ -1564,12 +1550,12 @@ static void Cmd_Apropos_f(cmd_state_t *cmd) Cvar_PrintHelp(cvar, cvar->name, true); count++; } - for (int i = 0; i < cvar->aliasindex; i++) + for (char **cvar_alias = cvar->aliases; cvar_alias && *cvar_alias; cvar_alias++) { - if (matchpattern_with_separator(cvar->aliases[i], partial, true, "", false)) + if (matchpattern_with_separator(*cvar_alias, partial, true, "", false)) { Con_Printf ("cvar "); - Cvar_PrintHelp(cvar, cvar->aliases[i], true); + Cvar_PrintHelp(cvar, *cvar_alias, true); count++; } } @@ -1602,6 +1588,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 @@ -1609,11 +1612,10 @@ Cmd_Init */ void Cmd_Init(void) { - cmd_iter_t *cmd_iter; 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->maxsize = CMDBUFSIZE; cbuf->lock = Thread_CreateMutex(); cbuf->wait = false; host.cbuf = cbuf; @@ -1622,36 +1624,20 @@ void Cmd_Init(void) cbuf->deferred.prev = cbuf->deferred.next = &(cbuf->deferred); cbuf->free.prev = cbuf->free.next = &(cbuf->free); - 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->cbuf = cbuf; - 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 = CF_CLIENT | CF_SERVER; - cmd_client.cmd_flags = CF_CLIENT | CF_CLIENT_FROM_SERVER; - cmd_client.auto_flags = CF_SERVER_FROM_CLIENT; - cmd_client.auto_function = CL_ForwardToServer_f; // FIXME: Move this to the client. - cmd_client.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 = CF_SERVER; - cmd_server.cmd_flags = CF_SERVER; - cmd_server.auto_flags = 0; - cmd_server.auto_function = NULL; - cmd_server.userdefined = &cmd_userdefined_all; + // 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.cmd_flags = CF_SERVER_FROM_CLIENT | CF_USERINFO; - cmd_serverfromclient.auto_flags = 0; - cmd_serverfromclient.auto_function = NULL; - 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; + cmd_iter_all[2].cmd = NULL; // // register our commands // @@ -1720,7 +1706,7 @@ void Cmd_Shutdown(void) Cmd_Argc ============ */ -int Cmd_Argc (cmd_state_t *cmd) +inline int Cmd_Argc (cmd_state_t *cmd) { return cmd->argc; } @@ -1730,7 +1716,7 @@ int Cmd_Argc (cmd_state_t *cmd) Cmd_Argv ============ */ -const char *Cmd_Argv(cmd_state_t *cmd, int arg) +inline const char *Cmd_Argv(cmd_state_t *cmd, int arg) { if (arg >= cmd->argc ) return cmd->null_string; @@ -1742,7 +1728,7 @@ const char *Cmd_Argv(cmd_state_t *cmd, int arg) Cmd_Args ============ */ -const char *Cmd_Args (cmd_state_t *cmd) +inline const char *Cmd_Args (cmd_state_t *cmd) { return cmd->args; } @@ -1761,6 +1747,7 @@ static void Cmd_TokenizeString (cmd_state_t *cmd, const char *text) cmd->argc = 0; cmd->args = NULL; + cmd->cmdline = NULL; while (1) { @@ -1784,6 +1771,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; @@ -1817,22 +1806,13 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const cmd_function_t *func; cmd_function_t *prev, *current; cmd_state_t *cmd; - xcommand_t save = NULL; - qbool auto_add = false; int i; - for (i = 0; i < 3; i++) + for (i = 0; i < 2; i++) { cmd = cmd_iter_all[i].cmd; - if ((flags & cmd->cmd_flags) || (flags & cmd->auto_flags)) + if (flags & cmd->cmd_flags) { - if((flags & cmd->auto_flags) && cmd->auto_function) - { - save = function; - function = cmd->auto_function; - auto_add = true; - } - // fail if the command is a variable name if (Cvar_FindVar(cmd->cvars, cmd_name, ~0)) { @@ -1847,10 +1827,8 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const { if (!strcmp(cmd_name, func->name)) { - if(func->autofunc && !auto_add) - break; Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name); - goto next; + continue; } } @@ -1860,7 +1838,6 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const func->function = function; func->description = description; func->next = cmd->engine_functions; - func->autofunc = auto_add; // 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) @@ -1885,14 +1862,25 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const } } - 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; - func->autofunc = false; + + // bones_was_here: if this QC command overrides an engine command, store its pointer + // to avoid doing this search at invocation if QC declines to handle this command. + for (cmd_function_t *f = cmd->engine_functions; f; f = f->next) + { + if (!strcmp(cmd_name, f->name)) + { + Con_DPrintf("Adding QC override of engine command %s\n", cmd_name); + func->overridden = f; + break; + } + } // 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) @@ -1905,12 +1893,7 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const } func->next = current; } - if (save) - function = save; } -next: - auto_add = false; - continue; } } @@ -2153,6 +2136,79 @@ 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->overridden) // If this QC command overrides an engine command, + func = func->overridden; // fall back to that command. + } + 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 @@ -2182,13 +2238,8 @@ void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qb { if (!strcasecmp(cmd->argv[0], func->name)) { - if(func->qcfunc) - { - if((func->flags & CF_CLIENT) && CL_VM_ConsoleCommand(text)) - goto done; - else if((func->flags & CF_SERVER) && SV_VM_ConsoleCommand(text)) - goto done; - } + if(cmd->Handle(cmd, func, text, src)) + goto done; } } @@ -2196,33 +2247,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_local: - 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) - { - 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); - 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 @@ -2352,3 +2386,7 @@ void Cmd_RestoreInitState(void) } Cvar_RestoreInitState(&cvars_all); } + +void Cmd_NoOperation_f(cmd_state_t *cmd) +{ +}