X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=cmd.c;h=8637f4886823501ef7d6814b1c32450490c9ab87;hb=eb5f88dfe5c842c61f52d13b5be72afc39d6e998;hp=9e4059e5f351145309b3f25fef5dd25398fa144a;hpb=b9ba00ee9a682a2ba3a627b8d6545bde54fe97a4;p=xonotic%2Fdarkplaces.git diff --git a/cmd.c b/cmd.c index 9e4059e5..8637f488 100644 --- a/cmd.c +++ b/cmd.c @@ -20,25 +20,44 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. // cmd.c -- Quake script command processing module #include "quakedef.h" +#include "thread.h" -typedef struct cmdalias_s -{ - struct cmdalias_s *next; - char name[MAX_ALIAS_NAME]; - char *value; -} cmdalias_t; +cmd_state_t cmd_client; +cmd_state_t cmd_server; +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[] = { + {&cmd_client}, + {&cmd_server}, + {&cmd_serverfromclient}, + {NULL}, +}; -static mempool_t *cmd_mempool; -static char cmd_tokenizebuffer[CMD_TOKENIZELENGTH]; -static int cmd_tokenizebufferpos = 0; +// we only run the +whatever commandline arguments once +qboolean host_stuffcmdsrun = false; //============================================================================= +void Cbuf_Lock(cbuf_t *cbuf) +{ + Thread_LockMutex(cbuf->lock); +} + +void Cbuf_Unlock(cbuf_t *cbuf) +{ + Thread_UnlockMutex(cbuf->lock); +} + + /* ============ Cmd_Wait_f @@ -48,20 +67,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 time; -} cmddeferred_t; - -static cmddeferred_t *cmd_deferred_list = NULL; - /* ============ Cmd_Defer_f @@ -69,51 +79,46 @@ Cmd_Defer_f Cause a command to be executed after a delay. ============ */ -static void Cmd_Defer_f (void) +static cmd_input_t *Cbuf_LinkGet(cbuf_t *cbuf, cmd_input_t *existing); +static void Cmd_Defer_f (cmd_state_t *cmd) { - if(Cmd_Argc() == 1) + cmd_input_t *current; + cbuf_t *cbuf = cmd->cbuf; + + if(Cmd_Argc(cmd) == 1) { - double time = Sys_DoubleTime(); - cmddeferred_t *next = cmd_deferred_list; - if(!next) + if(List_IsEmpty(&cbuf->deferred)) Con_Printf("No commands are pending.\n"); - while(next) + else { - Con_Printf("-> In %9.2f: %s\n", next->time-time, next->value); - next = next->next; + llist_t *pos; + List_ForEach(pos, &cbuf->deferred) + { + current = List_Container(*pos, cmd_input_t, 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(cmd_deferred_list) - { - cmddeferred_t *cmd = cmd_deferred_list; - cmd_deferred_list = cmd->next; - Mem_Free(cmd->value); - Mem_Free(cmd); - } - } else if(Cmd_Argc() == 3) + while(!List_IsEmpty(&cbuf->deferred)) + List_Move_Tail(cbuf->deferred.next, &cbuf->free); + } + else if(Cmd_Argc(cmd) == 3) { - const char *value = Cmd_Argv(2); - cmddeferred_t *defcmd = (cmddeferred_t*)Mem_Alloc(tempmempool, sizeof(*defcmd)); - size_t len = strlen(value); + const char *text = Cmd_Argv(cmd, 2); + current = Cbuf_LinkGet(cbuf, NULL); + current->size = strlen(text); + current->source = cmd; + current->delay = atof(Cmd_Argv(cmd, 1)); - defcmd->time = Sys_DoubleTime() + atof(Cmd_Argv(1)); - defcmd->value = (char*)Mem_Alloc(tempmempool, len+1); - memcpy(defcmd->value, value, len+1); - defcmd->next = NULL; + memcpy(current->text, text, current->size + 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; @@ -127,20 +132,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] == '\\') @@ -171,8 +176,157 @@ static void Cmd_Centerprint_f (void) ============================================================================= */ -static sizebuf_t cmd_text; -static unsigned char cmd_text_buf[CMDBUFSIZE]; +/* +============ +Cbuf_ParseText + +Parses Quake console command-line +Returns true if command is complete +============ +*/ +static qboolean Cbuf_ParseText(char **start, size_t *size) +{ + int i = 0; + qboolean quotes = false; + qboolean comment = false; // Does not imply end because we might be starting the line with a comment. + qboolean escaped = false; + qboolean end = false; // Reached the end of a valid command + char *offset = NULL; // Non-NULL if valid command. Used by the caller to know where to start copying. + size_t cmdsize = 0; // Non-zero if valid command. Basically bytes to copy for the caller. + + /* + * Allow escapes in quotes. Ignore newlines and + * comments. Return 0 if input consists solely + * of either of those, and ignore blank input. + */ + while(!end) + { + switch ((*start)[i]) + { + case '/': + if(!quotes && (*start)[i+1] == '/' && (i == 0 || ISWHITESPACE((*start)[i-1]))) + comment = true; + break; + case 0: + if(!end && cmdsize) + return false; + comment = false; + end = true; + break; + case '\r': + case '\n': + comment = false; + quotes = false; + end = true; + break; + } + + if(!comment) + { + switch ((*start)[i]) + { + case ';': + if(!quotes) + end = true; + break; + case '"': + if (!escaped) + quotes = !quotes; + else + escaped = false; + break; + case '\\': + if (!escaped && quotes) + escaped = true; + else if (escaped) + escaped = false; + break; + } + + if(!offset) + { + if(!end) + offset = (char *)&(*start)[i]; + else if ((*start)[i]) + end = false; + } + else + cmdsize++; + } + i++; + } + + *start = offset; + *size = cmdsize; + + return true; +} + +static cmd_input_t *Cbuf_LinkGet(cbuf_t *cbuf, cmd_input_t *existing) +{ + cmd_input_t *ret = NULL; + if(existing && existing->pending) + ret = existing; + else + { + if(!List_IsEmpty(&cbuf->free)) + ret = List_Container(*cbuf->free.next, cmd_input_t, list); + else + { + ret = (cmd_input_t *)Z_Malloc(sizeof(cmd_input_t)); + ret->list.next = ret->list.prev = &ret->list; + } + ret->size = 0; + ret->pending = false; + } + + return ret; +} + + +// 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]; + qboolean complete; + cbuf_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) + { + /* + * FIXME: Upon reaching a terminator, we make a redundant + * call just to say "it's the end of the input stream". + */ + complete = Cbuf_ParseText(&in, &newsize); + + // Valid command + if(newsize) + { + if(!current) + current = Cbuf_LinkGet(cbuf, existing); + + if(!current->pending) + { + current->source = cmd; + List_Move_Tail(¤t->list, head); + } + + current->pending = complete; + totalsize += newsize; + strlcpy(¤t->text[current->size], in, newsize + 1); + current->size += newsize; + } + else if (existing && !totalsize) + existing->pending = false; + current = NULL; + in = &in[newsize]; + } + + cbuf->size += totalsize; +} /* ============ @@ -181,56 +335,51 @@ 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); + cbuf_t *cbuf = cmd->cbuf; + llist_t llist = {&llist, &llist}; - l = (int)strlen (text); + Cbuf_Lock(cbuf); - if (cmd_text.cursize + l >= cmd_text.maxsize) - { + if (cbuf->maxsize - cbuf->size <= l) Con_Print("Cbuf_AddText: overflow\n"); - return; + 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); } - - SZ_Write (&cmd_text, (const unsigned char *)text, (int)strlen (text)); + 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) { - char *temp; - int templen; + cbuf_t *cbuf = cmd->cbuf; + llist_t llist = {&llist, &llist}; + size_t l = strlen(text); - // copy off any commands still remaining in the exec buffer - templen = cmd_text.cursize; - if (templen) - { - temp = (char *)Mem_Alloc (tempmempool, templen); - memcpy (temp, cmd_text.data, templen); - SZ_Clear (&cmd_text); - } - else - temp = NULL; + Cbuf_Lock(cbuf); - // add the entire text of the file - Cbuf_AddText (text); - - // add the copied off data - if (temp != NULL) + // we need to memmove the existing text and stuff this in before it... + if (cbuf->size + l >= (size_t)cbuf->maxsize) + Con_Print("Cbuf_InsertText: overflow\n"); + else { - SZ_Write (&cmd_text, (const unsigned char *)temp, templen); - Mem_Free (temp); + Cbuf_LinkCreate(cmd, &llist, List_Container(*cbuf->start.next, cmd_input_t, list), text); + List_Splice(&llist, &cbuf->start); } + + Cbuf_Unlock(cbuf); } /* @@ -238,33 +387,30 @@ void Cbuf_InsertText (const char *text) Cbuf_Execute_Deferred --blub ============ */ -void Cbuf_Execute_Deferred (void) +static void Cbuf_Execute_Deferred (cbuf_t *cbuf) { - cmddeferred_t *cmd, *prev; - double time = Sys_DoubleTime(); - prev = NULL; - cmd = cmd_deferred_list; - while(cmd) + llist_t *pos; + cmd_input_t *current; + double 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)) + return; + cbuf->deferred_oldtime = host.realtime; + + List_ForEach(pos, &cbuf->deferred) { - if(cmd->time <= time) + current = List_Container(*pos, cmd_input_t, list); + 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->size; + List_Move(pos, &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; } } @@ -273,106 +419,77 @@ void Cbuf_Execute_Deferred (void) Cbuf_Execute ============ */ -static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias ); -void Cbuf_Execute (void) +static qboolean Cmd_PreprocessString(cmd_state_t *cmd, const char *intext, char *outtext, unsigned maxoutlen, cmd_alias_t *alias ); +void Cbuf_Execute (cbuf_t *cbuf) { - int i; - char *text; - char line[MAX_INPUTLINE]; + cmd_input_t *current; char preprocessed[MAX_INPUTLINE]; char *firstchar; - qboolean quotes, 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; - Cbuf_Execute_Deferred(); - while (cmd_text.cursize) + while (!List_IsEmpty(&cbuf->start)) { -// find a \n or ; line break - text = (char *)cmd_text.data; - - quotes = false; - comment = false; - for (i=0 ; i < cmd_text.cursize ; i++) + /* + * 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); + + /* + * 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->size; + + 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(!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 = true; - 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; + if(Cmd_PreprocessString(current->source, current->text, preprocessed, sizeof(preprocessed), NULL )) + Cmd_ExecuteString(current->source, preprocessed, src_local, false); } else { - memcpy (line, text, i); - line[i] = 0; + Cmd_ExecuteString (current->source, current->text, src_local, false); } -// 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 + // Recycle memory so using WASD doesn't cause a malloc and free + List_Move_Tail(¤t->list, &cbuf->free); - if (i == cmd_text.cursize) - cmd_text.cursize = 0; - else - { - i++; - cmd_text.cursize -= i; - memmove (cmd_text.data, text+i, cmd_text.cursize); - } + current = NULL; -// execute the command line - firstchar = line + strspn(line, " \t"); - if( - (strncmp(firstchar, "alias", 5) || (firstchar[5] != ' ' && firstchar[5] != '\t')) - && - (strncmp(firstchar, "bind", 4) || (firstchar[4] != ' ' && firstchar[4] != '\t')) - && - (strncmp(firstchar, "in_bind", 7) || (firstchar[7] != ' ' && firstchar[7] != '\t')) - ) + if (cbuf->wait) { - Cmd_PreprocessString( line, preprocessed, sizeof(preprocessed), NULL ); - Cmd_ExecuteString (preprocessed, src_command); - } - else - { - Cmd_ExecuteString (line, src_command); - } - - if (cmd_wait) - { // skip out while text still remains in buffer, leaving it - // for next frame - cmd_wait = false; + /* + * Skip out while text still remains in + * buffer, leaving it for next frame + */ + cbuf->wait = false; break; } } } +void Cbuf_Frame(cbuf_t *cbuf) +{ + Cbuf_Execute_Deferred(cbuf); + if (cbuf->size) + { + SV_LockThreadMutex(); + Cbuf_Execute(cbuf); + SV_UnlockThreadMutex(); + } +} + /* ============================================================================== @@ -391,14 +508,17 @@ quake +prog jctest.qp +cmd amlev1 quake -nosound +cmd amlev1 =============== */ -qboolean host_stuffcmdsrun = false; -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]; + + // come back later so we don't crash + if(host.state == host_init) + return; - if (Cmd_Argc () != 1) + if (Cmd_Argc (cmd) != 1) { Con_Print("stuffcmds : execute command line parameters\n"); return; @@ -411,28 +531,28 @@ 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'; @@ -442,44 +562,292 @@ 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(cmd_state_t *cmd, const char *filename) +{ + char *f; + size_t filenameLen = strlen(filename); + qboolean isdefaultcfg = + !strcmp(filename, "default.cfg") || + (filenameLen >= 12 && !strcmp(filename + filenameLen - 12, "/default.cfg")); + + if (!strcmp(filename, "config.cfg")) + { + filename = CONFIGFILENAME; + if (Sys_CheckParm("-noconfig")) + return; // don't execute config.cfg + } + + f = (char *)FS_LoadFile (filename, tempmempool, false, NULL); + if (!f) + { + Con_Printf("couldn't exec %s\n",filename); + return; + } + Con_Printf("execing %s\n",filename); + + // if executing default.cfg for the first time, lock the cvar defaults + // 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(cmd, "\ncvar_lockdefaults\n"); + + Cbuf_InsertText (cmd, f); + Mem_Free(f); + + if (isdefaultcfg) + { + // 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 + 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. + 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 + 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 + 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; + } + } +} /* =============== Cmd_Exec_f =============== */ -static void Cmd_Exec_f (void) +static void Cmd_Exec_f (cmd_state_t *cmd) { - char *f; + fssearch_t *s; + int i; - if (Cmd_Argc () != 2) + if (Cmd_Argc(cmd) != 2) { Con_Print("exec : execute a script file\n"); return; } - f = (char *)FS_LoadFile (Cmd_Argv(1), tempmempool, false, NULL); - if (!f) + 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; } - Con_Printf("execing %s\n",Cmd_Argv(1)); - // if executing default.cfg for the first time, lock the cvar defaults - // 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 (!strcmp(Cmd_Argv(1), "default.cfg")) - Cbuf_InsertText("\ncvar_lockdefaults\n"); + for(i = 0; i < s->numfilenames; ++i) + Cmd_Exec(cmd, s->filenames[i]); - // 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); - Mem_Free(f); + FS_FreeSearch(s); } @@ -490,12 +858,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 @@ -533,13 +901,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); @@ -551,14 +919,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; @@ -568,13 +936,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) ); } } } @@ -586,23 +954,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"); @@ -610,7 +978,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)) { @@ -621,38 +989,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(); - for (i=2 ; i< c ; i++) + line[0] = 0; // start out with a null string + c = Cmd_Argc(cmd); + for (i=2 ; i < c ; i++) { - strlcat (cmd, Cmd_Argv(i), sizeof (cmd)); - if (i != c) - strlcat (cmd, " ", sizeof (cmd)); + if (i != 2) + 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); } /* @@ -662,28 +1030,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 == cmd_alias) - cmd_alias = a->next; + if (a->initstate) // we can not remove init aliases + continue; + if(a == cmd->userdefined->alias) + cmd->userdefined->alias = a->next; if(p) p->next = a->next; Z_Free(a->value); @@ -704,30 +1074,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; -} 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, qboolean *is_multiple) { cvar_t *cvar; long argno; char *endptr; + static char vabuf[1024]; // cmd_mutex if(is_multiple) *is_multiple = false; @@ -741,11 +1093,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("%d", Cmd_Argc()); + return va(vabuf, sizeof(vabuf), "%d", Cmd_Argc(cmd)); } else if(varname[strlen(varname) - 1] == '-') { @@ -753,7 +1105,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; @@ -777,77 +1129,86 @@ 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 & CVAR_PRIVATE)) return cvar->string; return NULL; } -qboolean Cmd_QuoteString(char *out, size_t outlen, const char *in, const char *quoteset) +qboolean Cmd_QuoteString(char *out, size_t outlen, const char *in, const char *quoteset, qboolean putquotes) { qboolean quote_quot = !!strchr(quoteset, '"'); qboolean quote_backslash = !!strchr(quoteset, '\\'); qboolean quote_dollar = !!strchr(quoteset, '$'); + if(putquotes) + { + if(outlen <= 2) + { + *out++ = 0; + return false; + } + *out++ = '"'; --outlen; + --outlen; + } + while(*in) { if(*in == '"' && quote_quot) { if(outlen <= 2) - { - *out++ = 0; - return false; - } + goto fail; *out++ = '\\'; --outlen; *out++ = '"'; --outlen; } else if(*in == '\\' && quote_backslash) { if(outlen <= 2) - { - *out++ = 0; - return false; - } + goto fail; *out++ = '\\'; --outlen; *out++ = '\\'; --outlen; } else if(*in == '$' && quote_dollar) { if(outlen <= 2) - { - *out++ = 0; - return false; - } + goto fail; *out++ = '$'; --outlen; *out++ = '$'; --outlen; } else { if(outlen <= 1) - { - *out++ = 0; - return false; - } + goto fail; *out++ = *in; --outlen; } ++in; } + if(putquotes) + *out++ = '"'; *out++ = 0; return true; +fail: + if(putquotes) + *out++ = '"'; + *out++ = 0; + 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]; - static char varval[MAX_INPUTLINE]; - const char *varstr; + 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; + static char asis[] = "asis"; // just to suppress const char warnings if(varlen >= MAX_INPUTLINE) varlen = MAX_INPUTLINE - 1; @@ -864,37 +1225,80 @@ static const char *Cmd_GetCvarValue(const char *var, size_t varlen, cmdalias_t * if(*var == 0) { // empty cvar name? - return NULL; + if(alias) + Con_Printf(CON_WARN "Warning: Could not expand $ in alias %s\n", alias->name); + else + Con_Printf(CON_WARN "Warning: Could not expand $\n"); + return "$"; } - varstr = NULL; + if(varfunc) + { + char *p; + // ? means optional + while((p = strchr(varfunc, '?'))) + { + optional = true; + memmove(p, p+1, strlen(p)); // with final NUL + } + // ! means required + while((p = strchr(varfunc, '!'))) + { + required = true; + memmove(p, p+1, strlen(p)); // with final NUL + } + // kill spaces + while((p = strchr(varfunc, ' '))) + { + memmove(p, p+1, strlen(p)); // with final NUL + } + // if no function is left, NULL it + if(!*varfunc) + varfunc = NULL; + } 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; // 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"; + varfunc = asis; } if(!varstr) { - if(alias) - Con_Printf("Warning: Could not expand $%s in alias %s\n", varname, alias->name); + if(required) + { + if(alias) + Con_Printf(CON_ERROR "Error: Could not expand $%s in alias %s\n", varname, alias->name); + else + Con_Printf(CON_ERROR "Error: Could not expand $%s\n", varname); + return NULL; + } + else if(optional) + { + return ""; + } else - Con_Printf("Warning: Could not expand $%s\n", varname); - return NULL; + { + if(alias) + Con_Printf(CON_WARN "Warning: Could not expand $%s in alias %s\n", varname, alias->name); + else + Con_Printf(CON_WARN "Warning: Could not expand $%s\n", varname); + dpsnprintf(varval, sizeof(varval), "$%s", varname); + return varval; + } } if(!varfunc || !strcmp(varfunc, "q")) // note: quoted form is default, use "asis" to override! { // quote it so it can be used inside double quotes // we just need to replace " by \", and of course, double backslashes - Cmd_QuoteString(varval, sizeof(varval), varstr, "\"\\"); + Cmd_QuoteString(varval, sizeof(varval), varstr, "\"\\", false); return varval; } else if(!strcmp(varfunc, "asis")) @@ -912,7 +1316,7 @@ Cmd_PreprocessString Preprocesses strings and replaces $*, $param#, $cvar accordingly. Also strips comments. */ -static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned maxoutlen, cmdalias_t *alias ) { +static qboolean 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; @@ -920,7 +1324,7 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma // don't crash if there's no room in the outtext buffer if( maxoutlen == 0 ) { - return; + return false; } maxoutlen--; // because of \0 @@ -941,6 +1345,10 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma // that way) // - ${var asis} inserts the cvar value as is, without doing this // quoting + // - ${var ?} silently expands to the empty string if + // $var does not exist + // - ${var !} fails expansion and executes nothing if + // $var does not exist // - prefix the cvar name with a dollar sign to do indirection; // for example, if $x has the value timelimit, ${$x} will return // the value of $timelimit @@ -951,6 +1359,7 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma // parameters, without extra quoting, so one can use $* to just // pass all parameters around. All parameters starting from $n // can be referred to as $n- (so $* is equivalent to $1-). + // - ${* q} and ${n- q} force quoting anyway // // Note: when expanding an alias, cvar expansion is done in the SAME step // as alias expansion so that alias parameters or cvar values containing @@ -986,7 +1395,9 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma 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; } else @@ -997,7 +1408,9 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma } } else { varlen = strspn(in, "#*0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-"); - val = Cmd_GetCvarValue(in, varlen, alias); + val = Cmd_GetCvarValue(cmd, in, varlen, alias); + if(!val) + return false; eat = varlen; } if(val) @@ -1022,6 +1435,7 @@ static void Cmd_PreprocessString( const char *intext, char *outtext, unsigned ma outtext[outlen++] = *in++; } outtext[outlen] = 0; + return true; } /* @@ -1031,19 +1445,21 @@ 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 ]; - static char buffer2[ MAX_INPUTLINE ]; - Cmd_PreprocessString( alias->value, buffer, sizeof(buffer) - 2, alias ); + static char buffer[ MAX_INPUTLINE ]; // cmd_mutex + static char buffer2[ MAX_INPUTLINE ]; // cmd_mutex + qboolean ret = Cmd_PreprocessString( cmd, alias->value, buffer, sizeof(buffer) - 2, alias ); + if(!ret) + return; // insert at start of command buffer, so that aliases execute in order // (fixes bug introduced by Black on 20050705) // Note: Cbuf_PreprocessString will be called on this string AGAIN! So we // 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, "$"); - Cbuf_InsertText( buffer2 ); + Cmd_QuoteString(buffer2, sizeof(buffer2), buffer, "$", false); + Cbuf_InsertText(cmd, buffer2); } /* @@ -1055,33 +1471,40 @@ 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; - 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, '?')); } else { partial = NULL; len = 0; + ispattern = false; } - ispattern = partial && (strchr(partial, '*') || strchr(partial, '?')); - count = 0; - for (cmd = cmd_functions; cmd; cmd = cmd->next) + for (func = cmd->userdefined->csqc_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++; + } + for (func = cmd->engine_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++; } @@ -1096,57 +1519,71 @@ 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; - size_t len; int count; qboolean ispattern; + char vabuf[1024]; - if (Cmd_Argc() > 1) - { - partial = Cmd_Args(); - len = strlen(partial); - } + 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; } ispattern = partial && (strchr(partial, '*') || strchr(partial, '?')); if(!ispattern) - { - partial = va("*%s*", partial); - len += 2; - } + 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 (int i = 0; i < cvar->aliasindex; i++) + { + if (matchpattern_with_separator(cvar->aliases[i], partial, true, "", false)) + { + Con_Printf ("cvar "); + Cvar_PrintHelp(cvar, cvar->aliases[i], true); + count++; + } + } + } + for (func = cmd->userdefined->csqc_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)) - if (!matchpattern_with_separator(alias->value, partial, true, "", false)) + if (!matchpattern_with_separator(alias->value, partial, true, "\n", false)) // when \n is as separator wildcards don't match it continue; - Con_Printf("alias ^5%s^7: %s", alias->name, alias->value); + Con_Printf("alias ^5%s^7: %s", alias->name, alias->value); // do not print an extra \n count++; } Con_Printf("%i result%s\n\n", count, (count > 1) ? "s" : ""); @@ -1157,50 +1594,88 @@ static void Cmd_Apropos_f(void) Cmd_Init ============ */ -void Cmd_Init (void) +void Cmd_Init(void) { - 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_iter_t *cmd_iter; + cbuf_t *cbuf = (cbuf_t *)Z_Malloc(sizeof(cbuf_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); + + 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 = CVAR_CLIENT | CVAR_SERVER; + cmd_client.cmd_flags = CMD_CLIENT | CMD_CLIENT_FROM_SERVER; + cmd_client.auto_flags = CMD_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 = CVAR_SERVER; + cmd_server.cmd_flags = CMD_SERVER; + cmd_server.auto_flags = 0; + cmd_server.auto_function = NULL; + cmd_server.userdefined = &cmd_userdefined_all; + // 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 = CMD_SERVER_FROM_CLIENT | CMD_USERINFO; + cmd_serverfromclient.auto_flags = 0; + cmd_serverfromclient.auto_function = NULL; + cmd_serverfromclient.userdefined = &cmd_userdefined_null; -void Cmd_Init_Commands (void) -{ // // 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"); + // client-only commands + Cmd_AddCommand(CMD_SHARED, "wait", Cmd_Wait_f, "make script execution wait for next rendered frame"); + Cmd_AddCommand(CMD_CLIENT, "cprint", Cmd_Centerprint_f, "print something at the screen center"); + + // maintenance commands used for upkeep of cvars and saved configs + Cmd_AddCommand(CMD_SHARED, "stuffcmds", Cmd_StuffCmds_f, "execute commandline parameters (must be present in quake.rc script)"); + Cmd_AddCommand(CMD_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(CMD_SHARED, "cvar_resettodefaults_all", Cvar_ResetToDefaults_All_f, "sets all cvars to their locked default values"); + Cmd_AddCommand(CMD_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(CMD_SHARED, "cvar_resettodefaults_saveonly", Cvar_ResetToDefaults_SaveOnly_f, "sets all saved cvars to their locked default values (variables that will be saved to config.cfg)"); + + // general console commands used in multiple environments + Cmd_AddCommand(CMD_SHARED, "exec", Cmd_Exec_f, "execute a script file"); + Cmd_AddCommand(CMD_SHARED, "echo",Cmd_Echo_f, "print a message to the console (useful in scripts)"); + Cmd_AddCommand(CMD_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(CMD_SHARED, "unalias",Cmd_UnAlias_f, "remove an alias"); + Cmd_AddCommand(CMD_SHARED, "set", Cvar_Set_f, "create or change the value of a console variable"); + Cmd_AddCommand(CMD_SHARED, "seta", Cvar_SetA_f, "create or change the value of a console variable that will be saved to config.cfg"); + Cmd_AddCommand(CMD_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(CMD_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(CMD_SHARED, "cmdlist", Cmd_List_f, "lists all console commands beginning with the specified prefix or matching the specified wildcard pattern"); + Cmd_AddCommand(CMD_SHARED, "cvarlist", Cvar_List_f, "lists all console variables beginning with the specified prefix or matching the specified wildcard pattern"); + Cmd_AddCommand(CMD_SHARED, "apropos", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description"); + Cmd_AddCommand(CMD_SHARED, "find", 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 ("cprint", Cmd_Centerprint_f, "print something at the screen center"); - Cmd_AddCommand ("defer", Cmd_Defer_f, "execute a command in the future"); + Cmd_AddCommand(CMD_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(CMD_SHARED | CMD_CLIENT_FROM_SERVER, "toggle", Cmd_Toggle_f, "toggles a console variable's values (use for more info)"); } /* @@ -1210,7 +1685,19 @@ Cmd_Shutdown */ void Cmd_Shutdown(void) { - Mem_FreePool(&cmd_mempool); + cmd_iter_t *cmd_iter; + for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++) + { + 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); + } } /* @@ -1218,9 +1705,9 @@ void Cmd_Shutdown(void) Cmd_Argc ============ */ -int Cmd_Argc (void) +int Cmd_Argc (cmd_state_t *cmd) { - return cmd_argc; + return cmd->argc; } /* @@ -1228,11 +1715,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]; } /* @@ -1240,12 +1727,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 @@ -1254,12 +1740,12 @@ 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; while (1) { @@ -1283,24 +1769,24 @@ static void Cmd_TokenizeString (const char *text) if (!*text) return; - if (cmd_argc == 1) - cmd_args = 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++; } } } @@ -1311,59 +1797,130 @@ 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; + xcommand_t save = NULL; + qboolean auto_add = false; + 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 < 3; i++) { - if (!strcmp (cmd_name, cmd->name)) + cmd = cmd_iter_all[i].cmd; + if ((flags & cmd->cmd_flags) || (flags & cmd->auto_flags)) { - if (consolefunction || clientfunction) + if((flags & cmd->auto_flags) && cmd->auto_function) { - Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name); - return; + save = function; + function = cmd->auto_function; + auto_add = true; } - else //[515]: csqc + + // fail if the command is a variable name + if (Cvar_FindVar(cmd->cvars, cmd_name, ~0)) { - cmd->csqcfunc = true; + Con_Printf("Cmd_AddCommand: %s already defined as a var\n", cmd_name); return; } + + if (function) + { + // fail if the command already exists in this interpreter + for (func = cmd->engine_functions; func; func = func->next) + { + if (!strcmp(cmd_name, func->name)) + { + if(func->autofunc && !auto_add) + break; + Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name); + goto next; + } + } + + 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; + 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) + ; + if (prev) { + prev->next = func; + } + else { + cmd->engine_functions = func; + } + func->next = current; + } + else + { + // mark csqcfunc if the function already exists in the csqc_functions list + for (func = cmd->userdefined->csqc_functions; func; func = func->next) + { + if (!strcmp(cmd_name, func->name)) + { + func->csqcfunc = true; //[515]: csqc + continue; + } + } + + + func = (cmd_function_t *)Mem_Alloc(cmd->mempool, sizeof(cmd_function_t)); + func->name = cmd_name; + func->function = function; + func->description = description; + func->csqcfunc = true; //[515]: csqc + func->next = cmd->userdefined->csqc_functions; + func->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) + ; + if (prev) { + prev->next = func; + } + else { + cmd->userdefined->csqc_functions = func; + } + func->next = current; + } + if (save) + function = save; } +next: + auto_add = false; + 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; +static int Cmd_Compare(const char *s1, const char *s2, size_t len, qboolean casesensitive) +{ + if(len) + return (casesensitive ? strncmp(s1, s2, len) : strncasecmp(s1, s2, len)); + else + return (casesensitive ? strcmp(s1, s2) : strcasecmp(s1, s2)); } -void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *description) +cmd_function_t *Cmd_GetCommand(cmd_state_t *cmd, const char *partial, size_t len, qboolean casesensitive) { - Cmd_AddCommand_WithClientCommand (cmd_name, function, NULL, description); + 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; } /* @@ -1371,38 +1928,25 @@ void Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *desc Cmd_Exists ============ */ -qboolean Cmd_Exists (const char *cmd_name) +qboolean Cmd_Exists (cmd_state_t *cmd, const char *cmd_name) { - cmd_function_t *cmd; - - for (cmd=cmd_functions ; cmd ; cmd=cmd->next) - if (!strcmp (cmd_name,cmd->name)) - return true; - + if(Cmd_GetCommand(cmd, cmd_name, 0, true)) + return true; return false; } - /* ============ Cmd_CompleteCommand ============ */ -const char *Cmd_CompleteCommand (const char *partial) +const char *Cmd_CompleteCommand (cmd_state_t *cmd, const char *partial) { - cmd_function_t *cmd; - size_t len; - - len = strlen(partial); - - if (!len) - return NULL; - -// check functions - for (cmd = cmd_functions; cmd; cmd = cmd->next) - if (!strncasecmp(partial, cmd->name, len)) - return cmd->name; + cmd_function_t *func; + func = Cmd_GetCommand(cmd, partial, strlen(partial), false); + if(func) + return func->name; return NULL; } @@ -1415,9 +1959,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; @@ -1428,8 +1972,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->csqc_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; @@ -1444,34 +1992,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->csqc_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->csqc_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); } /* @@ -1483,9 +2037,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); @@ -1494,20 +2048,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); } @@ -1522,9 +2076,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; @@ -1536,7 +2090,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++; @@ -1552,18 +2106,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; @@ -1571,14 +2125,22 @@ 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 *cmd; - for (cmd=cmd_functions ; cmd ; cmd=cmd->next) - cmd->csqcfunc = false; + cmd_function_t *func; + cmd_function_t **next = &cmd->userdefined->csqc_functions; + + while(*next) + { + func = *next; + *next = func->next; + Z_Free(func); + } } -qboolean CL_VM_ConsoleCommand (const char *cmd); +extern cvar_t sv_cheats; + /* ============ Cmd_ExecuteString @@ -1587,254 +2149,77 @@ 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) +void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qboolean lockmutex) { int oldpos; - int found; - cmd_function_t *cmd; - cmdalias_t *a; + cmd_function_t *func; + cmd_alias_t *a; + if (lockmutex) + Cbuf_Lock(cmd->cbuf); + oldpos = cmd->cbuf->tokenizebufferpos; + cmd->source = src; - oldpos = cmd_tokenizebufferpos; - cmd_source = src; - found = false; - - Cmd_TokenizeString (text); + Cmd_TokenizeString (cmd, text); // execute the command line - if (!Cmd_Argc()) - { - cmd_tokenizebufferpos = oldpos; - return; // no tokens - } + if (!Cmd_Argc(cmd)) + goto done; // no tokens // check functions - for (cmd=cmd_functions ; cmd ; cmd=cmd->next) + func = Cmd_GetCommand(cmd, cmd->argv[0], 0, false); + if(func) { - if (!strcasecmp (cmd_argv[0],cmd->name)) + if (func->csqcfunc && CL_VM_ConsoleCommand(text)) //[515]: csqc + goto done; + else { - if (cmd->csqcfunc && CL_VM_ConsoleCommand (text)) //[515]: csqc - return; 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)); - } + case src_local: + if (func->function) + func->function(cmd); else - Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(0)); - found = true; - goto command_found; - break; + Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(cmd, 0)); + goto done; case src_client: - if (cmd->clientfunction) + if (func->function) { - cmd->clientfunction (); - cmd_tokenizebufferpos = oldpos; - return; + if((func->flags & CMD_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; } - break; } } -command_found: // if it's a client command and no command was found, say so. - if (cmd_source == src_client) + if (cmd->source == src_client) { - Con_Printf("player \"%s\" tried to %s\n", host_client->name, text); - cmd_tokenizebufferpos = oldpos; - return; + Con_Printf("Client \"%s\" tried to execute \"%s\"\n", host_client->name, text); + goto done; } // check alias - for (a=cmd_alias ; a ; a=a->next) + for (a=cmd->userdefined->alias ; a ; a=a->next) { - if (!strcasecmp (cmd_argv[0], a->name)) + if (!strcasecmp (cmd->argv[0], a->name)) { - Cmd_ExecuteAlias(a); - cmd_tokenizebufferpos = oldpos; - return; + Cmd_ExecuteAlias(cmd, a); + goto done; } } - if(found) // if the command was hooked and found, all is good - { - cmd_tokenizebufferpos = oldpos; - return; - } - // check cvars - if (!Cvar_Command () && host_framecount > 0) - Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(0)); - - cmd_tokenizebufferpos = oldpos; + 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_ForwardStringToServer - -Sends an entire command string over to the server, unprocessed -=================== -*/ -void Cmd_ForwardStringToServer (const char *s) -{ - char temp[128]; - if (cls.state != ca_connected) - { - Con_Printf("Can't \"%s\", not connected\n", s); - return; - } - - if (!cls.netcon) - return; - - // 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) - { - // say/say_team commands can replace % character codes with status info - while (*s) - { - if (*s == '%' && s[1]) - { - // handle proquake message macros - temp[0] = 0; - switch (s[1]) - { - case 'l': // current location - CL_Locs_FindLocationName(temp, sizeof(temp), cl.movement_origin); - break; - case 'h': // current health - dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_HEALTH]); - break; - case 'a': // current armor - dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_ARMOR]); - break; - case 'x': // current rockets - dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_ROCKETS]); - break; - case 'c': // current cells - dpsnprintf(temp, sizeof(temp), "%i", cl.stats[STAT_CELLS]); - break; - // silly proquake macros - case 'd': // loc at last death - CL_Locs_FindLocationName(temp, sizeof(temp), cl.lastdeathorigin); - break; - case 't': // current time - dpsnprintf(temp, sizeof(temp), "%.0f:%.0f", floor(cl.time / 60), cl.time - floor(cl.time / 60) * 60); - break; - case 'r': // rocket launcher status ("I have RL", "I need rockets", "I need RL") - if (!(cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER)) - dpsnprintf(temp, sizeof(temp), "I need RL"); - else if (!cl.stats[STAT_ROCKETS]) - dpsnprintf(temp, sizeof(temp), "I need rockets"); - else - dpsnprintf(temp, sizeof(temp), "I have RL"); - break; - case 'p': // powerup status (outputs "quad" "pent" and "eyes" according to status) - if (cl.stats[STAT_ITEMS] & IT_QUAD) - { - if (temp[0]) - strlcat(temp, " ", sizeof(temp)); - strlcat(temp, "quad", sizeof(temp)); - } - if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY) - { - if (temp[0]) - strlcat(temp, " ", sizeof(temp)); - strlcat(temp, "pent", sizeof(temp)); - } - if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY) - { - if (temp[0]) - strlcat(temp, " ", sizeof(temp)); - strlcat(temp, "eyes", sizeof(temp)); - } - break; - case 'w': // weapon status (outputs "SSG:NG:SNG:GL:RL:LG" with the text between : characters omitted if you lack the weapon) - if (cl.stats[STAT_ITEMS] & IT_SUPER_SHOTGUN) - strlcat(temp, "SSG", sizeof(temp)); - strlcat(temp, ":", sizeof(temp)); - if (cl.stats[STAT_ITEMS] & IT_NAILGUN) - strlcat(temp, "NG", sizeof(temp)); - strlcat(temp, ":", sizeof(temp)); - if (cl.stats[STAT_ITEMS] & IT_SUPER_NAILGUN) - strlcat(temp, "SNG", sizeof(temp)); - strlcat(temp, ":", sizeof(temp)); - if (cl.stats[STAT_ITEMS] & IT_GRENADE_LAUNCHER) - strlcat(temp, "GL", sizeof(temp)); - strlcat(temp, ":", sizeof(temp)); - if (cl.stats[STAT_ITEMS] & IT_ROCKET_LAUNCHER) - strlcat(temp, "RL", sizeof(temp)); - strlcat(temp, ":", sizeof(temp)); - if (cl.stats[STAT_ITEMS] & IT_LIGHTNING) - strlcat(temp, "LG", sizeof(temp)); - break; - default: - // not a recognized macro, print it as-is... - temp[0] = s[0]; - temp[1] = s[1]; - temp[2] = 0; - break; - } - // write the resulting text - SZ_Write(&cls.netcon->message, (unsigned char *)temp, strlen(temp)); - s += 2; - continue; - } - MSG_WriteByte(&cls.netcon->message, *s); - s++; - } - MSG_WriteByte(&cls.netcon->message, 0); - } - else // any other command is passed on as-is - SZ_Write(&cls.netcon->message, (const unsigned char *)s, (int)strlen(s) + 1); -} - -/* -=================== -Cmd_ForwardToServer - -Sends the entire command line over to the server -=================== -*/ -void Cmd_ForwardToServer (void) -{ - const char *s; - 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("%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); -} - - /* ================ Cmd_CheckParm @@ -1844,7 +2229,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; @@ -1854,10 +2239,92 @@ 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; } + + +void Cmd_SaveInitState(void) +{ + cmd_iter_t *cmd_iter; + for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++) + { + cmd_state_t *cmd = cmd_iter->cmd; + cmd_function_t *f; + cmd_alias_t *a; + for (f = cmd->userdefined->csqc_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(&cvars_all); +} + +void Cmd_RestoreInitState(void) +{ + cmd_iter_t *cmd_iter; + for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++) + { + cmd_state_t *cmd = cmd_iter->cmd; + cmd_function_t *f, **fp; + cmd_alias_t *a, **ap; + for (fp = &cmd->userdefined->csqc_functions; (f = *fp);) + { + 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 (fp = &cmd->engine_functions; (f = *fp);) + { + 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->userdefined->alias; (a = *ap);) + { + 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(&cvars_all); +}