cmd.h File Reference

#include "qtypes.h"
#include "qdefs.h"
#include "com_list.h"

Include dependency graph for cmd.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	cmd_alias_t
struct	cmd_buf_t
struct	cmd_function_t
struct	cmd_input_t
struct	cmd_state_t
	command interpreter state - the tokenizing and execution of commands, as well as pointers to which cvars and aliases they can access More...
struct	cmd_userdefined_t
	container for user-defined QC functions and aliases, shared between different command interpreters More...

Macros
#define	CF_ALLOCATED   (1u<<31)
	created by Cvar_Get() (console or QC)
#define	CF_ARCHIVE   (1u<<5)
	cvar should have its set value saved to config.cfg and persist across sessions
#define	CF_CHEAT   (1u<<4)
	command or cvar that gives an unfair advantage over other players and is blocked unless sv_cheats is 1
#define	CF_CLIENT   (1u<<0)
	cvar/command that only the client can change/execute
#define	CF_CLIENT_FROM_SERVER   (1u<<2)
	command that the server is allowed to execute on the client
#define	CF_DEFAULTSET   (1u<<30)
#define	CF_MAXFLAGSVAL   ((1u<<12) - 1)
	used to determine if flags is valid
#define	CF_NONE   0u
#define	CF_NOTIFY   (1u<<7)
	cvar should trigger a chat notification to all connected clients when changed
#define	CF_PERSISTENT   (1u<<10)
	cvar must not be reset on gametype switch (such as scr_screenshot_name, which otherwise isn't set to the mod name properly)
#define	CF_PRIVATE   (1u<<11)
	cvar should not be $ expanded or sent to the server under any circumstances (rcon_password, etc)
#define	CF_READONLY   (1u<<6)
	cvar cannot be changed from the console or the command buffer, and is considered CF_PERSISTENT
#define	CF_REGISTERED   (1u<<29)
	created by Cvar_RegisterVariable()
#define	CF_SERVER   (1u<<1)
	cvar/command that only the server can change/execute
#define	CF_SERVER_FROM_CLIENT   (1u<<3)
	command the client is allowed to execute on the server as a stringcmd
#define	CF_SERVERINFO   (1u<<8)
	command or cvar relevant to serverinfo string handling
#define	CF_SHARED   (CF_CLIENT | CF_SERVER)
#define	CF_USERINFO   (1u<<9)
	command or cvar used to communicate userinfo to the server

Typedefs
typedef void(*	xcommand_t) (struct cmd_state_s *cmd)

Enumerations
enum	cmd_source_t { src_client , src_local }

Functions
void	Cbuf_AddText (cmd_state_t *cmd, const char *text)
void	Cbuf_Clear (cmd_buf_t *cbuf)
	Clears all command buffers.
void	Cbuf_Execute (cmd_buf_t *cbuf)
void	Cbuf_Frame (cmd_buf_t *cbuf)
void	Cbuf_InsertText (cmd_state_t *cmd, const char *text)
void	Cbuf_Lock (cmd_buf_t *cbuf)
void	Cbuf_Unlock (cmd_buf_t *cbuf)
void	Cmd_AddCommand (unsigned flags, const char *cmd_name, xcommand_t function, const char *description)
	called by the init functions of other parts of the program to register commands and functions to call for them.
static int	Cmd_Argc (cmd_state_t *cmd)
static const char *	Cmd_Args (cmd_state_t *cmd)
static const char *	Cmd_Argv (cmd_state_t *cmd, int arg)
	Cmd_Argv(cmd, ) will return an empty string (not a NULL) if arg > argc, so string operations are always safe.
qbool	Cmd_Callback (cmd_state_t *cmd, cmd_function_t *func)
int	Cmd_CheckParm (cmd_state_t *cmd, const char *parm)
	Returns the position (1 to argc-1) in the command's argument list where the given parameter apears, or 0 if not present.
qbool	Cmd_CL_Callback (cmd_state_t *cmd, cmd_function_t *func, const char *text, size_t textlen, cmd_source_t src)
void	Cmd_ClearCSQCCommands (cmd_state_t *cmd)
const char *	Cmd_CompleteAlias (cmd_state_t *cmd, const char *partial)
const char **	Cmd_CompleteAliasBuildList (cmd_state_t *cmd, const char *partial)
int	Cmd_CompleteAliasCountPossible (cmd_state_t *cmd, const char *partial)
void	Cmd_CompleteAliasPrint (cmd_state_t *cmd, const char *partial)
const char **	Cmd_CompleteBuildList (cmd_state_t *cmd, const char *partial)
const char *	Cmd_CompleteCommand (cmd_state_t *cmd, const char *partial)
	attempts to match a partial command for automatic command line completion returns NULL if nothing fits
void	Cmd_CompleteCommandPrint (cmd_state_t *cmd, const char *partial)
int	Cmd_CompleteCountPossible (cmd_state_t *cmd, const char *partial)
void	Cmd_ExecuteString (cmd_state_t *cmd, const char *text, size_t textlen, cmd_source_t src, qbool lockmutex)
	Parses a single line of text into arguments and tries to execute it.
qbool	Cmd_Exists (cmd_state_t *cmd, const char *cmd_name)
	used by the cvar code to check for cvar / command name overlap
void	Cmd_Init (void)
	Command execution takes a null terminated string, breaks it into tokens, then searches for a command or variable that matches the first token.
void	Cmd_NoOperation_f (cmd_state_t *cmd)
void	Cmd_PreprocessAndExecuteString (cmd_state_t *cmd, const char *text, size_t textlen, cmd_source_t src, qbool lockmutex)
	Like Cmd_ExecuteString, but with variable expansion.
qbool	Cmd_QuoteString (char *out, size_t outlen, const char *in, const char *quoteset, qbool putquotes)
	quotes a string so that it can be used as a command argument again; quoteset is a string that contains one or more of ", \, $ and specifies the characters to be quoted (you usually want to either pass ""\" or ""\$").
void	Cmd_RestoreInitState (void)
	Restores cvars, commands and aliases to their init values and deletes any that were added since init.
void	Cmd_SaveInitState (void)
	called by Host_Init, this marks cvars, commands and aliases with their init values
void	Cmd_Shutdown (void)
qbool	Cmd_SV_Callback (cmd_state_t *cmd, cmd_function_t *func, const char *text, size_t textlen, cmd_source_t src)

Variables
cmd_state_t *	cmd_local
	command interpreter for local commands injected by SVQC, CSQC, MQC, server or client engine code uses cmddefs_all
cmd_state_t *	cmd_serverfromclient
	command interpreter for server commands received over network from clients uses cmddefs_null
cmd_userdefined_t	cmd_userdefined_all
	aliases and csqc functions
cmd_userdefined_t	cmd_userdefined_null
	intentionally empty
qbool	host_stuffcmdsrun

Macro Definition Documentation

CF_ALLOCATED

#define CF_ALLOCATED   (1u<<31)

created by Cvar_Get() (console or QC)

Definition at line 64 of file cmd.h.

Referenced by Cvar_Delete(), Cvar_Get(), Cvar_RegisterVariable(), Cvar_SetQuick(), Cvar_WriteVariables(), and VM_cvar_type().

CF_ARCHIVE

#define CF_ARCHIVE   (1u<<5)

cvar should have its set value saved to config.cfg and persist across sessions

Definition at line 53 of file cmd.h.

Referenced by Cvar_ResetToDefaults_NoSaveOnly_f(), Cvar_ResetToDefaults_SaveOnly_f(), Cvar_SetA_f(), Cvar_WriteVariables(), and VM_cvar_type().

CF_CHEAT

#define CF_CHEAT   (1u<<4)

command or cvar that gives an unfair advantage over other players and is blocked unless sv_cheats is 1

Definition at line 52 of file cmd.h.

Referenced by Cmd_SV_Callback(), and SV_InitOperatorCommands().

CF_CLIENT

#define CF_CLIENT   (1u<<0)

cvar/command that only the client can change/execute

Definition at line 48 of file cmd.h.

Referenced by CDAudio_Init(), CL_Demo_Init(), CL_Init(), CL_InitCommands(), CL_InitInput(), CL_Parse_Init(), CL_Particles_Init(), CL_Screen_Init(), CL_SendCvar_f(), CL_Video_Init(), Cmd_CL_Callback(), Cmd_Init(), Con_CompleteCommandLine(), Con_Init(), Curl_Init_Commands(), gl_backend_init(), GL_Draw_Init(), GL_Main_Init(), GL_Surf_Init(), Key_Console(), Key_Init(), Key_Parse_CommonKeys(), LoadSubtitles(), M_Init(), Mod_Init(), Mod_VBSP_Load(), MR_Init_Commands(), NetConn_Init(), R_Modules_Init(), R_Shadow_EditLights_Init(), R_Sky_Init(), R_Textures_Init(), S_Init(), Sbar_Init(), SV_Init(), V_Init(), VID_Shared_Init(), VM_CL_registercmd(), and VM_M_registercommand().

CF_CLIENT_FROM_SERVER

#define CF_CLIENT_FROM_SERVER   (1u<<2)

command that the server is allowed to execute on the client

Definition at line 50 of file cmd.h.

Referenced by CDAudio_Init(), CL_Init(), CL_InitCommands(), CL_Parse_Init(), Cmd_Init(), Curl_Init_Commands(), and V_Init().

CF_DEFAULTSET

#define CF_DEFAULTSET   (1u<<30)

Definition at line 63 of file cmd.h.

Referenced by Cvar_LockDefaults_f(), and Cvar_WriteVariables().

CF_MAXFLAGSVAL

#define CF_MAXFLAGSVAL   ((1u<<12) - 1)

used to determine if flags is valid

Definition at line 60 of file cmd.h.

Referenced by VM_registercvar().

CF_NONE

#define CF_NONE   0u

Definition at line 47 of file cmd.h.

CF_NOTIFY

#define CF_NOTIFY   (1u<<7)

cvar should trigger a chat notification to all connected clients when changed

Definition at line 55 of file cmd.h.

Referenced by Cvar_SetQuick_Internal(), and NetConn_ServerParsePacket().

CF_PERSISTENT

#define CF_PERSISTENT   (1u<<10)

cvar must not be reset on gametype switch (such as scr_screenshot_name, which otherwise isn't set to the mod name properly)

Definition at line 58 of file cmd.h.

Referenced by Cvar_ResetToDefaults_All_f(), Cvar_ResetToDefaults_NoSaveOnly_f(), Cvar_ResetToDefaults_SaveOnly_f(), Cvar_RestoreInitState(), and Cvar_SaveInitState().

CF_PRIVATE

#define CF_PRIVATE   (1u<<11)

cvar should not be $ expanded or sent to the server under any circumstances (rcon_password, etc)

Definition at line 59 of file cmd.h.

Referenced by CL_SendCvar_f(), Cmd_GetDirectCvarValue(), Cvar_PrintHelp(), PRVM_Cvar_ReadOk(), PRVM_Prog_Load(), and VM_cvar_type().

CF_READONLY

#define CF_READONLY   (1u<<6)

cvar cannot be changed from the console or the command buffer, and is considered CF_PERSISTENT

Definition at line 54 of file cmd.h.

Referenced by Cvar_Readonly(), Cvar_ResetToDefaults_All_f(), Cvar_ResetToDefaults_NoSaveOnly_f(), Cvar_ResetToDefaults_SaveOnly_f(), Cvar_RestoreInitState(), Cvar_SaveInitState(), GL_Setup(), VM_cvar_set(), and VM_cvar_type().

CF_REGISTERED

#define CF_REGISTERED   (1u<<29)

created by Cvar_RegisterVariable()

Definition at line 62 of file cmd.h.

Referenced by Cvar_RegisterVariable(), and Cvar_SetQuick().

CF_SERVER

#define CF_SERVER   (1u<<1)

cvar/command that only the server can change/execute

Definition at line 49 of file cmd.h.

Referenced by CL_Init(), CL_SendCvar_f(), Cmd_CL_Callback(), Cmd_Init(), Cmd_SV_Callback(), Con_CompleteCommandLine(), Key_Console(), Key_Parse_CommonKeys(), LoadSubtitles(), Mod_VBSP_Load(), NetConn_Init(), SV_InitOperatorCommands(), SV_Status_f(), and VM_SV_registercommand().

CF_SERVER_FROM_CLIENT

#define CF_SERVER_FROM_CLIENT   (1u<<3)

command the client is allowed to execute on the server as a stringcmd

Definition at line 51 of file cmd.h.

Referenced by Cmd_CL_Callback(), Cmd_Init(), SV_Init(), and SV_InitOperatorCommands().

CF_SERVERINFO

#define CF_SERVERINFO   (1u<<8)

command or cvar relevant to serverinfo string handling

Definition at line 56 of file cmd.h.

Referenced by Cvar_SetQuick_Internal().

CF_SHARED

#define CF_SHARED   (CF_CLIENT | CF_SERVER)

Definition at line 67 of file cmd.h.

Referenced by CL_InitCommands(), Cmd_Init(), Con_Init(), Crypto_Init_Commands(), FS_Init_Commands(), Host_InitLocal(), Memory_Init_Commands(), NetConn_Init(), PRVM_Init(), SV_Init(), SV_InitOperatorCommands(), and Sys_EM_Register_Commands().

CF_USERINFO

#define CF_USERINFO   (1u<<9)

command or cvar used to communicate userinfo to the server

Definition at line 57 of file cmd.h.

Referenced by Cmd_Init(), Cvar_SetQuick_Internal(), and SV_InitOperatorCommands().

Typedef Documentation

xcommand_t

typedef void(* xcommand_t) (struct cmd_state_s *cmd)

Definition at line 69 of file cmd.h.

Enumeration Type Documentation

cmd_source_t

enum cmd_source_t

Enumerator
src_client	came in over a net connection as a clc_stringcmd host_client will be valid during this state.
src_local	from the command buffer

Definition at line 71 of file cmd.h.

{
    src_client,  
    src_local    
} cmd_source_t;

Function Documentation

Cbuf_AddText()

void Cbuf_AddText	(	cmd_state_t *	cmd,
		const char *	text )

as new commands are generated from the console or keybindings, the text is added to the end of the command buffer.

Definition at line 264 of file cmd.c.

{
    size_t l = strlen(text);
    cmd_buf_t *cbuf = cmd->cbuf;
    llist_t llist = {&llist, &llist};
 
    if (cbuf->size + l > cbuf->maxsize)
    {
        Con_Printf(CON_WARN "Cbuf_AddText: input too large, %luKB ought to be enough for anybody.\n", (unsigned long)(cbuf->maxsize / 1024));
        return;
    }
 
    Cbuf_Lock(cbuf);
 
    // If the string terminates but the (last) line doesn't, the node will be left in the pending state (to be continued).
    Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.prev, cmd_input_t, list)), text, true);
    List_Splice_Tail(&llist, &cbuf->start);
 
    Cbuf_Unlock(cbuf);
}

References Cbuf_Lock(), Cbuf_ParseText(), Cbuf_Unlock(), cmd(), Con_Printf(), CON_WARN, List_Entry, List_Is_Empty(), List_Splice_Tail(), cmd_buf_t::maxsize, NULL, llist_t::prev, cmd_buf_t::size, cmd_buf_t::start, and strlen().

Referenced by Cbuf_Execute_Deferred(), CL_FinishTimeDemo(), CL_SignonReply(), CL_VM_Parse_StuffCmd(), Curl_CheckCommandWhenDone(), Host_Init(), Key_Console(), Key_Event(), M_Demo_Key(), M_GameOptions_Key(), M_LanConfig_Key(), M_Load_Key(), M_Main_Key(), M_Menu_Options_Graphics_AdjustSliders(), M_Options_Key(), M_Reset_Key(), M_Save_Key(), M_ServerList_Key(), M_Setup_Key(), M_SinglePlayer_Key(), M_Transfusion_Episode_Key(), M_Transfusion_Skill_Key(), M_Video_Key(), VM_changelevel(), VM_coredump(), and VM_localcmd().

Cbuf_Clear()

void Cbuf_Clear

(

cmd_buf_t *

cbuf

)

Clears all command buffers.

Definition at line 436 of file cmd.c.

{
    while (!List_Is_Empty(&cbuf->start))
        List_Move_Tail(cbuf->start.next, &cbuf->free);
    while (!List_Is_Empty(&cbuf->deferred))
        List_Move_Tail(cbuf->deferred.next, &cbuf->free);
    cbuf->size = 0;
}

References cmd_buf_t::deferred, cmd_buf_t::free, List_Is_Empty(), List_Move_Tail(), llist_t::next, cmd_buf_t::size, and cmd_buf_t::start.

Referenced by Cbuf_Execute(), Host_Error(), and MVM_error_cmd().

Cbuf_Execute()

void Cbuf_Execute

(

cmd_buf_t *

cbuf

)

Pulls off terminated lines of text from the command buffer and sends them through Cmd_ExecuteString. Stops when the buffer is empty. Normally called once per frame, but may be explicitly invoked.

Note

Do not call inside a command function!

Definition at line 351 of file cmd.c.

{
    cmd_input_t *current;
    unsigned int i = 0;
 
    // LadyHavoc: making sure the tokenizebuffer doesn't get filled up by repeated crashes
    cbuf->tokenizebufferpos = 0;
 
    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_Entry(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;
 
        Cmd_PreprocessAndExecuteString(current->source, current->text, current->length, src_local, false);
        cbuf->size -= current->length;
        // Recycle memory so using WASD doesn't cause a malloc and free
        List_Move_Tail(&current->list, &cbuf->free);
 
        if (cbuf->wait)
        {
            /*
             * Skip out while text still remains in
             * buffer, leaving it for next frame
             */
            cbuf->wait = false;
            break;
        }
 
        if (++i == 1000000 && prvm_runawaycheck)
        {
            Con_Printf(CON_WARN "Cbuf_Execute: runaway loop counter hit limit of %d commands, clearing command buffers!\n", i);
            Cbuf_Clear(cbuf);
        }
    }
}

References Cbuf_Clear(), Cmd_PreprocessAndExecuteString(), Con_Printf(), CON_WARN, cmd_buf_t::free, i, cmd_input_t::length, cmd_input_t::list, List_Entry, List_Is_Empty(), List_Move_Tail(), llist_t::next, cmd_input_t::pending, prvm_runawaycheck, cmd_buf_t::size, cmd_input_t::source, src_local, cmd_buf_t::start, cmd_input_t::text, cmd_buf_t::tokenizebufferpos, and cmd_buf_t::wait.

Referenced by Cbuf_Frame(), CL_ReadDemoMessage(), and Host_Init().

Cbuf_Frame()

void Cbuf_Frame

(

cmd_buf_t *

cbuf

)

Performs deferred commands and runs Cbuf_Execute, called by Host_Frame

Definition at line 417 of file cmd.c.

{
    // 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)
    {
        SV_LockThreadMutex();
        Cbuf_Execute(cbuf);
        SV_UnlockThreadMutex();
    }
 
//  R_TimeReport("console");
}

References Cbuf_Execute(), Cbuf_Execute_Deferred(), Cbuf_Frame_Input(), cmd_buf_t::size, SV_LockThreadMutex, and SV_UnlockThreadMutex.

Referenced by Host_Frame().

Cbuf_InsertText()

void Cbuf_InsertText	(	cmd_state_t *	cmd,
		const char *	text )

when a command wants to issue other commands immediately, the text is inserted at the beginning of the buffer, before any remaining unexecuted commands.

Definition at line 292 of file cmd.c.

{
    cmd_buf_t *cbuf = cmd->cbuf;
    llist_t llist = {&llist, &llist};
    size_t l = strlen(text);
 
    if (cbuf->size + l > cbuf->maxsize)
    {
        Con_Printf(CON_WARN "Cbuf_InsertText: input too large, %luKB ought to be enough for anybody.\n", (unsigned long)(cbuf->maxsize / 1024));
        return;
    }
 
    Cbuf_Lock(cbuf);
 
    // bones_was_here assertion: when prepending to the buffer it never makes sense to leave node(s) in the `pending` state,
    // it would have been impossible to append to such text later in the old raw text buffer,
    // and allowing it causes bugs when .cfg files lack \n at EOF (see: https://gitlab.com/xonotic/darkplaces/-/issues/378).
    Cbuf_ParseText(cmd, &llist, (List_Is_Empty(&cbuf->start) ? NULL : List_Entry(cbuf->start.next, cmd_input_t, list)), text, false);
    List_Splice(&llist, &cbuf->start);
 
    Cbuf_Unlock(cbuf);
}

References Cbuf_Lock(), Cbuf_ParseText(), Cbuf_Unlock(), cmd(), Con_Printf(), CON_WARN, List_Entry, List_Is_Empty(), List_Splice(), cmd_buf_t::maxsize, llist_t::next, NULL, cmd_buf_t::size, cmd_buf_t::start, and strlen().

Referenced by Cbuf_Frame_Input(), CL_NextDemo(), Cmd_Exec(), Cmd_ExecuteAlias(), Cmd_StuffCmds_f(), FS_ChangeGameDirs(), Host_AddConfigText(), Key_Console(), Key_Event(), and M_Keys_Key().

Cbuf_Lock()

void Cbuf_Lock

(

cmd_buf_t *

cbuf

)

Definition at line 45 of file cmd.c.

{
    Thread_LockMutex(cbuf->lock);
}

References cmd_buf_t::lock, and Thread_LockMutex.

Referenced by Cbuf_AddText(), Cbuf_InsertText(), Cmd_Defer_f(), and Cmd_ExecuteString().

Cbuf_Unlock()

void Cbuf_Unlock

(

cmd_buf_t *

cbuf

)

Definition at line 50 of file cmd.c.

{
    Thread_UnlockMutex(cbuf->lock);
}

References cmd_buf_t::lock, and Thread_UnlockMutex.

Referenced by Cbuf_AddText(), Cbuf_InsertText(), Cmd_Defer_f(), Cmd_ExecuteString(), and Cmd_Shutdown().

Cmd_AddCommand()

void Cmd_AddCommand	(	unsigned	flags,
		const char *	cmd_name,
		xcommand_t	function,
		const char *	description )

called by the init functions of other parts of the program to register commands and functions to call for them.

The cmd_name is referenced later, so it should not be in temp memory

Definition at line 1661 of file cmd.c.

{
    cmd_function_t *func;
    cmd_function_t *prev, *current;
    cmd_state_t *cmd;
    int i;
 
    for (i = 0; i < 2; i++)
    {
        cmd = cmd_iter_all[i].cmd;
        if (flags & cmd->cmd_flagsmask)
        {
            // fail if the command is a variable name
            if (Cvar_FindVar(cmd->cvars, cmd_name, ~0))
            {
                Con_Printf(CON_WARN "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))
                    {
                        Con_Printf(CON_WARN "Cmd_AddCommand: %s already defined\n", cmd_name);
                        continue;
                    }
                }
 
                func = (cmd_function_t *)Mem_Alloc(cmd->mempool, sizeof(cmd_function_t));
                func->flags = flags;
                func->name = cmd_name;
                func->function = function;
                func->description = description;
                func->next = cmd->engine_functions;
 
                // 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 qcfunc if the function already exists in the qc_functions list
                for (func = cmd->userdefined->qc_functions; func; func = func->next)
                {
                    if (!strcmp(cmd_name, func->name))
                    {
                        func->qcfunc = true; //[515]: csqc
                        continue;
                    }
                }
 
                func = (cmd_function_t *)Mem_Alloc(cmd->mempool, sizeof(cmd_function_t));
                func->flags = flags;
                func->name = cmd_name;
                func->function = function;
                func->description = description;
                func->qcfunc = true; //[515]: csqc
                func->next = cmd->userdefined->qc_functions;
 
                // bones_was_here: if this QC command overrides an engine command, store its pointer
                // to avoid doing this search at invocation if QC declines to handle this command.
                for (cmd_function_t *f = cmd->engine_functions; f; f = f->next)
                {
                    if (!strcmp(cmd_name, f->name))
                    {
                        Con_DPrintf("Adding QC override of engine command %s\n", cmd_name);
                        func->overridden = f;
                        break;
                    }
                }
 
                // insert it at the right alphanumeric position
                for (prev = NULL, current = cmd->userdefined->qc_functions; current && strcmp(current->name, func->name) < 0; prev = current, current = current->next)
                    ;
                if (prev) {
                    prev->next = func;
                }
                else {
                    cmd->userdefined->qc_functions = func;
                }
                func->next = current;
            }
        }
    }
}

References cmd(), cmd_iter_t::cmd, cmd_iter_all, Con_DPrintf(), Con_Printf(), CON_WARN, Cvar_FindVar(), cmd_function_t::description, f, cmd_function_t::flags, flags, cmd_function_t::function, i, Mem_Alloc, cmd_function_t::name, cmd_function_t::next, NULL, cmd_function_t::overridden, and cmd_function_t::qcfunc.

Referenced by CDAudio_Init(), CL_Demo_Init(), CL_Init(), CL_InitCommands(), CL_InitInput(), CL_Parse_Init(), CL_Particles_Init(), CL_Screen_Init(), CL_Video_Init(), Cmd_Init(), Con_Init(), Crypto_Init_Commands(), Curl_Init_Commands(), FS_Init_Commands(), gl_backend_init(), GL_Draw_Init(), GL_Main_Init(), GL_Surf_Init(), Host_InitLocal(), Key_Init(), M_Init(), Memory_Init_Commands(), Mod_Init(), MR_Init_Commands(), NetConn_Init(), PRVM_Init(), R_Modules_Init(), R_Shadow_EditLights_Init(), R_Sky_Init(), R_Textures_Init(), S_Init(), Sbar_Init(), SV_Init(), SV_InitOperatorCommands(), Sys_EM_Register_Commands(), V_Init(), VID_Shared_Init(), VM_CL_registercmd(), VM_M_registercommand(), and VM_SV_registercommand().

Cmd_Argc()

static int Cmd_Argc ( cmd_state_t * cmd )

inlinestatic

Definition at line 249 of file cmd.h.

{
    return cmd->argc;
}

References cmd().

Referenced by Call_MR_ToggleMenu_f(), CD_f(), CL_Color_f(), CL_Connect_f(), CL_Disconnect_f(), CL_DownloadBegin_f(), CL_DownloadFinished_f(), CL_EstablishConnection(), CL_Fog_f(), CL_Fog_HeightTexture_f(), CL_ForwardToServer_f(), CL_FullInfo_f(), CL_FullServerinfo_f(), CL_IPLog_List_f(), CL_Locs_Add_f(), CL_Name_f(), CL_Packet_f(), CL_Particles_LoadEffectInfo_f(), CL_PingPLReport_f(), CL_PlayDemo_f(), CL_PlayVideo_f(), CL_PQRcon_f(), CL_Rcon_f(), CL_Reconnect_f(), CL_Record_f(), CL_SendCvar_f(), CL_SetInfo_f(), CL_Startdemos_f(), CL_TimeDemo_f(), CL_User_f(), Cmd_Alias_f(), Cmd_Apropos_f(), Cmd_CheckParm(), Cmd_Defer_f(), Cmd_Echo_f(), Cmd_Exec_f(), Cmd_ExecuteString(), Cmd_GetDirectCvarValue(), Cmd_List_f(), Cmd_StuffCmds_f(), Cmd_Toggle_f(), Cmd_UnAlias_f(), Con_ConDump_f(), Con_Maps_f(), Con_MsgCmdMode(), Crypto_HostKey_Clear_f(), Crypto_KeyGen_f(), Curl_Curl_f(), Cvar_Command(), Cvar_Del_f(), Cvar_List_f(), Cvar_Set_f(), Cvar_SetA_f(), Download_CheckExtensions(), FS_GameDir_f(), FS_ListDirectoryCmd(), FS_Which_f(), GL_TextureMode_f(), Host_SaveConfig_f(), Image_FixTransparentPixels_f(), IN_BestWeapon_f(), IN_BestWeapon_Register_f(), Key_Bind_f(), Key_History_f(), Key_In_Bind_f(), Key_In_BindList_f(), Key_In_Bindmap_f(), Key_In_Unbind_f(), Key_Unbind_f(), LoadFont_f(), LoadSky_f(), MemList_f(), Mod_Decompile_f(), Mod_GenerateLightmaps_f(), Mod_Precache_f(), PRVM_Breakpoint_f(), PRVM_CallProfile_f(), PRVM_ChildProfile_f(), PRVM_ED_Count_f(), PRVM_ED_EdictGet_f(), PRVM_ED_EdictSet_f(), PRVM_ED_GlobalGet_f(), PRVM_ED_PrintEdict_f(), PRVM_ED_PrintEdicts_f(), PRVM_EdictWatchpoint_f(), PRVM_Fields_f(), PRVM_GameCommand(), PRVM_Global_f(), PRVM_Globals_f(), PRVM_GlobalSet_f(), PRVM_GlobalWatchpoint_f(), PRVM_PrintFunction_f(), PRVM_Profile_f(), R_Envmap_f(), R_ReplaceWorldTexture_f(), R_Shadow_EditLights_Edit_f(), R_Shadow_EditLights_Spawn_f(), S_PauseSound_f(), S_Play_Common(), SCR_Centerprint_f(), SCR_InfoBar_f(), SCR_ScreenShot_f(), SV_Changelevel_f(), SV_Download_f(), SV_Ent_Create_f(), SV_Ent_Remove_f(), SV_Kick_f(), SV_Loadgame_f(), SV_Map_f(), SV_MaxPlayers_f(), SV_Name_f(), SV_Playermodel_f(), SV_Playerskin_f(), SV_PModel_f(), SV_Rate_BurstSize_f(), SV_Restart_f(), SV_Savegame_f(), SV_Say(), SV_SendCvar_f(), SV_Status_f(), SV_Tell_f(), and V_BonusFlash_f().

Cmd_Args()

static const char * Cmd_Args ( cmd_state_t * cmd )

inlinestatic

Definition at line 260 of file cmd.h.

{
    return cmd->args;
}

References cmd().

Referenced by CL_ForwardToServer_f(), CL_Name_f(), CL_PQRcon_f(), CL_Rcon_f(), Cmd_Apropos_f(), Cmd_GetDirectCvarValue(), Con_MsgCmdMode(), PRVM_GameCommand(), SV_Kick_f(), SV_Name_f(), SV_Playermodel_f(), SV_Playerskin_f(), SV_Say(), and SV_Tell_f().

Cmd_Argv()

static const char * Cmd_Argv ( cmd_state_t * cmd, int arg )

inlinestatic

Cmd_Argv(cmd, ) will return an empty string (not a NULL) if arg > argc, so string operations are always safe.

Definition at line 254 of file cmd.h.

{
    if (arg >= cmd->argc )
        return cmd->null_string;
    return cmd->argv[arg];
}

References cmd().

Referenced by Call_MR_ToggleMenu_f(), CD_f(), CL_Color_f(), CL_Connect_f(), CL_Disconnect_f(), CL_DownloadBegin_f(), CL_DownloadFinished_f(), CL_EstablishConnection(), CL_Fog_f(), CL_Fog_HeightTexture_f(), CL_ForwardToServer_f(), CL_FullInfo_f(), CL_FullServerinfo_f(), CL_IPLog_List_f(), CL_Locs_Add_f(), CL_Name_f(), CL_Packet_f(), CL_Particles_LoadEffectInfo_f(), CL_PingPLReport_f(), CL_PlayDemo_f(), CL_PlayVideo_f(), CL_PQRcon_f(), CL_Rcon_f(), CL_Record_f(), CL_SendCvar_f(), CL_SetInfo_f(), CL_Startdemos_f(), CL_TimeDemo_f(), CL_User_f(), Cmd_Alias_f(), Cmd_Apropos_f(), Cmd_Callback(), Cmd_CheckParm(), Cmd_Defer_f(), Cmd_Echo_f(), Cmd_Exec_f(), Cmd_ExecuteString(), Cmd_GetDirectCvarValue(), Cmd_List_f(), Cmd_Toggle_f(), Cmd_UnAlias_f(), Con_ConDump_f(), Con_Maps_f(), Crypto_HostKey_Clear_f(), Crypto_KeyGen_f(), Curl_Curl_f(), Cvar_Command(), Cvar_Del_f(), Cvar_List_f(), Cvar_Set_f(), Cvar_SetA_f(), Download_CheckExtensions(), FS_GameDir_f(), FS_ListDirectoryCmd(), FS_Which_f(), GL_TextureMode_f(), Host_SaveConfig_f(), Image_FixTransparentPixels_f(), IN_BestWeapon_f(), IN_BestWeapon_Register_f(), IN_Impulse(), Key_Bind_f(), Key_History_f(), Key_In_Bind_f(), Key_In_BindList_f(), Key_In_Bindmap_f(), Key_In_Unbind_f(), Key_Unbind_f(), KeyDown(), KeyUp(), LoadFont_f(), LoadSky_f(), MemList_f(), Mod_Decompile_f(), Mod_Precache_f(), PRVM_Breakpoint_f(), PRVM_CallProfile_f(), PRVM_ChildProfile_f(), PRVM_ED_Count_f(), PRVM_ED_EdictGet_f(), PRVM_ED_EdictSet_f(), PRVM_ED_GlobalGet_f(), PRVM_ED_PrintEdict_f(), PRVM_ED_PrintEdicts_f(), PRVM_EdictWatchpoint_f(), PRVM_Fields_f(), PRVM_Global_f(), PRVM_Globals_f(), PRVM_GlobalSet_f(), PRVM_GlobalWatchpoint_f(), PRVM_PrintFunction_f(), PRVM_Profile_f(), R_Envmap_f(), R_ReplaceWorldTexture_f(), R_Shadow_EditLights_Edit_f(), S_PauseSound_f(), S_Play_Common(), SCR_Centerprint_f(), SCR_InfoBar_f(), SCR_ScreenShot_f(), SV_Changelevel_f(), SV_Color_f(), SV_Download_f(), SV_Ent_Create_f(), SV_Ent_Remove_All_f(), SV_Ent_Remove_f(), SV_Give_f(), SV_Kick_f(), SV_Loadgame_f(), SV_Map_f(), SV_MaxPlayers_f(), SV_Name_f(), SV_Playermodel_f(), SV_Playerskin_f(), SV_PModel_f(), SV_Rate_BurstSize_f(), SV_Rate_f(), SV_Savegame_f(), SV_SendCvar_f(), SV_Status_f(), SV_Viewframe_f(), SV_Viewmodel_f(), V_BonusFlash_f(), and V_cshift_f().

Cmd_Callback()

qbool Cmd_Callback	(	cmd_state_t *	cmd,
		cmd_function_t *	func )

Definition at line 2008 of file cmd.c.

{
    if (func->function)
        func->function(cmd);
    else
        Con_Printf(CON_WARN "Command \"%s\" can not be executed\n", Cmd_Argv(cmd, 0));
    return true;
}

References cmd(), Cmd_Argv(), Con_Printf(), CON_WARN, and cmd_function_t::function.

Referenced by Cmd_CL_Callback().

Cmd_CheckParm()

int Cmd_CheckParm	(	cmd_state_t *	cmd,
		const char *	parm )

Returns the position (1 to argc-1) in the command's argument list where the given parameter apears, or 0 if not present.

Definition at line 2140 of file cmd.c.

{
    int i;
 
    if (!parm)
    {
        Con_Printf(CON_WARN "Cmd_CheckParm: NULL");
        return 0;
    }
 
    for (i = 1; i < Cmd_Argc (cmd); i++)
        if (!strcasecmp (parm, Cmd_Argv(cmd, i)))
            return i;
 
    return 0;
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), CON_WARN, and i.

Cmd_CL_Callback()

qbool Cmd_CL_Callback	(	cmd_state_t *	cmd,
		cmd_function_t *	func,
		const char *	text,
		size_t	textlen,
		cmd_source_t	src )

Definition at line 2017 of file cmd.c.

{
    // TODO: Assign these functions to QC commands directly?
    if(func->qcfunc)
    {
        if(((func->flags & CF_CLIENT) && CL_VM_ConsoleCommand(text, textlen)) ||
           ((func->flags & CF_SERVER) && SV_VM_ConsoleCommand(text, textlen)))
            return true;
 
        if (func->overridden) // If this QC command overrides an engine command,
            func = func->overridden; // fall back to that command.
    }
    if (func->flags & CF_SERVER_FROM_CLIENT)
    {
        if(host_isclient.integer)
        {
            CL_ForwardToServer_f(cmd);
            return true;
        }
        else if(!(func->flags & CF_SERVER))
        {
            Con_Printf(CON_WARN "Cannot execute client commands from a dedicated server console.\n");
            return true;
        }
    }
    return Cmd_Callback(cmd, func);
}

References CF_CLIENT, CF_SERVER, CF_SERVER_FROM_CLIENT, CL_ForwardToServer_f(), CL_VM_ConsoleCommand(), cmd(), Cmd_Callback(), Con_Printf(), CON_WARN, cmd_function_t::flags, host_isclient, cvar_t::integer, cmd_function_t::overridden, cmd_function_t::qcfunc, and SV_VM_ConsoleCommand().

Referenced by Cmd_Init().

Cmd_ClearCSQCCommands()

void Cmd_ClearCSQCCommands

(

cmd_state_t *

cmd

)

Definition at line 1981 of file cmd.c.

{
    cmd_function_t *func;
    cmd_function_t **next = &cmd->userdefined->qc_functions;
    
    while(*next)
    {
        func = *next;
        *next = func->next;
        Z_Free(func);
    }
}

References cmd(), cmd_function_t::next, and Z_Free.

Referenced by CL_VM_ShutDown().

Cmd_CompleteAlias()

const char * Cmd_CompleteAlias	(	cmd_state_t *	cmd,
		const char *	partial )

Definition at line 1892 of file cmd.c.

{
    cmd_alias_t *alias;
    size_t len;
 
    len = strlen(partial);
 
    if (!len)
        return NULL;
 
    // Check functions
    for (alias = cmd->userdefined->alias; alias; alias = alias->next)
        if (!strncasecmp(partial, alias->name, len))
            return alias->name;
 
    return NULL;
}

References cmd(), cmd_alias_t::name, cmd_alias_t::next, NULL, and strlen().

Cmd_CompleteAliasBuildList()

const char ** Cmd_CompleteAliasBuildList	(	cmd_state_t *	cmd,
		const char *	partial )

Definition at line 1961 of file cmd.c.

{
    cmd_alias_t *alias;
    size_t len = 0;
    size_t bpos = 0;
    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->userdefined->alias; alias; alias = alias->next)
        if (!strncasecmp(partial, alias->name, len))
            buf[bpos++] = alias->name;
 
    buf[bpos] = NULL;
    return buf;
}

References buf, cmd(), Cmd_CompleteAliasCountPossible(), Mem_Alloc, cmd_alias_t::name, cmd_alias_t::next, NULL, strlen(), and tempmempool.

Referenced by Con_CompleteCommandLine().

Cmd_CompleteAliasCountPossible()

int Cmd_CompleteAliasCountPossible	(	cmd_state_t *	cmd,
		const char *	partial )

Definition at line 1931 of file cmd.c.

{
    cmd_alias_t *alias;
    size_t      len;
    int         h;
 
    h = 0;
 
    len = strlen(partial);
 
    if (!len)
        return 0;
 
    // Loop through the command list and count all partial matches
    for (alias = cmd->userdefined->alias; alias; alias = alias->next)
        if (!strncasecmp(partial, alias->name, len))
            h++;
 
    return h;
}

References cmd(), cmd_alias_t::name, cmd_alias_t::next, and strlen().

Referenced by Cmd_CompleteAliasBuildList(), and Con_CompleteCommandLine().

Cmd_CompleteAliasPrint()

void Cmd_CompleteAliasPrint	(	cmd_state_t *	cmd,
		const char *	partial )

Definition at line 1911 of file cmd.c.

{
    cmd_alias_t *alias;
    size_t len = strlen(partial);
    // Loop through the alias list and print all matches
    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);
}

References cmd(), Con_Printf(), cmd_alias_t::name, cmd_alias_t::next, strlen(), and cmd_alias_t::value.

Referenced by Con_CompleteCommandLine().

Cmd_CompleteBuildList()

const char ** Cmd_CompleteBuildList	(	cmd_state_t *	cmd,
		const char *	partial )

Definition at line 1847 of file cmd.c.

{
    cmd_function_t *func;
    size_t len = 0;
    size_t bpos = 0;
    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 functions lists and print all matches
    for (func = cmd->userdefined->qc_functions; func; func = func->next)
        if (!strncasecmp(partial, func->name, len))
            buf[bpos++] = func->name;
    for (func = cmd->engine_functions; func; func = func->next)
        if (!strncasecmp(partial, func->name, len))
            buf[bpos++] = func->name;
 
    buf[bpos] = NULL;
    return buf;
}

References buf, cmd(), Cmd_CompleteCountPossible(), Mem_Alloc, cmd_function_t::name, cmd_function_t::next, NULL, strlen(), and tempmempool.

Referenced by Con_CompleteCommandLine().

Cmd_CompleteCommand()

const char * Cmd_CompleteCommand	(	cmd_state_t *	cmd,
		const char *	partial )

attempts to match a partial command for automatic command line completion returns NULL if nothing fits

Definition at line 1783 of file cmd.c.

{
    cmd_function_t *func;
    size_t len;
 
    len = strlen(partial);
 
    if (!len)
        return NULL;
 
// check functions
    for (func = cmd->userdefined->qc_functions; func; func = func->next)
        if (!strncasecmp(partial, func->name, len))
            return func->name;
 
    for (func = cmd->engine_functions; func; func = func->next)
        if (!strncasecmp(partial, func->name, len))
            return func->name;
 
    return NULL;
}

References cmd(), cmd_function_t::name, cmd_function_t::next, NULL, and strlen().

Cmd_CompleteCommandPrint()

void Cmd_CompleteCommandPrint	(	cmd_state_t *	cmd,
		const char *	partial )

Definition at line 1870 of file cmd.c.

{
    cmd_function_t *func;
    size_t len = strlen(partial);
    // Loop through the command list and print all matches
    for (func = cmd->userdefined->qc_functions; func; func = func->next)
        if (!strncasecmp(partial, func->name, len))
            Con_Printf("^2%s^7: %s\n", func->name, func->description);
    for (func = cmd->engine_functions; func; func = func->next)
        if (!strncasecmp(partial, func->name, len))
            Con_Printf("^2%s^7: %s\n", func->name, func->description);
}

References cmd(), Con_Printf(), cmd_function_t::description, cmd_function_t::name, cmd_function_t::next, and strlen().

Referenced by Con_CompleteCommandLine().

Cmd_CompleteCountPossible()

int Cmd_CompleteCountPossible	(	cmd_state_t *	cmd,
		const char *	partial )

Definition at line 1814 of file cmd.c.

{
    cmd_function_t *func;
    size_t len;
    int h;
 
    h = 0;
    len = strlen(partial);
 
    if (!len)
        return 0;
 
    // Loop through the command list and count all partial matches
    for (func = cmd->userdefined->qc_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;
}

References cmd(), cmd_function_t::name, cmd_function_t::next, and strlen().

Referenced by Cmd_CompleteBuildList(), and Con_CompleteCommandLine().

Cmd_ExecuteString()

void Cmd_ExecuteString	(	cmd_state_t *	cmd,
		const char *	text,
		size_t	textlen,
		cmd_source_t	src,
		qbool	lockmutex )

Parses a single line of text into arguments and tries to execute it.

The text can come from the command buffer, a remote client, or stdin.

Definition at line 2068 of file cmd.c.

{
    int oldpos;
    cmd_function_t *func;
    cmd_alias_t *a;
 
    if (lockmutex)
        Cbuf_Lock(cmd->cbuf);
    oldpos = cmd->cbuf->tokenizebufferpos;
    cmd->source = src;
 
    Cmd_TokenizeString (cmd, text);
 
// execute the command line
    if (!Cmd_Argc(cmd))
        goto done; // no tokens
 
// check functions
    for (func = cmd->userdefined->qc_functions; func; func = func->next)
        if (!strcasecmp(cmd->argv[0], func->name))
            if(cmd->Handle(cmd, func, text, textlen, src))
                goto functions_done;
 
    for (func = cmd->engine_functions; func; func=func->next)
        if (!strcasecmp (cmd->argv[0], func->name))
            if(cmd->Handle(cmd, func, text, textlen, src))
                goto functions_done;
 
functions_done:
    // If it's a client command and wasn't found and handled, say so.
    // Also don't let clients call server aliases.
    if (cmd->source == src_client)
    {
        if (!func)
            Con_Printf("Client \"%s\" tried to execute \"%s\"\n", host_client->name, text);
        goto done;
    }
 
// check alias
    // Execute any alias with the same name as a command after the command.
    for (a=cmd->userdefined->alias ; a ; a=a->next)
    {
        if (!strcasecmp (cmd->argv[0], a->name))
        {
            Cmd_ExecuteAlias(cmd, a);
            goto done;
        }
    }
 
    // If the command was found and handled don't try to handle it as a cvar.
    if (func)
        goto done;
 
// check cvars
    // Xonotic is still maintained so we don't want to hide problems from getting fixed
    if (!Cvar_Command(cmd) && (host.framecount > 0 || gamemode == GAME_XONOTIC))
        Con_Printf(CON_WARN "Unknown command \"%s\"\n", Cmd_Argv(cmd, 0));
done:
    cmd->cbuf->tokenizebufferpos = oldpos;
    if (lockmutex)
        Cbuf_Unlock(cmd->cbuf);
}

References a, Cbuf_Lock(), Cbuf_Unlock(), cmd(), Cmd_Argc(), Cmd_Argv(), Cmd_ExecuteAlias(), Cmd_TokenizeString(), Con_Printf(), CON_WARN, Cvar_Command(), host_static_t::framecount, GAME_XONOTIC, gamemode, host, host_client, client_t::name, cmd_function_t::name, cmd_function_t::next, src, and src_client.

Referenced by CL_ParseServerMessage(), CL_Record_f(), CL_VM_Parse_StuffCmd(), Cmd_PreprocessAndExecuteString(), Key_Message(), SV_ReadClientMessage(), and VM_SV_clientcommand().

Cmd_Exists()

qbool Cmd_Exists	(	cmd_state_t *	cmd,
		const char *	cmd_name )

used by the cvar code to check for cvar / command name overlap

Definition at line 1762 of file cmd.c.

{
    cmd_function_t  *func;
 
    for (func = cmd->userdefined->qc_functions; func; func = func->next)
        if (!strcmp(cmd_name, func->name))
            return true;
 
    for (func=cmd->engine_functions ; func ; func=func->next)
        if (!strcmp (cmd_name,func->name))
            return true;
 
    return false;
}

References cmd(), cmd_function_t::name, and cmd_function_t::next.

Referenced by Cvar_Get(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), and VM_registercvar().

Cmd_Init()

void Cmd_Init

(

void

)

Command execution takes a null terminated string, breaks it into tokens, then searches for a command or variable that matches the first token.

Commands can come from three sources, but the handler functions may choose to dissallow the action or forward it to a remote server if the source is not apropriate.

Definition at line 1492 of file cmd.c.

{
    cmd_buf_t *cbuf;
    unsigned cvars_flagsmask, cmds_flagsmask;
 
    cbuf_mempool = Mem_AllocPool("Command buffer", 0, NULL);
    cbuf = (cmd_buf_t *)Mem_Alloc(cbuf_mempool, sizeof(cmd_buf_t));
    cbuf->maxsize = CMDBUFSIZE;
    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);
 
    // 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
    if (cls.state == ca_dedicated)
    {
        cvars_flagsmask = CF_SERVER;
        cmds_flagsmask = CF_SERVER | CF_SERVER_FROM_CLIENT;
    }
    else
    {
        cvars_flagsmask = CF_CLIENT | CF_SERVER;
        cmds_flagsmask = CF_CLIENT | CF_SERVER | CF_CLIENT_FROM_SERVER | CF_SERVER_FROM_CLIENT;
    }
    cmd_iter_all[0].cmd = cmd_local = Cmd_AddInterpreter(cbuf, &cvars_all, cvars_flagsmask, cmds_flagsmask, &cmd_userdefined_all);
    cmd_local->Handle = Cmd_CL_Callback;
 
    // server commands received from clients have no reason to access cvars, cvar expansion seems perilous.
    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_iter_all[2].cmd = NULL;
//
// register our commands
//
    // client-only commands
    Cmd_AddCommand(CF_SHARED, "wait", Cmd_Wait_f, "make script execution wait for next rendered frame");
 
    // maintenance commands used for upkeep of cvars and saved configs
    Cmd_AddCommand(CF_SHARED, "stuffcmds", Cmd_StuffCmds_f, "execute commandline parameters (must be present in quake.rc script)");
    Cmd_AddCommand(CF_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(CF_SHARED, "cvar_resettodefaults_all", Cvar_ResetToDefaults_All_f, "sets all cvars to their locked default values");
    Cmd_AddCommand(CF_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(CF_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(CF_SHARED, "exec", Cmd_Exec_f, "execute a script file");
    Cmd_AddCommand(CF_SHARED, "echo",Cmd_Echo_f, "print a message to the console (useful in scripts)");
    Cmd_AddCommand(CF_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(CF_SHARED, "unalias",Cmd_UnAlias_f, "remove an alias");
    Cmd_AddCommand(CF_SHARED, "set", Cvar_Set_f, "create or change the value of a console variable");
    Cmd_AddCommand(CF_SHARED, "seta", Cvar_SetA_f, "create or change the value of a console variable that will be saved to config.cfg");
    Cmd_AddCommand(CF_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(CF_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(CF_SHARED, "cmdlist", Cmd_List_f, "lists all console commands beginning with the specified prefix or matching the specified wildcard pattern");
    Cmd_AddCommand(CF_SHARED, "cvarlist", Cvar_List_f, "lists all console variables beginning with the specified prefix or matching the specified wildcard pattern");
    Cmd_AddCommand(CF_SHARED, "apropos", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description");
    Cmd_AddCommand(CF_SHARED, "find", Cmd_Apropos_f, "lists all console variables/commands/aliases containing the specified string in the name or description");
 
    Cmd_AddCommand(CF_SHARED, "defer", Cmd_Defer_f, "execute a command in the future");
 
    // DRESK - 5/14/06
    // Support Doom3-style Toggle Command
    Cmd_AddCommand(CF_SHARED | CF_CLIENT_FROM_SERVER, "toggle", Cmd_Toggle_f, "toggles a console variable's values (use for more info)");
}

References ca_dedicated, host_static_t::cbuf, cbuf_mempool, CF_CLIENT, CF_CLIENT_FROM_SERVER, CF_SERVER, CF_SERVER_FROM_CLIENT, CF_SHARED, CF_USERINFO, cls, cmd_iter_t::cmd, Cmd_AddCommand(), Cmd_AddInterpreter(), Cmd_Alias_f(), Cmd_Apropos_f(), Cmd_CL_Callback(), Cmd_Defer_f(), Cmd_Echo_f(), Cmd_Exec_f(), cmd_iter_all, Cmd_List_f(), cmd_local, cmd_serverfromclient, Cmd_StuffCmds_f(), Cmd_SV_Callback(), Cmd_Toggle_f(), Cmd_UnAlias_f(), cmd_userdefined_all, cmd_userdefined_null, Cmd_Wait_f(), CMDBUFSIZE, Cvar_Del_f(), Cvar_List_f(), Cvar_LockDefaults_f(), Cvar_ResetToDefaults_All_f(), Cvar_ResetToDefaults_NoSaveOnly_f(), Cvar_ResetToDefaults_SaveOnly_f(), Cvar_Set_f(), Cvar_SetA_f(), cvars_all, cvars_null, cmd_buf_t::deferred, cmd_buf_t::free, cmd_state_t::Handle, host, cmd_buf_t::lock, cmd_buf_t::maxsize, Mem_Alloc, Mem_AllocPool, llist_t::next, NULL, llist_t::prev, cmd_buf_t::start, client_static_t::state, tempmempool, Thread_CreateMutex, and cmd_buf_t::wait.

Referenced by Host_Init().

Cmd_NoOperation_f()

void Cmd_NoOperation_f

(

cmd_state_t *

cmd

)

Definition at line 2240 of file cmd.c.

{
}

Referenced by S_Init().

Cmd_PreprocessAndExecuteString()

void Cmd_PreprocessAndExecuteString	(	cmd_state_t *	cmd,
		const char *	text,
		size_t	textlen,
		cmd_source_t	src,
		qbool	lockmutex )

Like Cmd_ExecuteString, but with variable expansion.

Definition at line 1323 of file cmd.c.

{
    char preprocessed[MAX_INPUTLINE];
    size_t preprocessed_len;
    const char *firstchar;
 
    firstchar = 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((preprocessed_len = Cmd_PreprocessString(cmd, text, preprocessed, sizeof(preprocessed), NULL)))
            Cmd_ExecuteString(cmd, preprocessed, preprocessed_len, src, lockmutex);
    }
    else
        Cmd_ExecuteString(cmd, text, textlen, src, lockmutex);
}

References cmd(), Cmd_ExecuteString(), Cmd_PreprocessString(), ISWHITESPACE, MAX_INPUTLINE, NULL, and src.

Referenced by Cbuf_Execute(), and RCon_Execute().

Cmd_QuoteString()

qbool Cmd_QuoteString	(	char *	out,
		size_t	outlen,
		const char *	in,
		const char *	quoteset,
		qbool	putquotes )

quotes a string so that it can be used as a command argument again; quoteset is a string that contains one or more of ", \, $ and specifies the characters to be quoted (you usually want to either pass ""\" or ""\$").

Returns true on success, and false on overrun (in which case out will contain a part of the quoted string). If putquotes is set, the enclosing quote marks are also put.

Definition at line 1000 of file cmd.c.

{
    qbool quote_quot = !!strchr(quoteset, '"');
    qbool quote_backslash = !!strchr(quoteset, '\\');
    qbool 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)
                goto fail;
            *out++ = '\\'; --outlen;
            *out++ = '"'; --outlen;
        }
        else if(*in == '\\' && quote_backslash)
        {
            if(outlen <= 2)
                goto fail;
            *out++ = '\\'; --outlen;
            *out++ = '\\'; --outlen;
        }
        else if(*in == '$' && quote_dollar)
        {
            if(outlen <= 2)
                goto fail;
            *out++ = '$'; --outlen;
            *out++ = '$'; --outlen;
        }
        else
        {
            if(outlen <= 1)
                goto fail;
            *out++ = *in; --outlen;
        }
        ++in;
    }
    if(putquotes)
        *out++ = '"';
    *out++ = 0;
    return true;
fail:
    if(putquotes)
        *out++ = '"';
    *out++ = 0;
    return false;
}

Referenced by Cmd_ExecuteAlias(), Cmd_GetCvarValue(), Cvar_WriteVariables(), Key_PrintBindList(), and Key_WriteBindings().

Cmd_RestoreInitState()

void Cmd_RestoreInitState

(

void

)

Restores cvars, commands and aliases to their init values and deletes any that were added since init.

Definition at line 2180 of file cmd.c.

{
    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->qc_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);
}

References a, cmd(), cmd_iter_t::cmd, cmd_iter_all, Con_DPrintf(), Cvar_RestoreInitState(), cvars_all, f, Mem_strdup, cmd_alias_t::next, Z_Free, and zonemempool.

Referenced by Host_LoadConfig_f().

Cmd_SaveInitState()

void Cmd_SaveInitState

(

void

)

called by Host_Init, this marks cvars, commands and aliases with their init values

Definition at line 2159 of file cmd.c.

{
    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->qc_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);
}

References a, cmd(), cmd_iter_t::cmd, cmd_iter_all, Cvar_SaveInitState(), cvars_all, f, Mem_strdup, and zonemempool.

Referenced by Host_Init().

Cmd_Shutdown()

void Cmd_Shutdown

(

void

)

Definition at line 1575 of file cmd.c.

{
    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);
    }
}

References Cbuf_Unlock(), cmd(), cmd_iter_t::cmd, cmd_iter_all, and Mem_FreePool.

Referenced by Host_Shutdown().

Cmd_SV_Callback()

qbool Cmd_SV_Callback	(	cmd_state_t *	cmd,
		cmd_function_t *	func,
		const char *	text,
		size_t	textlen,
		cmd_source_t	src )

Definition at line 2045 of file cmd.c.

{
    if(func->qcfunc && (func->flags & CF_SERVER))
        return SV_VM_ConsoleCommand(text, textlen);
    else if (src == src_client)
    {
        if((func->flags & CF_CHEAT) && !sv_cheats.integer)
            SV_ClientPrintf(CON_WARN "No cheats allowed. The server must have sv_cheats set to 1\n");
        else
            func->function(cmd);
        return true;
    }
    return false;
}

References CF_CHEAT, CF_SERVER, cmd(), CON_WARN, cmd_function_t::flags, cmd_function_t::function, cvar_t::integer, cmd_function_t::qcfunc, src, src_client, sv_cheats, SV_ClientPrintf(), and SV_VM_ConsoleCommand().

Referenced by Cmd_Init().

Variable Documentation

cmd_local

cmd_state_t* cmd_local

extern

command interpreter for local commands injected by SVQC, CSQC, MQC, server or client engine code uses cmddefs_all

Definition at line 25 of file cmd.c.

Referenced by Cbuf_Frame_Input(), CL_DisconnectEx(), CL_EstablishConnection(), CL_FinishTimeDemo(), CL_NextDemo(), CL_Parse_ErrorCleanUp(), CL_ParseServerInfo(), CL_ParseServerMessage(), CL_ReadDemoMessage(), CL_SetupWorldModel(), CL_SignonReply(), CL_VM_Init(), CL_VM_Parse_StuffCmd(), CL_VM_ShutDown(), Cmd_Init(), Curl_CheckCommandWhenDone(), Cvar_Get(), Cvar_RegisterCallback(), Cvar_RegisterVariable(), Cvar_RegisterVirtual(), FS_ChangeGameDirs(), gl_main_shutdown(), Host_Error(), Host_Init(), IN_Move_TouchScreen_Quake(), Key_Event(), M_KeyEvent(), M_ToggleMenu(), MP_Init(), MVM_error_cmd(), QW_CL_StartUpload(), R_RenderView(), R_Shadow_EditLights_EditAll_f(), r_shadow_newmap(), R_Shadow_SetShadowMode(), RCon_Execute(), SV_VM_Setup(), Sys_Error(), VM_changelevel(), VM_coredump(), VM_localcmd(), and VM_registercvar().

cmd_serverfromclient

cmd_state_t* cmd_serverfromclient

extern

command interpreter for server commands received over network from clients uses cmddefs_null

Definition at line 26 of file cmd.c.

Referenced by Cmd_Init(), SV_ReadClientMessage(), and VM_SV_clientcommand().

cmd_userdefined_all

cmd_userdefined_t cmd_userdefined_all

extern

aliases and csqc functions

Definition at line 28 of file cmd.c.

Referenced by Cmd_Init().

cmd_userdefined_null

cmd_userdefined_t cmd_userdefined_null

extern

intentionally empty

Definition at line 29 of file cmd.c.

Referenced by Cmd_Init().

host_stuffcmdsrun

qbool host_stuffcmdsrun

extern

Definition at line 41 of file cmd.c.

Referenced by Cmd_StuffCmds_f().