X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=cmd.c;h=722d1477ad9e1f03ad1ba0b6993b7a61e03ea743;hb=695449b27b0210ce2cfba1446fdb458a908c7456;hp=01a28ae693986d7f7e805d9624f6d47a6623e1c3;hpb=43ea541463e5c2f4fe0f050da19bca2d557cb9d2;p=xonotic%2Fdarkplaces.git diff --git a/cmd.c b/cmd.c index 01a28ae6..722d1477 100644 --- a/cmd.c +++ b/cmd.c @@ -41,18 +41,19 @@ static cmd_iter_t cmd_iter_all[] = { {NULL}, }; +mempool_t *cbuf_mempool; // we only run the +whatever commandline arguments once qbool host_stuffcmdsrun = false; //============================================================================= -void Cbuf_Lock(cbuf_t *cbuf) +void Cbuf_Lock(cmd_buf_t *cbuf) { Thread_LockMutex(cbuf->lock); } -void Cbuf_Unlock(cbuf_t *cbuf) +void Cbuf_Unlock(cmd_buf_t *cbuf) { Thread_UnlockMutex(cbuf->lock); } @@ -79,43 +80,48 @@ Cmd_Defer_f Cause a command to be executed after a delay. ============ */ -static cmd_input_t *Cbuf_LinkGet(cbuf_t *cbuf, cmd_input_t *existing); +static cmd_input_t *Cbuf_LinkGet(cmd_buf_t *cbuf, cmd_input_t *existing); static void Cmd_Defer_f (cmd_state_t *cmd) { cmd_input_t *current; - cbuf_t *cbuf = cmd->cbuf; + cmd_buf_t *cbuf = cmd->cbuf; 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) + List_For_Each(pos, &cbuf->deferred) { - current = List_Container(*pos, cmd_input_t, list); + current = List_Entry(*pos, 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)) List_Move_Tail(cbuf->deferred.next, &cbuf->free); } else if(Cmd_Argc(cmd) == 3) { const char *text = Cmd_Argv(cmd, 2); current = Cbuf_LinkGet(cbuf, NULL); - current->size = strlen(text); + current->length = strlen(text); current->source = cmd; current->delay = atof(Cmd_Argv(cmd, 1)); - memcpy(current->text, text, current->size + 1); + if(current->size < current->length) + { + current->text = (char *)Mem_Realloc(cbuf_mempool, current->text, current->length + 1); + current->size = current->length; + } - List_Move_Tail(¤t->list, &cbuf->deferred); + strlcpy(current->text, text, current->length + 1); + List_Move_Tail(¤t->list, &cbuf->deferred); } else { @@ -176,14 +182,14 @@ static void Cmd_Centerprint_f (cmd_state_t *cmd) ============================================================================= */ -static cmd_input_t *Cbuf_LinkGet(cbuf_t *cbuf, cmd_input_t *existing) +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_IsEmpty(&cbuf->free)) + else if(!List_Is_Empty(&cbuf->free)) { - ret = List_Container(*cbuf->free.next, cmd_input_t, list); + ret = List_Entry(*cbuf->free.next, cmd_input_t, list); ret->length = 0; ret->pending = false; } @@ -192,7 +198,7 @@ static cmd_input_t *Cbuf_LinkGet(cbuf_t *cbuf, cmd_input_t *existing) static cmd_input_t *Cmd_AllocInputNode(void) { - cmd_input_t *node = (cmd_input_t *)Z_Malloc(sizeof(cmd_input_t)); + 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; @@ -289,10 +295,10 @@ static size_t Cmd_ParseInput (cmd_input_t **output, char **input) (*output)->length += cmdsize; - if((*output)->size < (*output)->length + 1) + if((*output)->size < (*output)->length) { - (*output)->text = (char *)Mem_Realloc(tempmempool, (*output)->text, (*output)->size + cmdsize + 1); - (*output)->size = (*output)->length + 1; + (*output)->text = (char *)Mem_Realloc(cbuf_mempool, (*output)->text, (*output)->length + 1); + (*output)->size = (*output)->length; } strlcpy(&(*output)->text[offset], &(*input)[start], cmdsize + 1); @@ -309,7 +315,7 @@ static size_t Cmd_ParseInput (cmd_input_t **output, char **input) static void Cbuf_LinkCreate(cmd_state_t *cmd, llist_t *head, cmd_input_t *existing, const char *text) { char *in = (char *)&text[0]; - cbuf_t *cbuf = cmd->cbuf; + cmd_buf_t *cbuf = cmd->cbuf; size_t totalsize = 0, newsize = 0; cmd_input_t *current = NULL; @@ -348,7 +354,7 @@ Adds command text at the end of the buffer void Cbuf_AddText (cmd_state_t *cmd, const char *text) { size_t l = strlen(text); - cbuf_t *cbuf = cmd->cbuf; + cmd_buf_t *cbuf = cmd->cbuf; llist_t llist = {&llist, &llist}; Cbuf_Lock(cbuf); @@ -357,8 +363,8 @@ 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)) + 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); @@ -374,19 +380,19 @@ FIXME: actually change the command buffer to do less copying */ void Cbuf_InsertText (cmd_state_t *cmd, const char *text) { - cbuf_t *cbuf = cmd->cbuf; + cmd_buf_t *cbuf = cmd->cbuf; llist_t llist = {&llist, &llist}; size_t l = strlen(text); Cbuf_Lock(cbuf); // we need to memmove the existing text and stuff this in before it... - if (cbuf->size + l >= (size_t)cbuf->maxsize) + 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)) + Cbuf_LinkCreate(cmd, &llist, List_Entry(*cbuf->start.next, cmd_input_t, list), text); + if(!List_Is_Empty(&llist)) List_Splice(&llist, &cbuf->start); } @@ -398,7 +404,7 @@ void Cbuf_InsertText (cmd_state_t *cmd, const char *text) Cbuf_Execute_Deferred --blub ============ */ -static void Cbuf_Execute_Deferred (cbuf_t *cbuf) +static void Cbuf_Execute_Deferred (cmd_buf_t *cbuf) { llist_t *pos; cmd_input_t *current; @@ -411,13 +417,13 @@ static void Cbuf_Execute_Deferred (cbuf_t *cbuf) return; cbuf->deferred_oldtime = host.realtime; - List_ForEach(pos, &cbuf->deferred) + List_For_Each(pos, &cbuf->deferred) { - current = List_Container(*pos, cmd_input_t, list); + current = List_Entry(*pos, cmd_input_t, list); current->delay -= eat; if(current->delay <= 0) { - cbuf->size += current->size; + 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; @@ -431,7 +437,7 @@ Cbuf_Execute ============ */ static qbool Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmd_alias_t *alias ); -void Cbuf_Execute (cbuf_t *cbuf) +void Cbuf_Execute (cmd_buf_t *cbuf) { cmd_input_t *current; char preprocessed[MAX_INPUTLINE]; @@ -440,15 +446,18 @@ void Cbuf_Execute (cbuf_t *cbuf) // 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); + /* * Assume we're rolling with the current command-line and * always set this false because alias expansion or cbuf insertion @@ -473,9 +482,6 @@ void Cbuf_Execute (cbuf_t *cbuf) Cmd_ExecuteString (current->source, current->text, src_local, false); } - // Recycle memory so using WASD doesn't cause a malloc and free - List_Move_Tail(¤t->list, &cbuf->free); - current = NULL; if (cbuf->wait) @@ -490,7 +496,7 @@ void Cbuf_Execute (cbuf_t *cbuf) } } -void Cbuf_Frame(cbuf_t *cbuf) +void Cbuf_Frame(cmd_buf_t *cbuf) { Cbuf_Execute_Deferred(cbuf); if (cbuf->size) @@ -524,10 +530,6 @@ 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]; - - // come back later so we don't crash - if(host.state == host_init) - return; if (Cmd_Argc (cmd) != 1) { @@ -1504,7 +1506,7 @@ static void Cmd_List_f (cmd_state_t *cmd) } count = 0; - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) { if (partial && (ispattern ? !matchpattern_with_separator(func->name, partial, false, "", false) : strncmp(partial, func->name, len))) continue; @@ -1572,7 +1574,7 @@ static void Cmd_Apropos_f(cmd_state_t *cmd) } } } - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) { if (!matchpattern_with_separator(func->name, partial, true, "", false)) if (!matchpattern_with_separator(func->description, partial, true, "", false)) @@ -1608,7 +1610,9 @@ Cmd_Init void Cmd_Init(void) { cmd_iter_t *cmd_iter; - cbuf_t *cbuf = (cbuf_t *)Z_Malloc(sizeof(cbuf_t)); + 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; @@ -1757,6 +1761,7 @@ static void Cmd_TokenizeString (cmd_state_t *cmd, const char *text) cmd->argc = 0; cmd->args = NULL; + cmd->cmdline = NULL; while (1) { @@ -1780,6 +1785,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; @@ -1871,33 +1878,34 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const } else { - // mark csqcfunc if the function already exists in the csqc_functions list - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + // 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->csqcfunc = true; //[515]: csqc + func->qcfunc = true; //[515]: csqc 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->csqcfunc = true; //[515]: csqc - func->next = cmd->userdefined->csqc_functions; + func->qcfunc = true; //[515]: csqc + func->next = cmd->userdefined->qc_functions; func->autofunc = false; // insert it at the right alphanumeric position - for (prev = NULL, current = cmd->userdefined->csqc_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next) + 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->csqc_functions = func; + cmd->userdefined->qc_functions = func; } func->next = current; } @@ -1910,30 +1918,6 @@ next: } } -static int Cmd_Compare(const char *s1, const char *s2, size_t len, qbool casesensitive) -{ - if(len) - return (casesensitive ? strncmp(s1, s2, len) : strncasecmp(s1, s2, len)); - else - return (casesensitive ? strcmp(s1, s2) : strcasecmp(s1, s2)); -} - -cmd_function_t *Cmd_GetCommand(cmd_state_t *cmd, const char *partial, size_t len, qbool casesensitive) -{ - cmd_function_t *func = NULL; - - // check functions - for (func = cmd->userdefined->csqc_functions; func; func = func->next) - if (!Cmd_Compare(partial, func->name, len, casesensitive)) - break; - - for (func=cmd->engine_functions ; func ; func=func->next) - if (!Cmd_Compare(partial, func->name, len, casesensitive)) - break; - - return func; -} - /* ============ Cmd_Exists @@ -1941,11 +1925,20 @@ Cmd_Exists */ qbool Cmd_Exists (cmd_state_t *cmd, const char *cmd_name) { - if(Cmd_GetCommand(cmd, cmd_name, 0, true)) - return true; + cmd_function_t *func; + + for (func = cmd->userdefined->qc_functions; func; func = func->next) + if (!strcmp(cmd_name, func->name)) + return true; + + for (func=cmd->engine_functions ; func ; func=func->next) + if (!strcmp (cmd_name,func->name)) + return true; + return false; } + /* ============ Cmd_CompleteCommand @@ -1954,10 +1947,22 @@ Cmd_CompleteCommand const char *Cmd_CompleteCommand (cmd_state_t *cmd, const char *partial) { cmd_function_t *func; + size_t len; + + len = strlen(partial); + + if (!len) + return NULL; + +// check functions + 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; - func = Cmd_GetCommand(cmd, partial, strlen(partial), false); - if(func) - return func->name; return NULL; } @@ -1983,7 +1988,7 @@ int Cmd_CompleteCountPossible (cmd_state_t *cmd, const char *partial) return 0; // Loop through the command list and count all partial matches - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) if (!strncasecmp(partial, func->name, len)) h++; @@ -2014,7 +2019,7 @@ const char **Cmd_CompleteBuildList (cmd_state_t *cmd, const char *partial) len = strlen(partial); buf = (const char **)Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *)); // Loop through the functions lists and print all matches - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) if (!strncasecmp(partial, func->name, len)) buf[bpos++] = func->name; for (func = cmd->engine_functions; func; func = func->next) @@ -2031,7 +2036,7 @@ void Cmd_CompleteCommandPrint (cmd_state_t *cmd, const char *partial) cmd_function_t *func; size_t len = strlen(partial); // Loop through the command list and print all matches - for (func = cmd->userdefined->csqc_functions; func; func = func->next) + for (func = cmd->userdefined->qc_functions; func; func = func->next) if (!strncasecmp(partial, func->name, len)) Con_Printf("^2%s^7: %s\n", func->name, func->description); for (func = cmd->engine_functions; func; func = func->next) @@ -2140,7 +2145,7 @@ const char **Cmd_CompleteAliasBuildList (cmd_state_t *cmd, const char *partial) void Cmd_ClearCSQCCommands (cmd_state_t *cmd) { cmd_function_t *func; - cmd_function_t **next = &cmd->userdefined->csqc_functions; + cmd_function_t **next = &cmd->userdefined->qc_functions; while(*next) { @@ -2177,12 +2182,23 @@ void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qb goto done; // no tokens // check functions - func = Cmd_GetCommand(cmd, cmd->argv[0], 0, false); - if(func) + for (func = cmd->userdefined->qc_functions; func; func = func->next) { - if (func->csqcfunc && CL_VM_ConsoleCommand(text)) //[515]: csqc - goto done; - else + 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; + } + } + } + + for (func = cmd->engine_functions; func; func=func->next) + { + if (!strcasecmp (cmd->argv[0], func->name)) { switch (src) { @@ -2202,6 +2218,7 @@ void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qb goto done; } } + break; } } @@ -2267,7 +2284,7 @@ void Cmd_SaveInitState(void) cmd_state_t *cmd = cmd_iter->cmd; cmd_function_t *f; cmd_alias_t *a; - for (f = cmd->userdefined->csqc_functions; f; f = f->next) + 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; @@ -2288,7 +2305,7 @@ void Cmd_RestoreInitState(void) cmd_state_t *cmd = cmd_iter->cmd; cmd_function_t *f, **fp; cmd_alias_t *a, **ap; - for (fp = &cmd->userdefined->csqc_functions; (f = *fp);) + for (fp = &cmd->userdefined->qc_functions; (f = *fp);) { if (f->initstate) fp = &f->next;