X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=cmd.c;h=fba45672c5a341bb3d70b12c144b29ee8c4fb489;hb=468f2af6459a6222dc8bbfb4470250f7ffd00edc;hp=c353b4c854d80a250b586fc39be42452e84c07ad;hpb=aadd101471d0227217f84d3dc6ed03fec4aacd4c;p=xonotic%2Fdarkplaces.git diff --git a/cmd.c b/cmd.c index c353b4c8..fba45672 100644 --- a/cmd.c +++ b/cmd.c @@ -22,8 +22,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "quakedef.h" #include "thread.h" -cmd_state_t cmd_local; -cmd_state_t cmd_serverfromclient; +cmd_state_t *cmd_local; +cmd_state_t *cmd_serverfromclient; cmd_userdefined_t cmd_userdefined_all; cmd_userdefined_t cmd_userdefined_null; @@ -33,11 +33,7 @@ typedef struct cmd_iter_s { } cmd_iter_t; -static cmd_iter_t cmd_iter_all[] = { - {&cmd_local}, - {&cmd_serverfromclient}, - {NULL}, -}; +static cmd_iter_t *cmd_iter_all; mempool_t *cbuf_mempool; @@ -86,21 +82,21 @@ static void Cmd_Defer_f (cmd_state_t *cmd) 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) @@ -185,9 +181,9 @@ 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; } @@ -361,8 +357,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); @@ -389,8 +385,8 @@ void Cbuf_InsertText (cmd_state_t *cmd, const char *text) 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); } @@ -415,9 +411,9 @@ static void Cbuf_Execute_Deferred (cmd_buf_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) { @@ -444,14 +440,14 @@ void Cbuf_Execute (cmd_buf_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); @@ -494,8 +490,29 @@ void Cbuf_Execute (cmd_buf_t *cbuf) } } +/* +=================== +Cbuf_Frame_Input + +Add them exactly as if they had been typed at the console +=================== +*/ +static void Cbuf_Frame_Input(void) +{ + char *line; + + while ((line = Sys_ConsoleInput())) + Cbuf_AddText(cmd_local, line); +} + void Cbuf_Frame(cmd_buf_t *cbuf) { + // check for commands typed to the host + Cbuf_Frame_Input(); + +// R_TimeReport("preconsole"); + + // execute commands queued with the defer command Cbuf_Execute_Deferred(cbuf); if (cbuf->size) { @@ -503,6 +520,8 @@ void Cbuf_Frame(cmd_buf_t *cbuf) Cbuf_Execute(cbuf); SV_UnlockThreadMutex(); } + +// R_TimeReport("console"); } /* @@ -1600,6 +1619,23 @@ static void Cmd_Apropos_f(cmd_state_t *cmd) Con_Printf("%i result%s\n\n", count, (count > 1) ? "s" : ""); } +static cmd_state_t *Cmd_AddInterpreter(cmd_buf_t *cbuf, cvar_state_t *cvars, int cvars_flagsmask, int cmds_flagsmask, cmd_userdefined_t *userdefined) +{ + cmd_state_t *cmd = (cmd_state_t *)Mem_Alloc(tempmempool, sizeof(cmd_state_t)); + + cmd->mempool = Mem_AllocPool("commands", 0, NULL); + // space for commands and script files + cmd->cbuf = cbuf; + cmd->null_string = ""; + + cmd->cvars = cvars; + cmd->cvars_flagsmask = cvars_flagsmask; + cmd->cmd_flags = cmds_flagsmask; + cmd->userdefined = userdefined; + + return cmd; +} + /* ============ Cmd_Init @@ -1607,7 +1643,6 @@ Cmd_Init */ void Cmd_Init(void) { - cmd_iter_t *cmd_iter; cmd_buf_t *cbuf; cbuf_mempool = Mem_AllocPool("Command buffer", 0, NULL); cbuf = (cmd_buf_t *)Mem_Alloc(cbuf_mempool, sizeof(cmd_buf_t)); @@ -1620,29 +1655,20 @@ void Cmd_Init(void) cbuf->deferred.prev = cbuf->deferred.next = &(cbuf->deferred); cbuf->free.prev = cbuf->free.next = &(cbuf->free); - for (cmd_iter = cmd_iter_all; cmd_iter->cmd; cmd_iter++) - { - cmd_state_t *cmd = cmd_iter->cmd; - cmd->mempool = Mem_AllocPool("commands", 0, NULL); - // space for commands and script files - cmd->cbuf = cbuf; - cmd->null_string = ""; - } - // client console can see server cvars because the user may start a server - cmd_local.cvars = &cvars_all; - cmd_local.cvars_flagsmask = CF_CLIENT | CF_SERVER; - cmd_local.cmd_flags = CF_SERVER | CF_CLIENT | CF_CLIENT_FROM_SERVER; - cmd_local.auto_flags = CF_SERVER_FROM_CLIENT; - cmd_local.auto_function = CL_ForwardToServer_f; // FIXME: Move this to the client. - cmd_local.userdefined = &cmd_userdefined_all; + // FIXME: Get rid of cmd_iter_all eventually. This is just a hack to reduce the amount of work to make the interpreters dynamic. + cmd_iter_all = (cmd_iter_t *)Mem_Alloc(tempmempool, sizeof(cmd_iter_t) * 3); + + // local console + cmd_iter_all[0].cmd = cmd_local = Cmd_AddInterpreter(cbuf, &cvars_all, CF_CLIENT | CF_SERVER, CF_CLIENT | CF_CLIENT_FROM_SERVER | CF_SERVER_FROM_CLIENT, &cmd_userdefined_all); + cmd_local->Handle = Cmd_CL_Callback; + cmd_local->NotFound = NULL; + // server commands received from clients have no reason to access cvars, cvar expansion seems perilous. - cmd_serverfromclient.cvars = &cvars_null; - cmd_serverfromclient.cvars_flagsmask = 0; - cmd_serverfromclient.cmd_flags = CF_SERVER_FROM_CLIENT | CF_USERINFO; - cmd_serverfromclient.auto_flags = 0; - cmd_serverfromclient.auto_function = NULL; - cmd_serverfromclient.userdefined = &cmd_userdefined_null; + cmd_iter_all[1].cmd = cmd_serverfromclient = Cmd_AddInterpreter(cbuf, &cvars_null, 0, CF_SERVER_FROM_CLIENT | CF_USERINFO, &cmd_userdefined_null); + cmd_serverfromclient->Handle = Cmd_SV_Callback; + cmd_serverfromclient->NotFound = Cmd_SV_NotFound; + cmd_iter_all[2].cmd = NULL; // // register our commands // @@ -1811,22 +1837,13 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const cmd_function_t *func; cmd_function_t *prev, *current; cmd_state_t *cmd; - xcommand_t save = NULL; - qbool auto_add = false; int i; for (i = 0; i < 2; i++) { cmd = cmd_iter_all[i].cmd; - if ((flags & cmd->cmd_flags) || (flags & cmd->auto_flags)) + if (flags & cmd->cmd_flags) { - if((flags & cmd->auto_flags) && cmd->auto_function) - { - save = function; - function = cmd->auto_function; - auto_add = true; - } - // fail if the command is a variable name if (Cvar_FindVar(cmd->cvars, cmd_name, ~0)) { @@ -1841,10 +1858,8 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const { if (!strcmp(cmd_name, func->name)) { - if(func->autofunc && !auto_add) - break; Con_Printf("Cmd_AddCommand: %s already defined\n", cmd_name); - goto next; + continue; } } @@ -1854,7 +1869,6 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const func->function = function; func->description = description; func->next = cmd->engine_functions; - func->autofunc = auto_add; // insert it at the right alphanumeric position for (prev = NULL, current = cmd->engine_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next) @@ -1887,7 +1901,6 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const func->description = description; 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->qc_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next) @@ -1900,12 +1913,7 @@ void Cmd_AddCommand(int flags, const char *cmd_name, xcommand_t function, const } func->next = current; } - if (save) - function = save; } -next: - auto_add = false; - continue; } } @@ -2148,6 +2156,76 @@ void Cmd_ClearCSQCCommands (cmd_state_t *cmd) extern cvar_t sv_cheats; +/* + * Cloudwalk FIXME: This idea sounded great in my head but... + * How do we handle commands that can be received by the client, + * but which the server can also execute locally? + * + * If we create a callback where the engine will forward to server + * but try to execute the command locally if it's dedicated, + * we're back to intermixing client and server code which I'm + * trying to avoid. There's no other way I can think of to + * implement that behavior that doesn't involve an #ifdef, or + * making a mess of hooks. + */ +qbool Cmd_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src) +{ + if (func->function) + func->function(cmd); + else + Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(cmd, 0)); + return true; +} + +qbool Cmd_CL_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src) +{ + // TODO: Assign these functions to QC commands directly? + if(func->qcfunc) + { + if(((func->flags & CF_CLIENT) && CL_VM_ConsoleCommand(text)) || + ((func->flags & CF_SERVER) && SV_VM_ConsoleCommand(text))) + return true; + } + if (func->flags & CF_SERVER_FROM_CLIENT) + { + if(host_isclient.integer) + { + CL_ForwardToServer_f(cmd); + return true; + } + else if(!(func->flags & CF_SERVER)) + { + Con_Printf("Cannot execute client commands from a dedicated server console.\n"); + return true; + } + } + return Cmd_Callback(cmd, func, text, src); +} + +qbool Cmd_SV_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src) +{ + if(func->qcfunc && (func->flags & CF_SERVER)) + return SV_VM_ConsoleCommand(text); + else if (src == src_client) + { + if((func->flags & CF_CHEAT) && !sv_cheats.integer) + SV_ClientPrintf("No cheats allowed. The server must have sv_cheats set to 1\n"); + else + func->function(cmd); + return true; + } + return false; +} + +qbool Cmd_SV_NotFound(cmd_state_t *cmd, cmd_function_t *func, const char *text, cmd_source_t src) +{ + if (cmd->source == src_client) + { + Con_Printf("Client \"%s\" tried to execute \"%s\"\n", host_client->name, text); + return true; + } + return false; +} /* ============ Cmd_ExecuteString @@ -2177,13 +2255,8 @@ void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qb { if (!strcasecmp(cmd->argv[0], func->name)) { - if(func->qcfunc) - { - if((func->flags & CF_CLIENT) && CL_VM_ConsoleCommand(text)) - goto done; - else if((func->flags & CF_SERVER) && SV_VM_ConsoleCommand(text)) - goto done; - } + if(cmd->Handle(cmd, func, text, src)) + goto done; } } @@ -2191,33 +2264,16 @@ void Cmd_ExecuteString (cmd_state_t *cmd, const char *text, cmd_source_t src, qb { if (!strcasecmp (cmd->argv[0], func->name)) { - switch (src) - { - case src_local: - if (func->function) - func->function(cmd); - else - Con_Printf("Command \"%s\" can not be executed\n", Cmd_Argv(cmd, 0)); + if(cmd->Handle(cmd, func, text, src)) goto done; - case src_client: - if (func->function) - { - if((func->flags & CF_CHEAT) && !sv_cheats.integer) - SV_ClientPrintf("No cheats allowed. The server must have sv_cheats set to 1\n"); - else - func->function(cmd); - goto done; - } - } - break; } } // if it's a client command and no command was found, say so. - if (cmd->source == src_client) + if(cmd->NotFound) { - Con_Printf("Client \"%s\" tried to execute \"%s\"\n", host_client->name, text); - goto done; + if(cmd->NotFound(cmd, func, text, src)) + goto done; } // check alias @@ -2347,3 +2403,7 @@ void Cmd_RestoreInitState(void) } Cvar_RestoreInitState(&cvars_all); } + +void Cmd_NoOperation_f(cmd_state_t *cmd) +{ +}