cmd.c File Reference

#include "qcommon.h"

Go to the source code of this file.

Classes
struct	cmdalias_s
struct	cmd_function_s

Macros
#define	MAX_ALIAS_NAME   32
#define	ALIAS_LOOP_COUNT   16

Typedefs
typedef struct cmdalias_s	cmdalias_t
typedef struct cmd_function_s	cmd_function_t

Functions
void	Cmd_ForwardToServer (void)
void	Cmd_Wait_f (void)
void	Cbuf_Init (void)
void	Cbuf_AddText (char *text)
void	Cbuf_InsertText (char *text)
void	Cbuf_CopyToDefer (void)
void	Cbuf_InsertFromDefer (void)
void	Cbuf_ExecuteText (int exec_when, char *text)
void	Cbuf_Execute (void)
void	Cbuf_AddEarlyCommands (qboolean clear)
qboolean	Cbuf_AddLateCommands (void)
void	Cmd_Exec_f (void)
void	Cmd_Echo_f (void)
void	Cmd_Alias_f (void)
int	Cmd_Argc (void)
char *	Cmd_Argv (int arg)
char *	Cmd_Args (void)
char *	Cmd_MacroExpandString (char *text)
void	Cmd_TokenizeString (char *text, qboolean macroExpand)
void	Cmd_AddCommand (char *cmd_name, xcommand_t function)
void	Cmd_RemoveCommand (char *cmd_name)
qboolean	Cmd_Exists (char *cmd_name)
char *	Cmd_CompleteCommand (char *partial)
void	Cmd_ExecuteString (char *text)
void	Cmd_List_f (void)
void	Cmd_Init (void)

Variables
cmdalias_t *	cmd_alias
qboolean	cmd_wait
int	alias_count
sizebuf_t	cmd_text
byte	cmd_text_buf [8192]
char	defer_text_buf [8192]
static int	cmd_argc
static char *	cmd_argv [MAX_STRING_TOKENS]
static char *	cmd_null_string = ""
static char	cmd_args [MAX_STRING_CHARS]
static cmd_function_t *	cmd_functions

Macro Definition Documentation

ALIAS_LOOP_COUNT

#define ALIAS_LOOP_COUNT   16

Definition at line 39 of file cmd.c.

MAX_ALIAS_NAME

#define MAX_ALIAS_NAME   32

Definition at line 26 of file cmd.c.

Typedef Documentation

cmd_function_t

typedef struct cmd_function_s cmd_function_t

cmdalias_t

typedef struct cmdalias_s cmdalias_t

Function Documentation

Cbuf_AddEarlyCommands()

void Cbuf_AddEarlyCommands

(

qboolean

clear

)

Definition at line 263 of file cmd.c.

{
    int     i;
    char    *s;
 
    for (i=0 ; i<COM_Argc() ; i++)
    {
        s = COM_Argv(i);
        if (strcmp (s, "+set"))
            continue;
        Cbuf_AddText (va("set %s %s\n", COM_Argv(i+1), COM_Argv(i+2)));
        if (clear)
        {
            COM_ClearArgv(i);
            COM_ClearArgv(i+1);
            COM_ClearArgv(i+2);
        }
        i+=2;
    }
}

Referenced by Qcommon_Init().

Cbuf_AddLateCommands()

qboolean Cbuf_AddLateCommands

(

void

)

Definition at line 296 of file cmd.c.

{
    int     i, j;
    int     s;
    char    *text, *build, c;
    int     argc;
    qboolean    ret;
 
// build the combined string to parse from
    s = 0;
    argc = COM_Argc();
    for (i=1 ; i<argc ; i++)
    {
        s += strlen (COM_Argv(i)) + 1;
    }
    if (!s)
        return false;
        
    text = Z_Malloc (s+1);
    text[0] = 0;
    for (i=1 ; i<argc ; i++)
    {
        strcat (text,COM_Argv(i));
        if (i != argc-1)
            strcat (text, " ");
    }
    
// pull out the commands
    build = Z_Malloc (s+1);
    build[0] = 0;
    
    for (i=0 ; i<s-1 ; i++)
    {
        if (text[i] == '+')
        {
            i++;
 
            for (j=i ; (text[j] != '+') && (text[j] != '-') && (text[j] != 0) ; j++)
                ;
 
            c = text[j];
            text[j] = 0;
            
            strcat (build, text+i);
            strcat (build, "\n");
            text[j] = c;
            i = j-1;
        }
    }
 
    ret = (build[0] != 0);
    if (ret)
        Cbuf_AddText (build);
    
    Z_Free (text);
    Z_Free (build);
 
    return ret;
}

Referenced by Qcommon_Init().

Cbuf_AddText()

void Cbuf_AddText

(

char *

text

)

Definition at line 90 of file cmd.c.

{
    int     l;
    
    l = strlen (text);
 
    if (cmd_text.cursize + l >= cmd_text.maxsize)
    {
        Com_Printf ("Cbuf_AddText: overflow\n");
        return;
    }
    SZ_Write (&cmd_text, text, strlen (text));
}

Referenced by Cbuf_AddEarlyCommands(), Cbuf_AddLateCommands(), Cbuf_ExecuteText(), Cbuf_InsertText(), CL_ConnectionlessPacket(), CL_ParseServerMessage(), Con_ToggleConsole_f(), ConsoleFunc(), ControlsResetDefaultsFunc(), FS_ExecAutoexec(), FS_SetGamedir(), JoinServerFunc(), Key_Console(), Key_Event(), Key_Message(), LoadGameCallback(), Qcommon_Frame(), Qcommon_Init(), SaveGameCallback(), StartGame(), StartServerActionFunc(), SV_InitGameProgs(), and SV_Nextserver().

Cbuf_CopyToDefer()

void Cbuf_CopyToDefer

(

void

)

Definition at line 147 of file cmd.c.

{
    memcpy(defer_text_buf, cmd_text_buf, cmd_text.cursize);
    defer_text_buf[cmd_text.cursize] = 0;
    cmd_text.cursize = 0;
}

Referenced by SV_Map().

Cbuf_Execute()

void Cbuf_Execute

(

void

)

Definition at line 194 of file cmd.c.

{
    int     i;
    char    *text;
    char    line[1024];
    int     quotes;
 
    alias_count = 0;        // don't allow infinite alias loops
 
    while (cmd_text.cursize)
    {
// find a \n or ; line break
        text = (char *)cmd_text.data;
 
        quotes = 0;
        for (i=0 ; i< cmd_text.cursize ; i++)
        {
            if (text[i] == '"')
                quotes++;
            if ( !(quotes&1) &&  text[i] == ';')
                break;  // don't break if inside a quoted string
            if (text[i] == '\n')
                break;
        }
            
                
        memcpy (line, text, i);
        line[i] = 0;
        
// 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
 
        if (i == cmd_text.cursize)
            cmd_text.cursize = 0;
        else
        {
            i++;
            cmd_text.cursize -= i;
            memmove (text, text+i, cmd_text.cursize);
        }
 
// execute the command line
        Cmd_ExecuteString (line);
        
        if (cmd_wait)
        {
            // skip out while text still remains in buffer, leaving it
            // for next frame
            cmd_wait = false;
            break;
        }
    }
}

Referenced by CL_Init(), CL_ParseServerMessage(), CL_SendCommand(), ControlsResetDefaultsFunc(), Qcommon_Frame(), and Qcommon_Init().

Cbuf_ExecuteText()

void Cbuf_ExecuteText	(	int	exec_when,
		char *	text
	)

Definition at line 171 of file cmd.c.

{
    switch (exec_when)
    {
    case EXEC_NOW:
        Cmd_ExecuteString (text);
        break;
    case EXEC_INSERT:
        Cbuf_InsertText (text);
        break;
    case EXEC_APPEND:
        Cbuf_AddText (text);
        break;
    default:
        Com_Error (ERR_FATAL, "Cbuf_ExecuteText: bad exec_when");
    }
}

Referenced by VID_LoadRefresh().

Cbuf_Init()

void Cbuf_Init

(

void

)

Definition at line 78 of file cmd.c.

{
    SZ_Init (&cmd_text, cmd_text_buf, sizeof(cmd_text_buf));
}

Referenced by Qcommon_Init().

Cbuf_InsertFromDefer()

void Cbuf_InsertFromDefer

(

void

)

Definition at line 159 of file cmd.c.

{
    Cbuf_InsertText (defer_text_buf);
    defer_text_buf[0] = 0;
}

Referenced by SV_Begin_f().

Cbuf_InsertText()

void Cbuf_InsertText

(

char *

text

)

Definition at line 114 of file cmd.c.

{
    char    *temp;
    int     templen;
 
// copy off any commands still remaining in the exec buffer
    templen = cmd_text.cursize;
    if (templen)
    {
        temp = Z_Malloc (templen);
        memcpy (temp, cmd_text.data, templen);
        SZ_Clear (&cmd_text);
    }
    else
        temp = NULL;    // shut up compiler
        
// add the entire text of the file
    Cbuf_AddText (text);
    
// add the copied off data
    if (templen)
    {
        SZ_Write (&cmd_text, temp, templen);
        Z_Free (temp);
    }
}

Referenced by Cbuf_ExecuteText(), Cbuf_InsertFromDefer(), Cmd_Exec_f(), Cmd_ExecuteString(), and Keys_MenuKey().

Cmd_AddCommand()

void Cmd_AddCommand	(	char *	cmd_name,
		xcommand_t	function
	)

Definition at line 691 of file cmd.c.

{
    cmd_function_t  *cmd;
    
// fail if the command is a variable name
    if (Cvar_VariableString(cmd_name)[0])
    {
        Com_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)
    {
        if (!strcmp (cmd_name, cmd->name))
        {
            Com_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
            return;
        }
    }
 
    cmd = Z_Malloc (sizeof(cmd_function_t));
    cmd->name = cmd_name;
    cmd->function = function;
    cmd->next = cmd_functions;
    cmd_functions = cmd;
}

Referenced by CDAudio_RandomPlay(), CL_InitInput(), CL_InitLocal(), Cmd_Init(), Con_Init(), Cvar_Init(), FS_InitFilesystem(), IN_Init(), Key_Init(), M_Init(), Qcommon_Init(), S_Init(), SCR_Init(), SV_InitOperatorCommands(), V_Init(), VID_Init(), and VID_LoadRefresh().

Cmd_Alias_f()

void Cmd_Alias_f

(

void

)

Definition at line 425 of file cmd.c.

{
    cmdalias_t  *a;
    char        cmd[1024];
    int         i, c;
    char        *s;
 
    if (Cmd_Argc() == 1)
    {
        Com_Printf ("Current alias commands:\n");
        for (a = cmd_alias ; a ; a=a->next)
            Com_Printf ("%s : %s\n", a->name, a->value);
        return;
    }
 
    s = Cmd_Argv(1);
    if (strlen(s) >= MAX_ALIAS_NAME)
    {
        Com_Printf ("Alias name is too long\n");
        return;
    }
 
    // if the alias already exists, reuse it
    for (a = cmd_alias ; a ; a=a->next)
    {
        if (!strcmp(s, a->name))
        {
            Z_Free (a->value);
            break;
        }
    }
 
    if (!a)
    {
        a = Z_Malloc (sizeof(cmdalias_t));
        a->next = cmd_alias;
        cmd_alias = a;
    }
    strcpy (a->name, s);    
 
// 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++)
    {
        strcat (cmd, Cmd_Argv(i));
        if (i != (c - 1))
            strcat (cmd, " ");
    }
    strcat (cmd, "\n");
    
    a->value = CopyString (cmd);
}

Referenced by Cmd_Init().

Cmd_Argc()

int Cmd_Argc

(

void

)

Definition at line 507 of file cmd.c.

{
    return cmd_argc;
}

Referenced by CDAudio_RandomPlay(), CL_Connect_f(), CL_Download_f(), CL_ForwardToServer_f(), CL_Packet_f(), CL_Precache_f(), CL_Rcon_f(), CL_Record_f(), CL_Setenv_f(), Cmd_Alias_f(), Cmd_Echo_f(), Cmd_Exec_f(), Cmd_ExecuteString(), Cmd_ForwardToServer(), Con_Dump_f(), Cvar_Command(), Cvar_Set_f(), FS_Dir_f(), FS_Link_f(), Key_Bind_f(), Key_Unbind_f(), S_Play(), SCR_Sky_f(), SCR_TimeRefresh_f(), SV_BeginDownload_f(), SV_ConSay_f(), SV_DumpUser_f(), SV_GameMap_f(), SV_InitGameProgs(), SV_Kick_f(), SV_Loadgame_f(), SV_Savegame_f(), SV_ServerRecord_f(), SV_SetMaster_f(), SV_SetPlayer(), SVC_RemoteCommand(), V_Gun_Model_f(), and VID_LoadRefresh().

Cmd_Args()

char* Cmd_Args

(

void

)

Definition at line 531 of file cmd.c.

{
    return cmd_args;
}

Referenced by CL_ForwardToServer_f(), Cmd_ForwardToServer(), SV_ConSay_f(), and SV_InitGameProgs().

Cmd_Argv()

char* Cmd_Argv

(

int

arg

)

Definition at line 517 of file cmd.c.

{
    if ( (unsigned)arg >= cmd_argc )
        return cmd_null_string;
    return cmd_argv[arg];   
}

Referenced by CDAudio_RandomPlay(), CL_Connect_f(), CL_ConnectionlessPacket(), CL_Download_f(), CL_ForwardToServer_f(), CL_Packet_f(), CL_Precache_f(), CL_Rcon_f(), CL_Record_f(), CL_Setenv_f(), Cmd_Alias_f(), Cmd_Echo_f(), Cmd_Exec_f(), Cmd_ForwardToServer(), Com_Error_f(), Con_Dump_f(), Cvar_Command(), Cvar_Set_f(), FS_Dir_f(), FS_Link_f(), IN_Impulse(), Key_Bind_f(), Key_Unbind_f(), KeyDown(), KeyUp(), Rcon_Validate(), S_Play(), SCR_Sky_f(), SV_Baselines_f(), SV_Begin_f(), SV_BeginDownload_f(), SV_Configstrings_f(), SV_ConnectionlessPacket(), SV_DemoMap_f(), SV_ExecuteUserCommand(), SV_GameMap_f(), SV_InitGameProgs(), SV_Loadgame_f(), SV_Map_f(), SV_Nextserver_f(), SV_Savegame_f(), SV_ServerRecord_f(), SV_SetMaster_f(), SV_SetPlayer(), SVC_DirectConnect(), SVC_Info(), SVC_RemoteCommand(), V_Gun_Model_f(), and VID_LoadRefresh().

Cmd_CompleteCommand()

char* Cmd_CompleteCommand

(

char *

partial

)

Definition at line 772 of file cmd.c.

{
    cmd_function_t  *cmd;
    int             len;
    cmdalias_t      *a;
    
    len = strlen(partial);
    
    if (!len)
        return NULL;
        
// check for exact match
    for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
        if (!strcmp (partial,cmd->name))
            return cmd->name;
    for (a=cmd_alias ; a ; a=a->next)
        if (!strcmp (partial, a->name))
            return a->name;
 
// check for partial match
    for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
        if (!strncmp (partial,cmd->name, len))
            return cmd->name;
    for (a=cmd_alias ; a ; a=a->next)
        if (!strncmp (partial, a->name, len))
            return a->name;
 
    return NULL;
}

Referenced by CompleteCommand().

Cmd_Echo_f()

void Cmd_Echo_f

(

void

)

Definition at line 409 of file cmd.c.

{
    int     i;
    
    for (i=1 ; i<Cmd_Argc() ; i++)
        Com_Printf ("%s ",Cmd_Argv(i));
    Com_Printf ("\n");
}

Referenced by Cmd_Init().

Cmd_Exec_f()

void Cmd_Exec_f

(

void

)

Definition at line 371 of file cmd.c.

{
    char    *f, *f2;
    int     len;
 
    if (Cmd_Argc () != 2)
    {
        Com_Printf ("exec <filename> : execute a script file\n");
        return;
    }
 
    len = FS_LoadFile (Cmd_Argv(1), (void **)&f);
    if (!f)
    {
        Com_Printf ("couldn't exec %s\n",Cmd_Argv(1));
        return;
    }
    Com_Printf ("execing %s\n",Cmd_Argv(1));
    
    // the file doesn't have a trailing 0, so we need to copy it off
    f2 = Z_Malloc(len+1);
    memcpy (f2, f, len);
    f2[len] = 0;
 
    Cbuf_InsertText (f2);
 
    Z_Free (f2);
    FS_FreeFile (f);
}

Referenced by Cmd_Init().

Cmd_ExecuteString()

void Cmd_ExecuteString

(

char *

text

)

Definition at line 811 of file cmd.c.

{   
    cmd_function_t  *cmd;
    cmdalias_t      *a;
 
    Cmd_TokenizeString (text, true);
            
    // execute the command line
    if (!Cmd_Argc())
        return;     // no tokens
 
    // check functions
    for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
    {
        if (!Q_strcasecmp (cmd_argv[0],cmd->name))
        {
            if (!cmd->function)
            {   // forward to server command
                Cmd_ExecuteString (va("cmd %s", text));
            }
            else
                cmd->function ();
            return;
        }
    }
 
    // check alias
    for (a=cmd_alias ; a ; a=a->next)
    {
        if (!Q_strcasecmp (cmd_argv[0], a->name))
        {
            if (++alias_count == ALIAS_LOOP_COUNT)
            {
                Com_Printf ("ALIAS_LOOP_COUNT\n");
                return;
            }
            Cbuf_InsertText (a->value);
            return;
        }
    }
    
    // check cvars
    if (Cvar_Command ())
        return;
 
    // send it as a server command if we are connected
    Cmd_ForwardToServer ();
}

Referenced by Cbuf_Execute(), Cbuf_ExecuteText(), Cmd_ExecuteString(), and SVC_RemoteCommand().

Cmd_Exists()

qboolean Cmd_Exists

(

char *

cmd_name

)

Definition at line 752 of file cmd.c.

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

Cmd_ForwardToServer()

void Cmd_ForwardToServer

(

void

)

Definition at line 299 of file cl_main.c.

{
    char    *cmd;
 
    cmd = Cmd_Argv(0);
    if (cls.state <= ca_connected || *cmd == '-' || *cmd == '+')
    {
        Com_Printf ("Unknown command \"%s\"\n", cmd);
        return;
    }
 
    MSG_WriteByte (&cls.netchan.message, clc_stringcmd);
    SZ_Print (&cls.netchan.message, cmd);
    if (Cmd_Argc() > 1)
    {
        SZ_Print (&cls.netchan.message, " ");
        SZ_Print (&cls.netchan.message, Cmd_Args());
    }
}

Referenced by Cmd_ExecuteString().

Cmd_Init()

void Cmd_Init

(

void

)

Definition at line 881 of file cmd.c.

{
//
// register our commands
//
    Cmd_AddCommand ("cmdlist",Cmd_List_f);
    Cmd_AddCommand ("exec",Cmd_Exec_f);
    Cmd_AddCommand ("echo",Cmd_Echo_f);
    Cmd_AddCommand ("alias",Cmd_Alias_f);
    Cmd_AddCommand ("wait", Cmd_Wait_f);
}

Referenced by Qcommon_Init().

Cmd_List_f()

void Cmd_List_f

(

void

)

Definition at line 865 of file cmd.c.

{
    cmd_function_t  *cmd;
    int             i;
 
    i = 0;
    for (cmd=cmd_functions ; cmd ; cmd=cmd->next, i++)
        Com_Printf ("%s\n", cmd->name);
    Com_Printf ("%i commands\n", i);
}

Referenced by Cmd_Init().

Cmd_MacroExpandString()

char* Cmd_MacroExpandString

(

char *

text

)

Definition at line 542 of file cmd.c.

{
    int     i, j, count, len;
    qboolean    inquote;
    char    *scan;
    static  char    expanded[MAX_STRING_CHARS];
    char    temporary[MAX_STRING_CHARS];
    char    *token, *start;
 
    inquote = false;
    scan = text;
 
    len = strlen (scan);
    if (len >= MAX_STRING_CHARS)
    {
        Com_Printf ("Line exceeded %i chars, discarded.\n", MAX_STRING_CHARS);
        return NULL;
    }
 
    count = 0;
 
    for (i=0 ; i<len ; i++)
    {
        if (scan[i] == '"')
            inquote ^= 1;
        if (inquote)
            continue;   // don't expand inside quotes
        if (scan[i] != '$')
            continue;
        // scan out the complete macro
        start = scan+i+1;
        token = COM_Parse (&start);
        if (!start)
            continue;
    
        token = Cvar_VariableString (token);
 
        j = strlen(token);
        len += j;
        if (len >= MAX_STRING_CHARS)
        {
            Com_Printf ("Expanded line exceeded %i chars, discarded.\n", MAX_STRING_CHARS);
            return NULL;
        }
 
        strncpy (temporary, scan, i);
        strcpy (temporary+i, token);
        strcpy (temporary+i+j, start);
 
        strcpy (expanded, temporary);
        scan = expanded;
        i--;
 
        if (++count == 100)
        {
            Com_Printf ("Macro expansion loop, discarded.\n");
            return NULL;
        }
    }
 
    if (inquote)
    {
        Com_Printf ("Line has unmatched quote, discarded.\n");
        return NULL;
    }
 
    return scan;
}

Referenced by Cmd_TokenizeString().

Cmd_RemoveCommand()

void Cmd_RemoveCommand

(

char *

cmd_name

)

Definition at line 724 of file cmd.c.

{
    cmd_function_t  *cmd, **back;
 
    back = &cmd_functions;
    while (1)
    {
        cmd = *back;
        if (!cmd)
        {
            Com_Printf ("Cmd_RemoveCommand: %s not added\n", cmd_name);
            return;
        }
        if (!strcmp (cmd_name, cmd->name))
        {
            *back = cmd->next;
            Z_Free (cmd);
            return;
        }
        back = &cmd->next;
    }
}

Referenced by S_Shutdown(), and VID_LoadRefresh().

Cmd_TokenizeString()

void Cmd_TokenizeString	(	char *	text,
		qboolean	macroExpand
	)

Definition at line 620 of file cmd.c.

{
    int     i;
    char    *com_token;
 
// clear the args from the last string
    for (i=0 ; i<cmd_argc ; i++)
        Z_Free (cmd_argv[i]);
        
    cmd_argc = 0;
    cmd_args[0] = 0;
    
    // macro expand the text
    if (macroExpand)
        text = Cmd_MacroExpandString (text);
    if (!text)
        return;
 
    while (1)
    {
// skip whitespace up to a /n
        while (*text && *text <= ' ' && *text != '\n')
        {
            text++;
        }
        
        if (*text == '\n')
        {   // a newline seperates commands in the buffer
            text++;
            break;
        }
 
        if (!*text)
            return;
 
        // set cmd_args to everything after the first arg
        if (cmd_argc == 1)
        {
            int     l;
 
            strcpy (cmd_args, text);
 
            // strip off any trailing whitespace
            l = strlen(cmd_args) - 1;
            for ( ; l >= 0 ; l--)
                if (cmd_args[l] <= ' ')
                    cmd_args[l] = 0;
                else
                    break;
        }
            
        com_token = COM_Parse (&text);
        if (!text)
            return;
 
        if (cmd_argc < MAX_STRING_TOKENS)
        {
            cmd_argv[cmd_argc] = Z_Malloc (strlen(com_token)+1);
            strcpy (cmd_argv[cmd_argc], com_token);
            cmd_argc++;
        }
    }
    
}

Referenced by CL_ConnectionlessPacket(), Cmd_ExecuteString(), SV_ConnectionlessPacket(), and SV_ExecuteUserCommand().

Cmd_Wait_f()

void Cmd_Wait_f

(

void

)

Definition at line 54 of file cmd.c.

{
    cmd_wait = true;
}

Referenced by Cmd_Init().

Variable Documentation

alias_count

int alias_count

Definition at line 40 of file cmd.c.

Referenced by Cbuf_Execute(), and Cmd_ExecuteString().

cmd_alias

cmdalias_t* cmd_alias

Definition at line 35 of file cmd.c.

Referenced by Cmd_Alias_f(), Cmd_CompleteCommand(), and Cmd_ExecuteString().

cmd_argc

int cmd_argc

static

Definition at line 495 of file cmd.c.

Referenced by Cmd_Argc(), Cmd_Argv(), and Cmd_TokenizeString().

cmd_args

char cmd_args[MAX_STRING_CHARS]

static

Definition at line 498 of file cmd.c.

Referenced by Cmd_Args(), and Cmd_TokenizeString().

cmd_argv

char* cmd_argv[MAX_STRING_TOKENS]

static

Definition at line 496 of file cmd.c.

Referenced by Cmd_Argv(), Cmd_ExecuteString(), and Cmd_TokenizeString().

cmd_functions

cmd_function_t* cmd_functions

static

Definition at line 500 of file cmd.c.

Referenced by Cmd_AddCommand(), Cmd_CompleteCommand(), Cmd_ExecuteString(), Cmd_Exists(), Cmd_List_f(), and Cmd_RemoveCommand().

cmd_null_string

char* cmd_null_string = ""

static

Definition at line 497 of file cmd.c.

Referenced by Cmd_Argv().

cmd_text

sizebuf_t cmd_text

Definition at line 68 of file cmd.c.

Referenced by Cbuf_AddText(), Cbuf_CopyToDefer(), Cbuf_Execute(), Cbuf_Init(), and Cbuf_InsertText().

cmd_text_buf

byte cmd_text_buf[8192]

Definition at line 69 of file cmd.c.

Referenced by Cbuf_CopyToDefer(), and Cbuf_Init().

cmd_wait

qboolean cmd_wait

Definition at line 37 of file cmd.c.

Referenced by Cbuf_Execute(), and Cmd_Wait_f().

defer_text_buf

char defer_text_buf[8192]

Definition at line 71 of file cmd.c.

Referenced by Cbuf_CopyToDefer(), and Cbuf_InsertFromDefer().