Fix DP_QC_FINDCHAIN_TOFIELD errors

[xonotic/darkplaces.git] / cmd.c

diff --git a/cmd.c b/cmd.c
index fba45672c5a341bb3d70b12c144b29ee8c4fb489..c9b2cd5d8b0fc8d172d69685c59880122518d1d7 100644 (file)
--- a/cmd.c
+++ b/cmd.c
@@ -86,12 +86,8 @@ static void Cmd_Defer_f (cmd_state_t *cmd)
                        Con_Printf("No commands are pending.\n");
                else
                {
-                       llist_t *pos;
-               List_For_Each(pos, &cbuf->deferred)
-               {
-                               current = List_Entry(*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)))
@@ -183,7 +179,7 @@ static cmd_input_t *Cbuf_LinkGet(cmd_buf_t *cbuf, cmd_input_t *existing)
                ret = existing;
        else if(!List_Is_Empty(&cbuf->free))
        {
-               ret = List_Entry(*cbuf->free.next, cmd_input_t, list);
+               ret = List_Entry(cbuf->free.next, cmd_input_t, list);
                ret->length = 0;
                ret->pending = false;
        }
@@ -198,6 +194,11 @@ static cmd_input_t *Cmd_AllocInputNode(void)
        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;
@@ -284,6 +285,7 @@ static size_t Cmd_ParseInput (cmd_input_t **output, char **input)
                if(!*output)
                        *output = Cmd_AllocInputNode();
 
+               // Append, since this input line hasn't closed yet.
                if((*output)->pending)
                        offset = (*output)->length;
 
@@ -296,6 +298,11 @@ static size_t Cmd_ParseInput (cmd_input_t **output, char **input)
                }
 
                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;
        }
 
@@ -316,12 +323,14 @@ static void Cbuf_LinkCreate(cmd_state_t *cmd, llist_t *head, cmd_input_t *existi
        // 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(&current, &in);
 
                // Valid command
                if(newsize)
                {
+                       // current will match existing if the input line hasn't terminated yet
                        if(current != existing)
                        {
                                current->source = cmd;
@@ -357,7 +366,7 @@ void Cbuf_AddText (cmd_state_t *cmd, const char *text)
                Con_Print("Cbuf_AddText: overflow\n");
        else
        {
-               Cbuf_LinkCreate(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(*cbuf->start.prev, cmd_input_t, list)), text);
+               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);
        }
@@ -385,7 +394,7 @@ void Cbuf_InsertText (cmd_state_t *cmd, const char *text)
                Con_Print("Cbuf_InsertText: overflow\n");
        else
        {
-               Cbuf_LinkCreate(cmd, &llist, List_Entry(*cbuf->start.next, cmd_input_t, list), text);
+               Cbuf_LinkCreate(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.next, cmd_input_t, list)), text);
                if(!List_Is_Empty(&llist))
                        List_Splice(&llist, &cbuf->start);
        }
@@ -400,7 +409,6 @@ Cbuf_Execute_Deferred --blub
 */
 static void Cbuf_Execute_Deferred (cmd_buf_t *cbuf)
 {
-       llist_t *pos;
        cmd_input_t *current;
        double eat;
 
@@ -411,14 +419,13 @@ static void Cbuf_Execute_Deferred (cmd_buf_t *cbuf)
                return;
        cbuf->deferred_oldtime = host.realtime;
 
-    List_For_Each(pos, &cbuf->deferred)
+       List_For_Each_Entry(current, &cbuf->deferred, cmd_input_t, list)
        {
-               current = List_Entry(*pos, cmd_input_t, list);
                current->delay -= eat;
                if(current->delay <= 0)
                {
                        cbuf->size += current->length;
-                       List_Move(pos, &cbuf->start);
+                       List_Move(&current->list, &cbuf->start);
                        // We must return and come back next frame or the engine will freeze. Fragile... like glass :3
                        return;
                }
@@ -447,7 +454,7 @@ void Cbuf_Execute (cmd_buf_t *cbuf)
                 * 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);
+               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(&current->list, &cbuf->free);
@@ -1581,12 +1588,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++;
                        }
                }
@@ -1893,7 +1900,6 @@ 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;
@@ -1902,6 +1908,18 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const
                                func->qcfunc = true; //[515]: csqc
                                func->next = cmd->userdefined->qc_functions;
 
+                               // 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)
                                        ;
@@ -2185,6 +2203,9 @@ qbool Cmd_CL_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text,
                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)
        {