cmd.c File Reference

#include "shared/shared.h"
#include "shared/list.h"
#include "common/cmd.h"
#include "common/common.h"
#include "common/cvar.h"
#include "common/error.h"
#include "common/files.h"
#include "common/prompt.h"
#include "common/utils.h"
#include "client/client.h"

Go to the source code of this file.

Classes
struct	cmdalias_s
struct	cmd_trigger_t
struct	cmd_function_s

Macros
#define	Cmd_Malloc(size)   Z_TagMalloc(size, TAG_CMD)
#define	Cmd_CopyString(string)   Z_TagCopyString(string, TAG_CMD)
#define	ALIAS_HASH_SIZE   64
#define	FOR_EACH_ALIAS_HASH(alias, hash)   LIST_FOR_EACH(cmdalias_t, alias, &cmd_aliasHash[hash], hashEntry)
#define	FOR_EACH_ALIAS(alias)   LIST_FOR_EACH(cmdalias_t, alias, &cmd_alias, listEntry)
#define	FOR_EACH_TRIGGER(trig)   LIST_FOR_EACH(cmd_trigger_t, trig, &cmd_triggers, entry)
#define	FOR_EACH_TRIGGER_SAFE(trig, next)   LIST_FOR_EACH_SAFE(cmd_trigger_t, trig, next, &cmd_triggers, entry)
#define	MACRO_HASH_SIZE   64
#define	CMD_HASH_SIZE   128
#define	FOR_EACH_CMD_HASH(cmd, hash)   LIST_FOR_EACH(cmd_function_t, cmd, &cmd_hash[hash], hashEntry)
#define	FOR_EACH_CMD(cmd)   LIST_FOR_EACH(cmd_function_t, cmd, &cmd_functions, listEntry)

Typedefs
typedef struct cmdalias_s	cmdalias_t
typedef struct cmd_function_s	cmd_function_t

Functions
static char *	Cmd_ArgsRange (int from, int to)
static void	Cmd_Wait_f (void)
void	Cbuf_Init (void)
void	Cbuf_AddText (cmdbuf_t *buf, const char *text)
char *	Cbuf_Alloc (cmdbuf_t *buf, size_t len)
void	Cbuf_InsertText (cmdbuf_t *buf, const char *text)
void	Cbuf_Execute (cmdbuf_t *buf)
static cmdalias_t *	Cmd_AliasFind (const char *name)
char *	Cmd_AliasCommand (const char *name)
void	Cmd_AliasSet (const char *name, const char *cmd)
void	Cmd_Alias_g (genctx_t *ctx)
void	Cmd_Alias_f (void)
static void	Cmd_UnAlias_f (void)
static void	Cmd_Alias_c (genctx_t *ctx, int argnum)
static void	Cmd_UnAlias_c (genctx_t *ctx, int argnum)
static cmd_trigger_t *	find_trigger (const char *command, const char *match)
static void	list_triggers (void)
static void	Cmd_Trigger_f (void)
static void	Cmd_UnTrigger_f (void)
void	Cmd_ExecTrigger (const char *string)
static void	Cmd_If_f (void)
static void	Cmd_OpenURL_f (void)
cmd_macro_t *	Cmd_FindMacro (const char *name)
void	Cmd_Macro_g (genctx_t *ctx)
void	Cmd_AddMacro (const char *name, xmacro_t function)
from_t	Cmd_From (void)
size_t	Cmd_ArgOffset (int arg)
int	Cmd_FindArgForOffset (size_t offset)
size_t	Cmd_WhiteSpaceTail (void)
int	Cmd_Argc (void)
char *	Cmd_Argv (int arg)
size_t	Cmd_ArgvBuffer (int arg, char *buffer, size_t size)
char *	Cmd_Args (void)
char *	Cmd_RawArgs (void)
char *	Cmd_RawString (void)
size_t	Cmd_ArgsBuffer (char *buffer, size_t size)
char *	Cmd_ArgsFrom (int from)
char *	Cmd_RawArgsFrom (int from)
void	Cmd_Shift (void)
int	Cmd_ParseOptions (const cmd_option_t *opt)
void	Cmd_PrintUsage (const cmd_option_t *opt, const char *suffix)
void	Cmd_PrintHelp (const cmd_option_t *opt)
void	Cmd_PrintHint (void)
void	Cmd_Option_c (const cmd_option_t *opt, xgenerator_t g, genctx_t *ctx, int argnum)
char *	Cmd_MacroExpandString (const char *text, qboolean aliasHack)
void	Cmd_TokenizeString (const char *text, qboolean macroExpand)
static cmd_function_t *	Cmd_Find (const char *name)
static void	Cmd_RegCommand (const cmdreg_t *reg)
void	Cmd_AddCommand (const char *name, xcommand_t function)
void	Cmd_Register (const cmdreg_t *reg)
void	Cmd_Deregister (const cmdreg_t *reg)
void	Cmd_RemoveCommand (const char *name)
qboolean	Cmd_Exists (const char *name)
xcommand_t	Cmd_FindFunction (const char *name)
xcompleter_t	Cmd_FindCompleter (const char *name)
void	Cmd_Command_g (genctx_t *ctx)
void	Cmd_ExecuteCommand (cmdbuf_t *buf)
void	Cmd_ExecuteString (cmdbuf_t *buf, const char *text)
qerror_t	Cmd_ExecuteFile (const char *path, unsigned flags)
static void	Cmd_Exec_f (void)
void	Cmd_Config_g (genctx_t *ctx)
static void	Cmd_Exec_c (genctx_t *ctx, int argnum)
static void	Cmd_Echo_f (void)
static void	Cmd_EchoEx_c (genctx_t *ctx, int argnum)
static char *	unescape_string (char *dst, const char *src)
static void	Cmd_EchoEx_f (void)
static void	Cmd_List_f (void)
static void	Cmd_MacroList_f (void)
static void	Cmd_Text_f (void)
static void	Cmd_Complete_f (void)
void	Cmd_Init (void)

Variables
char	cmd_buffer_text [CMD_BUFFER_SIZE]
cmdbuf_t	cmd_buffer
cmdbuf_t *	cmd_current
static list_t	cmd_alias
static list_t	cmd_aliasHash [ALIAS_HASH_SIZE]
static list_t	cmd_triggers
static cmd_macro_t *	cmd_macros
static cmd_macro_t *	cmd_macroHash [MACRO_HASH_SIZE]
static list_t	cmd_functions
static list_t	cmd_hash [CMD_HASH_SIZE]
static int	cmd_argc
static char *	cmd_argv [MAX_STRING_TOKENS]
static char *	cmd_null_string = ""
static char	cmd_string [MAX_STRING_CHARS]
static size_t	cmd_string_len
static size_t	cmd_string_tail
static size_t	cmd_offsets [MAX_STRING_TOKENS]
static char	cmd_data [MAX_STRING_CHARS]
static char	cmd_args [MAX_STRING_CHARS]
int	cmd_optind
char *	cmd_optarg
char *	cmd_optopt
static const cmd_option_t	o_echo []
static const cmdreg_t	c_cmd []

Macro Definition Documentation

ALIAS_HASH_SIZE

#define ALIAS_HASH_SIZE   64

Definition at line 214 of file cmd.c.

Cmd_CopyString

#define Cmd_CopyString

(

string

)

Z_TagCopyString(string, TAG_CMD)

Definition at line 36 of file cmd.c.

CMD_HASH_SIZE

#define CMD_HASH_SIZE   128

Definition at line 810 of file cmd.c.

Cmd_Malloc

#define Cmd_Malloc

(

size

)

Z_TagMalloc(size, TAG_CMD)

Definition at line 35 of file cmd.c.

FOR_EACH_ALIAS

#define FOR_EACH_ALIAS

(

alias

)

LIST_FOR_EACH(cmdalias_t, alias, &cmd_alias, listEntry)

Definition at line 218 of file cmd.c.

FOR_EACH_ALIAS_HASH

#define FOR_EACH_ALIAS_HASH	(		alias,
			hash
	)		LIST_FOR_EACH(cmdalias_t, alias, &cmd_aliasHash[hash], hashEntry)

Definition at line 216 of file cmd.c.

FOR_EACH_CMD

#define FOR_EACH_CMD

(

cmd

)

LIST_FOR_EACH(cmd_function_t, cmd, &cmd_functions, listEntry)

Definition at line 814 of file cmd.c.

FOR_EACH_CMD_HASH

#define FOR_EACH_CMD_HASH	(		cmd,
			hash
	)		LIST_FOR_EACH(cmd_function_t, cmd, &cmd_hash[hash], hashEntry)

Definition at line 812 of file cmd.c.

FOR_EACH_TRIGGER

#define FOR_EACH_TRIGGER

(

trig

)

LIST_FOR_EACH(cmd_trigger_t, trig, &cmd_triggers, entry)

Definition at line 440 of file cmd.c.

FOR_EACH_TRIGGER_SAFE

#define FOR_EACH_TRIGGER_SAFE	(		trig,
			next
	)		LIST_FOR_EACH_SAFE(cmd_trigger_t, trig, next, &cmd_triggers, entry)

Definition at line 442 of file cmd.c.

MACRO_HASH_SIZE

#define MACRO_HASH_SIZE   64

Definition at line 729 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_AddText()

void Cbuf_AddText	(	cmdbuf_t *	buf,
		const char *	text
	)

Definition at line 95 of file cmd.c.

{
    size_t l = strlen(text);
 
    if (buf->cursize + l > buf->maxsize) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
    memcpy(buf->text + buf->cursize, text, l);
    buf->cursize += l;
}

Referenced by Activate(), CL_ParseStuffText(), Cmd_ExecTrigger(), Cmd_Text_f(), Com_AddLateCommands(), Con_Action(), Connect(), dummy_add_message(), dummy_run(), dummy_spawn(), finish_demo(), Key_Event(), NET_OpenServer(), PF_AddCommandString(), PlayDemo(), Qcommon_Init(), S_Update(), SV_MvdStuff_f(), SV_NextServer_f(), and VID_ToggleFullscreen().

Cbuf_Alloc()

char* Cbuf_Alloc	(	cmdbuf_t *	buf,
		size_t	len
	)

Definition at line 107 of file cmd.c.

{
    char *text;
 
    if (buf->cursize + len > buf->maxsize) {
        return NULL;
    }
    text = buf->text + buf->cursize;
    buf->cursize += len;
 
    return text;
}

Cbuf_Execute()

void Cbuf_Execute

(

cmdbuf_t *

buf

)

Definition at line 152 of file cmd.c.

{
    int     i;
    char    *text;
    char    line[MAX_STRING_CHARS];
    int     quotes;
 
    while (buf->cursize) {
        if (buf->waitCount > 0) {
            // skip out while text still remains in buffer, leaving it
            // for next frame (counter is decremented externally now)
            return;
        }
 
// find a \n or ; line break
        text = buf->text;
 
        quotes = 0;
        for (i = 0; i < buf->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;
        }
 
        // check for overflow
        if (i > sizeof(line) - 1) {
            i = sizeof(line) - 1;
        }
 
        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 == buf->cursize) {
            buf->cursize = 0;
        } else {
            i++;
            buf->cursize -= i;
            memmove(text, text + i, buf->cursize);
        }
 
// execute the command line
        cmd_current = buf;
        buf->exec(buf, line);
    }
 
    buf->aliasCount = 0;        // don't allow infinite alias loops
}

Referenced by CL_ParseServerData(), CL_PlayDemo_f(), CL_ProcessEvents(), Com_AddConfigFile(), Com_AddLateCommands(), dummy_run(), finish_demo(), Qcommon_Init(), and SV_Frame().

Cbuf_Init()

void Cbuf_Init

(

void

)

Definition at line 79 of file cmd.c.

{
    memset(&cmd_buffer, 0, sizeof(cmd_buffer));
    cmd_buffer.from = FROM_CONSOLE;
    cmd_buffer.text = cmd_buffer_text;
    cmd_buffer.maxsize = sizeof(cmd_buffer_text);
    cmd_buffer.exec = Cmd_ExecuteString;
}

Referenced by Qcommon_Init().

Cbuf_InsertText()

void Cbuf_InsertText	(	cmdbuf_t *	buf,
		const char *	text
	)

Definition at line 128 of file cmd.c.

{
    size_t l = strlen(text);
 
// add the entire text of the file
    if (!l) {
        return;
    }
    if (buf->cursize + l + 1 > buf->maxsize) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
 
    memmove(buf->text + l + 1, buf->text, buf->cursize);
    memcpy(buf->text, text, l);
    buf->text[l] = '\n';
    buf->cursize += l + 1;
}

Referenced by CL_FollowIP_f(), CL_Pause_f(), CL_PlayDemo_f(), CL_Seek_f(), Cmd_ExecuteCommand(), Cmd_ExecuteFile(), Cmd_If_f(), and dummy_exec_string().

Cmd_AddCommand()

void Cmd_AddCommand	(	const char *	name,
		xcommand_t	function
	)

Definition at line 1562 of file cmd.c.

{
    cmdreg_t reg;
 
    reg.name = name;
    reg.function = function;
    reg.completer = NULL;
    Cmd_RegCommand(&reg);
}

Referenced by BSP_Init(), CL_GTV_Init(), CL_InitAscii(), CL_InitDownloads(), CL_RegisterInput(), GL_Register(), Key_Init(), LOC_Init(), MOD_Init(), NET_Init(), OGG_Init(), Qcommon_Init(), R_Init_RTX(), R_Register(), SV_InitOperatorCommands(), Sys_Init(), and TST_Init().

Cmd_AddMacro()

void Cmd_AddMacro	(	const char *	name,
		xmacro_t	function
	)

Definition at line 770 of file cmd.c.

{
    cmd_macro_t *macro;
    unsigned hash;
 
// fail if the macro is a variable name
    if (Cvar_Exists(name, qfalse)) {
        Com_WPrintf("%s: %s already defined as a cvar\n", __func__, name);
        return;
    }
 
// fail if the macro already exists
    macro = Cmd_FindMacro(name);
    if (macro) {
        if (macro->function != function) {
            Com_WPrintf("%s: %s already defined\n", __func__, name);
        }
        return;
    }
 
    macro = Cmd_Malloc(sizeof(cmd_macro_t));
    macro->name = name;
    macro->function = function;
    macro->next = cmd_macros;
    cmd_macros = macro;
 
    hash = Com_HashString(name, MACRO_HASH_SIZE);
    macro->hashNext = cmd_macroHash[hash];
    cmd_macroHash[hash] = macro;
}

Referenced by CL_InitLocal(), GL_Register(), LOC_Init(), NET_Init(), and Qcommon_Init().

Cmd_Alias_c()

static void Cmd_Alias_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 416 of file cmd.c.

{
    if (argnum == 1) {
        Cmd_Alias_g(ctx);
    } else {
        Com_Generic_c(ctx, argnum - 2);
    }
}

Cmd_Alias_f()

void Cmd_Alias_f

(

void

)

Definition at line 307 of file cmd.c.

{
    cmdalias_t  *a;
    char        *s, *cmd;
 
    if (Cmd_Argc() < 2) {
        if (LIST_EMPTY(&cmd_alias)) {
            Com_Printf("No alias commands registered.\n");
            return;
        }
        Com_Printf("Registered alias commands:\n");
        FOR_EACH_ALIAS(a) {
            Com_Printf("\"%s\" = \"%s\"\n", a->name, a->value);
        }
        return;
    }
 
    s = Cmd_Argv(1);
    if (Cmd_Exists(s)) {
        Com_Printf("\"%s\" already defined as a command\n", s);
        return;
    }
 
    if (Cvar_Exists(s, qtrue)) {
        Com_Printf("\"%s\" already defined as a cvar\n", s);
        return;
    }
 
    if (Cmd_Argc() < 3) {
        a = Cmd_AliasFind(s);
        if (a) {
            Com_Printf("\"%s\" = \"%s\"\n", a->name, a->value);
        } else {
            Com_Printf("\"%s\" is undefined\n", s);
        }
        return;
    }
 
    // copy the rest of the command line
    cmd = Cmd_ArgsFrom(2);
    Cmd_AliasSet(s, cmd);
}

Cmd_Alias_g()

void Cmd_Alias_g

(

genctx_t *

ctx

)

Definition at line 288 of file cmd.c.

{
    cmdalias_t *a;
 
    FOR_EACH_ALIAS(a) {
        if (!Prompt_AddMatch(ctx, a->name)) {
            break;
        }
    }
}

Referenced by Cmd_Alias_c(), Cmd_UnAlias_c(), Com_Generic_c(), and Prompt_CompleteCommand().

Cmd_AliasCommand()

char* Cmd_AliasCommand

(

const char *

name

)

Definition at line 251 of file cmd.c.

{
    cmdalias_t *a;
 
    a = Cmd_AliasFind(name);
    if (!a) {
        return NULL;
    }
 
    return a->value;
}

Referenced by dummy_exec_string(), and Qcommon_Init().

Cmd_AliasFind()

static cmdalias_t* Cmd_AliasFind ( const char *  name )

static

Definition at line 236 of file cmd.c.

{
    unsigned hash;
    cmdalias_t *alias;
 
    hash = Com_HashString(name, ALIAS_HASH_SIZE);
    FOR_EACH_ALIAS_HASH(alias, hash) {
        if (!strcmp(name, alias->name)) {
            return alias;
        }
    }
 
    return NULL;
}

Referenced by Cmd_Alias_f(), Cmd_AliasCommand(), Cmd_AliasSet(), Cmd_ExecuteCommand(), and Cmd_UnAlias_f().

Cmd_AliasSet()

void Cmd_AliasSet	(	const char *	name,
		const char *	cmd
	)

Definition at line 263 of file cmd.c.

{
    cmdalias_t  *a;
    unsigned    hash;
    size_t      len;
 
    // if the alias already exists, reuse it
    a = Cmd_AliasFind(name);
    if (a) {
        Z_Free(a->value);
        a->value = Cmd_CopyString(cmd);
        return;
    }
 
    len = strlen(name);
    a = Cmd_Malloc(sizeof(cmdalias_t) + len);
    memcpy(a->name, name, len + 1);
    a->value = Cmd_CopyString(cmd);
 
    List_Append(&cmd_alias, &a->listEntry);
 
    hash = Com_HashString(name, ALIAS_HASH_SIZE);
    List_Append(&cmd_aliasHash[hash], &a->hashEntry);
}

Referenced by Cmd_Alias_f().

Cmd_Argc()

int Cmd_Argc

(

void

)

Definition at line 889 of file cmd.c.

{
    return cmd_argc;
}

Referenced by AC_Info_f(), CL_Changing_f(), CL_Connect_f(), CL_ConnectionlessPacket(), CL_Download_f(), CL_FollowIP_f(), CL_ForwardToServer_f(), CL_IgnoreNick_f(), CL_IgnoreText_f(), CL_PlayDemo_f(), CL_PlaySound_f(), CL_Rcon_f(), CL_Seek_f(), CL_ServerStatus_f(), CL_UnIgnoreNick_f(), CL_UnIgnoreText_f(), Cmd_Alias_f(), Cmd_Exec_f(), Cmd_If_f(), Cmd_OpenURL_f(), Cmd_Trigger_f(), Cmd_UnTrigger_f(), Com_Freeze_f(), Com_PrintJunk_f(), Con_Dump_f(), Con_RemoteMode_f(), Cvar_Command(), Cvar_Inc_f(), Cvar_Reset_f(), Cvar_Set_f(), Cvar_SetFlag_f(), Cvar_Toggle_f(), dummy_record_f(), dump_program(), exec_server_string(), FS_Dir_f(), FS_FDir_f(), FS_Link_f(), FS_WhereIs_f(), IMG_List_f(), IMG_ScreenShot_f(), IMG_ScreenShotJPG_f(), IMG_ScreenShotPNG_f(), IMG_ScreenShotTGA_f(), Key_Bind_f(), Key_Unbind_f(), LOC_Add_f(), LOC_LoadLocations(), LOC_Update_f(), MVD_Admin_f(), MVD_AutoFollow_f(), MVD_Follow_f(), MVD_Play_f(), MVD_Seek_f(), NET_Dns_f(), OGG_Cmd(), Parse_Action(), Parse_Banner(), Parse_Bind(), Parse_Bitmap(), Parse_Color(), Parse_File(), Parse_Footer(), Parse_If(), Parse_Pairs(), Parse_Plaque(), Parse_Range(), Parse_Savegame(), Parse_Spin(), Parse_Toggle(), ParseMasterArgs(), Prompt_CompleteCommand(), SCR_Draw_f(), SCR_ScoreShot_f(), SCR_Sky_f(), SCR_TimeRefresh_f(), SCR_UnDraw_f(), SV_AddFilterCmd_f(), SV_AddMatch_f(), SV_AddStuffCmd_f(), SV_BeginDownload_f(), SV_ConSay_f(), SV_DelFilterCmd_f(), SV_DelMatch_f(), SV_DelStuffCmd_f(), SV_DumpEnts_f(), SV_DumpUser_f(), SV_GameMap_f(), SV_InitGameProgs(), SV_Kick_f(), SV_Lag_f(), SV_ListStuffCmds_f(), SV_Loadgame_f(), SV_Map_f(), SV_MvdStatus_f(), SV_PickClient_f(), SV_Savegame_f(), SV_SetMaster_f(), SV_Status_f(), SV_Stuff_f(), SV_StuffAll_f(), SV_StuffCvar_f(), UI_PushMenu_f(), V_Gun_Model_f(), and vkpt_set_material().

Cmd_ArgOffset()

size_t Cmd_ArgOffset

(

int

arg

)

Definition at line 856 of file cmd.c.

{
    if (arg < 0) {
        return 0;
    }
    if (arg >= cmd_argc) {
        return cmd_string_len;
    }
    return cmd_offsets[arg];
}

Referenced by Prompt_CompleteCommand().

Cmd_Args()

char* Cmd_Args

(

void

)

Definition at line 933 of file cmd.c.

{
    int i;
 
    if (cmd_argc < 2) {
        return cmd_null_string;
    }
 
    cmd_args[0] = 0;
    for (i = 1; i < cmd_argc - 1; i++) {
        strcat(cmd_args, cmd_argv[i]);
        strcat(cmd_args, " ");
    }
    strcat(cmd_args, cmd_argv[i]);
 
    return cmd_args;
}

Referenced by Cmd_ArgsBuffer(), Cmd_Echo_f(), Cmd_MacroExpandString(), Cmd_Text_f(), Com_Quit_f(), Com_Recycle_f(), dummy_forward_f(), gtv_forward_cmd(), LOC_Add_f(), and LOC_Update_f().

Cmd_ArgsBuffer()

size_t Cmd_ArgsBuffer	(	char *	buffer,
		size_t	size
	)

Definition at line 969 of file cmd.c.

{
    return Q_strlcpy(buffer, Cmd_Args(), size);
}

Cmd_ArgsFrom()

char* Cmd_ArgsFrom

(

int

from

)

Definition at line 981 of file cmd.c.

{
    int i;
 
    if (from < 0 || from >= cmd_argc) {
        return cmd_null_string;
    }
 
    cmd_args[0] = 0;
    for (i = from; i < cmd_argc - 1; i++) {
        strcat(cmd_args, cmd_argv[i]);
        strcat(cmd_args, " ");
    }
    strcat(cmd_args, cmd_argv[i]);
 
    return cmd_args;
}

Referenced by CL_IgnoreText_f(), CL_UnIgnoreText_f(), Cmd_Alias_f(), Cmd_If_f(), Cmd_Trigger_f(), Cmd_UnTrigger_f(), Cvar_Command(), Cvar_Set_f(), Cvar_SetFlag_f(), Key_Bind_f(), MVD_Say_f(), Parse_Action(), Parse_Bind(), Parse_Bitmap(), Prompt_CompleteCommand(), SV_AddFilterCmd_f(), SV_AddMatch_f(), and SV_AddStuffCmd_f().

Cmd_ArgsRange()

static char * Cmd_ArgsRange ( int  from, int  to  )

static

Definition at line 999 of file cmd.c.

{
    int i;
 
    if (from < 0 || from >= cmd_argc) {
        return cmd_null_string;
    }
 
    if (to > cmd_argc - 1) {
        to = cmd_argc - 1;
    }
 
    cmd_args[0] = 0;
    for (i = from; i < to; i++) {
        strcat(cmd_args, cmd_argv[i]);
        strcat(cmd_args, " ");
    }
    strcat(cmd_args, cmd_argv[i]);
 
    return cmd_args;
}

Referenced by Cmd_If_f(), and Cmd_MacroExpandString().

Cmd_Argv()

char* Cmd_Argv

(

int

arg

)

Definition at line 899 of file cmd.c.

{
    if (arg < 0 || arg >= cmd_argc) {
        return cmd_null_string;
    }
    return cmd_argv[arg];
}

Referenced by AC_Info_f(), AC_List_f(), CL_Changing_f(), CL_Connect_f(), CL_ConnectionlessPacket(), CL_Download_f(), CL_FollowIP_f(), CL_ForwardToServer(), CL_ForwardToServer_f(), CL_PlayDemo_f(), CL_PlaySound_f(), CL_Precache_f(), CL_Rcon_f(), CL_Seek_f(), CL_ServerStatus_f(), CL_UnIgnoreText_f(), Cmd_Alias_f(), Cmd_Exec_f(), Cmd_If_f(), Cmd_MacroExpandString(), Cmd_OpenURL_f(), Cmd_Trigger_f(), Cmd_UnAlias_f(), Cmd_UnTrigger_f(), Cmd_Wait_f(), Com_Crash_f(), Com_Error_f(), Com_ErrorDrop_f(), Com_Freeze_f(), Com_Generic_c(), Com_PrintJunk_f(), Con_Dump_f(), Con_RemoteMode_f(), Cvar_Inc_f(), Cvar_Reset_f(), Cvar_Set_c(), Cvar_Set_f(), Cvar_SetFlag_f(), Cvar_Toggle_c(), Cvar_Toggle_f(), dummy_exec_string(), dummy_forward_f(), dummy_record_f(), dummy_wait_f(), dump_program(), exec_server_string(), FS_Dir_f(), FS_FDir_f(), FS_Link_f(), FS_Link_g(), FS_UnLink_f(), FS_WhereIs_f(), gtv_set_conn(), IMG_List_f(), IMG_ScreenShot_f(), IMG_ScreenShotJPG_f(), IMG_ScreenShotPNG_f(), IMG_ScreenShotTGA_f(), IN_Impulse(), Key_Bind_f(), Key_Unbind_f(), KeyDown(), KeyUp(), LOC_Add_f(), LOC_LoadLocations(), LOC_Update_f(), MAT_SetPBRMaterialAttribute(), MVD_Admin_f(), MVD_AutoFollow_f(), MVD_Follow_f(), MVD_GameClientCommand(), MVD_ListChannels_f(), MVD_Play_f(), MVD_Seek_f(), MVD_SetChannel(), MVD_Skip_f(), MVD_StreamedStop_f(), NET_Dns_f(), OGG_Cmd(), OGG_HelpMsg(), Parse_Action(), Parse_Background(), Parse_Banner(), parse_basic_params(), Parse_Bind(), Parse_Bitmap(), Parse_Color(), parse_enhanced_params(), Parse_Field(), Parse_File(), Parse_Footer(), Parse_If(), parse_packet_length(), Parse_Pairs(), Parse_Plaque(), Parse_Range(), Parse_Savegame(), Parse_Spin(), Parse_Toggle(), parse_userinfo(), ParseMasterArgs(), Prompt_CompleteCommand(), rcon_valid(), SCR_Draw_f(), SCR_ScoreShot_f(), SCR_Sky_f(), SCR_UnDraw_f(), should_really_restart(), SV_AddFilterCmd_f(), SV_AddMatch_f(), SV_AddStuffCmd_f(), SV_BeginDownload_f(), SV_ConnectionlessPacket(), SV_ConSay_f(), SV_CvarResult_f(), SV_DelFilterCmd_f(), SV_DelMatch_f(), SV_DelStuffCmd_f(), SV_DemoMap_f(), SV_DumpEnts_f(), SV_DumpUser_f(), SV_ExecuteUserCommand(), SV_FindStuffList(), SV_GameMap_f(), SV_InitGameProgs(), SV_Kick_f(), SV_Lag_f(), SV_ListStuffCmds_f(), SV_Loadgame_f(), SV_Map_f(), SV_MvdStuff_f(), SV_PickClient_f(), SV_Savegame_f(), SV_SetMaster_f(), SV_SetPlayer(), SV_Status_f(), SV_Stuff_f(), SV_StuffAll_f(), SV_StuffCvar_f(), SVC_Info(), UI_PushMenu_f(), V_Gun_Model_f(), and vkpt_set_material().

Cmd_ArgvBuffer()

size_t Cmd_ArgvBuffer	(	int	arg,
		char *	buffer,
		size_t	size
	)

Definition at line 912 of file cmd.c.

{
    char *s;
 
    if (arg < 0 || arg >= cmd_argc) {
        s = cmd_null_string;
    } else {
        s = cmd_argv[arg];
    }
 
    return Q_strlcpy(buffer, s, size);
}

Referenced by CL_PlaySound_f(), NET_Dns_f(), Parse_File(), parse_ignore_nick(), SV_BeginDownload_f(), and SV_Map().

Cmd_Command_g()

void Cmd_Command_g

(

genctx_t *

ctx

)

Definition at line 1634 of file cmd.c.

{
    cmd_function_t *cmd;
 
    FOR_EACH_CMD(cmd) {
        if (!Prompt_AddMatch(ctx, cmd->name)) {
            break;
        }
    }
}

Referenced by Com_Generic_c(), and Prompt_CompleteCommand().

Cmd_Complete_f()

static void Cmd_Complete_f ( void  )

static

Definition at line 1982 of file cmd.c.

{
    cmd_function_t *cmd;
    char *name;
    unsigned hash;
    size_t len;
 
    if (cmd_argc < 2) {
        Com_Printf("Usage: %s <command>", cmd_argv[0]);
        return;
    }
 
    name = cmd_argv[1];
 
// fail if the command is a variable name
    if (Cvar_Exists(name, qtrue)) {
        Com_Printf("%s is already defined as a cvar\n", name);
        return;
    }
 
// fail if the command already exists
    cmd = Cmd_Find(name);
    if (cmd) {
        //Com_Printf("%s is already defined\n", name);
        return;
    }
 
    len = strlen(name) + 1;
    cmd = Cmd_Malloc(sizeof(*cmd) + len);
    cmd->name = (char *)(cmd + 1);
    memcpy(cmd->name, name, len);
    cmd->function = NULL;
    cmd->completer = NULL;
 
    List_Append(&cmd_functions, &cmd->listEntry);
 
    hash = Com_HashString(name, CMD_HASH_SIZE);
    List_Append(&cmd_hash[hash], &cmd->hashEntry);
}

Cmd_Config_g()

void Cmd_Config_g

(

genctx_t *

ctx

)

Definition at line 1805 of file cmd.c.

{
    FS_File_g(NULL, "*.cfg", FS_SEARCH_SAVEPATH | FS_SEARCH_BYFILTER | FS_SEARCH_STRIPEXT, ctx);
}

Referenced by CL_WriteConfig_c(), and Cmd_Exec_c().

Cmd_Deregister()

void Cmd_Deregister

(

const cmdreg_t *

reg

)

Definition at line 1580 of file cmd.c.

{
    while (reg->name) {
        Cmd_RemoveCommand(reg->name);
        reg++;
    }
}

Referenced by FS_Shutdown(), IMG_Shutdown(), S_Shutdown(), SCR_Shutdown(), UI_Shutdown(), and V_Shutdown().

Cmd_Echo_f()

static void Cmd_Echo_f ( void  )

static

Definition at line 1824 of file cmd.c.

{
    Com_Printf("%s\n", Cmd_Args());
}

Cmd_EchoEx_c()

static void Cmd_EchoEx_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 1837 of file cmd.c.

{
    Cmd_Option_c(o_echo, NULL, ctx, argnum);
}

Cmd_EchoEx_f()

static void Cmd_EchoEx_f ( void  )

static

Definition at line 1882 of file cmd.c.

{
    char buffer[MAX_STRING_CHARS], *s;
    qboolean escapes = qfalse;
    color_index_t color = COLOR_NONE;
    const char *newline = "\n";
    int c;
 
    while ((c = Cmd_ParseOptions(o_echo)) != -1) {
        switch (c) {
        case 'h':
            Cmd_PrintUsage(o_echo, "[text]");
            Com_Printf("Print a line of text into the console.\n");
            Cmd_PrintHelp(o_echo);
            return;
        case 'e':
            escapes = qtrue;
            break;
        case 'c':
            color = Com_ParseColor(cmd_optarg, COLOR_NONE);
            break;
        case 'n':
            newline = "";
            break;
        default:
            return;
        }
    }
 
    s = Cmd_RawArgsFrom(cmd_optind);
    if (escapes) {
        s = unescape_string(buffer, s);
    }
 
    Com_SetColor(color);
    Com_Printf("%s%s", s, newline);
    Com_SetColor(COLOR_NONE);
}

Cmd_Exec_c()

static void Cmd_Exec_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 1810 of file cmd.c.

{
    if (argnum == 1) {
        Cmd_Config_g(ctx);
    }
}

Cmd_Exec_f()

static void Cmd_Exec_f ( void  )

static

Definition at line 1766 of file cmd.c.

{
    char    buffer[MAX_QPATH];
    size_t  len;
    qerror_t ret;
 
    if (Cmd_Argc() != 2) {
        Com_Printf("%s <filename> : execute a script file\n", Cmd_Argv(0));
        return;
    }
 
    len = FS_NormalizePathBuffer(buffer, Cmd_Argv(1), sizeof(buffer));
    if (len >= sizeof(buffer)) {
        Q_PrintError("exec", Q_ERR_NAMETOOLONG);
        return;
    }
 
    if (len == 0) {
        Q_PrintError("exec", Q_ERR_NAMETOOSHORT);
        return;
    }
 
    ret = Cmd_ExecuteFile(buffer, 0);
    if (ret == Q_ERR_NOENT && COM_CompareExtension(buffer, ".cfg")) {
        // try with .cfg extension
        len = Q_strlcat(buffer, ".cfg", sizeof(buffer));
        if (len >= sizeof(buffer)) {
            Q_PrintError("exec", Q_ERR_NAMETOOLONG);
            return;
        }
 
        ret = Cmd_ExecuteFile(buffer, 0);
    }
 
    if (ret) {
        Com_Printf("Couldn't exec %s: %s\n", buffer, Q_ErrorString(ret));
    }
}

Cmd_ExecTrigger()

void Cmd_ExecTrigger

(

const char *

string

)

Definition at line 576 of file cmd.c.

{
    cmd_trigger_t *trigger;
    char *match;
 
    // execute matching triggers
    FOR_EACH_TRIGGER(trigger) {
        match = Cmd_MacroExpandString(trigger->match, qfalse);
        if (match && Com_WildCmp(match, string)) {
            Cbuf_AddText(&cmd_buffer, trigger->command);
            Cbuf_AddText(&cmd_buffer, "\n");
        }
    }
}

Referenced by CL_Changing_f(), CL_ParseCenterPrint(), CL_ParsePrint(), and set_active_state().

Cmd_ExecuteCommand()

void Cmd_ExecuteCommand

(

cmdbuf_t *

buf

)

Definition at line 1645 of file cmd.c.

{
    cmd_function_t  *cmd;
    cmdalias_t      *a;
    cvar_t          *v;
    char            *text;
 
    // check functions
    cmd = Cmd_Find(cmd_argv[0]);
    if (cmd) {
        if (cmd->function) {
            cmd->function();
        } else if (!CL_ForwardToServer()) {
            Com_Printf("Can't \"%s\", not connected\n", cmd_argv[0]);
        }
        return;
    }
 
    // check aliases
    a = Cmd_AliasFind(cmd_argv[0]);
    if (a) {
        if (buf->aliasCount >= ALIAS_LOOP_COUNT) {
            Com_WPrintf("Runaway alias loop\n");
            return;
        }
        text = Cmd_MacroExpandString(a->value, qtrue);
        if (text) {
            buf->aliasCount++;
            Cbuf_InsertText(buf, text);
        }
        return;
    }
 
    // check variables
    v = Cvar_FindVar(cmd_argv[0]);
    if (v) {
        Cvar_Command(v);
        return;
    }
 
    // send it as a server command if we are connected
    if (!CL_ForwardToServer()) {
        Com_Printf("Unknown command \"%s\"\n", cmd_argv[0]);
    }
}

Referenced by Cmd_ExecuteString(), and exec_server_string().

Cmd_ExecuteFile()

qerror_t Cmd_ExecuteFile	(	const char *	path,
		unsigned	flags
	)

Definition at line 1710 of file cmd.c.

{
    char    *f;
    ssize_t len;
    qerror_t ret;
    cmdbuf_t *buf;
 
    len = FS_LoadFileEx(path, (void **)&f, flags, TAG_FILESYSTEM);
    if (!f) {
        return len;
    }
 
    // check for binary file
    if (memchr(f, 0, len)) {
        ret = Q_ERR_INVALID_FORMAT;
        goto finish;
    }
 
    // sanity check file size after stripping off comments
    len = COM_Compress(f);
    if (len > CMD_BUFFER_SIZE) {
        ret = Q_ERR_FBIG;
        goto finish;
    }
 
    // FIXME: always insert into main command buffer,
    // no matter where command came from?
    buf = &cmd_buffer;
 
    // check for exec loop
    if (++buf->aliasCount > ALIAS_LOOP_COUNT) {
        ret = Q_ERR_RUNAWAY_LOOP;
        goto finish;
    }
 
    // check for overflow
    if (buf->cursize + len + 1 > buf->maxsize) {
        ret = Q_ERR_STRING_TRUNCATED;
        goto finish;
    }
 
    // everything ok, execute it
    Com_Printf("Execing %s\n", path);
    Cbuf_InsertText(buf, f);
    ret = Q_ERR_SUCCESS;
 
finish:
    FS_FreeFile(f);
    return ret;
}

Referenced by Cmd_Exec_f(), and Com_AddConfigFile().

Cmd_ExecuteString()

void Cmd_ExecuteString	(	cmdbuf_t *	buf,
		const char *	text
	)

Definition at line 1698 of file cmd.c.

{
    Cmd_TokenizeString(text, qtrue);
 
    // execute the command line
    if (!cmd_argc) {
        return;        // no tokens
    }
 
    Cmd_ExecuteCommand(buf);
}

Referenced by Cbuf_Init(), and SVC_RemoteCommand().

Cmd_Exists()

qboolean Cmd_Exists

(

const char *

name

)

Definition at line 1613 of file cmd.c.

{
    cmd_function_t *cmd = Cmd_Find(name);
 
    return cmd ? qtrue : qfalse;
}

Referenced by Cmd_Alias_f().

Cmd_Find()

static cmd_function_t* Cmd_Find ( const char *  name )

static

Definition at line 1508 of file cmd.c.

{
    cmd_function_t *cmd;
    unsigned hash;
 
    hash = Com_HashString(name, CMD_HASH_SIZE);
    FOR_EACH_CMD_HASH(cmd, hash) {
        if (!strcmp(cmd->name, name)) {
            return cmd;
        }
    }
 
    return NULL;
}

Referenced by Cmd_Complete_f(), Cmd_ExecuteCommand(), Cmd_Exists(), Cmd_FindCompleter(), Cmd_FindFunction(), Cmd_RegCommand(), and Cmd_RemoveCommand().

Cmd_FindArgForOffset()

int Cmd_FindArgForOffset

(

size_t

offset

)

Definition at line 867 of file cmd.c.

{
    int i;
 
    for (i = 1; i < cmd_argc; i++) {
        if (offset < cmd_offsets[i]) {
            break;
        }
    }
    return i - 1;
}

Referenced by Prompt_CompleteCommand().

Cmd_FindCompleter()

xcompleter_t Cmd_FindCompleter

(

const char *

name

)

Definition at line 1627 of file cmd.c.

{
    cmd_function_t *cmd = Cmd_Find(name);
 
    return cmd ? cmd->completer : NULL;
}

Referenced by Com_Generic_c().

Cmd_FindFunction()

xcommand_t Cmd_FindFunction

(

const char *

name

)

Definition at line 1620 of file cmd.c.

{
    cmd_function_t *cmd = Cmd_Find(name);
 
    return cmd ? cmd->function : NULL;
}

Cmd_FindMacro()

cmd_macro_t* Cmd_FindMacro

(

const char *

name

)

Definition at line 739 of file cmd.c.

{
    cmd_macro_t *macro;
    unsigned hash;
 
    hash = Com_HashString(name, MACRO_HASH_SIZE);
    for (macro = cmd_macroHash[hash]; macro; macro = macro->hashNext) {
        if (!strcmp(macro->name, name)) {
            return macro;
        }
    }
 
    return NULL;
}

Referenced by Cmd_AddMacro(), Cmd_MacroExpandString(), SCR_Draw_f(), and SCR_UnDraw_f().

Cmd_From()

from_t Cmd_From

(

void

)

Definition at line 851 of file cmd.c.

{
    return cmd_current->from;
}

Referenced by Cvar_Command(), Cvar_Inc_f(), Cvar_Reset_f(), Cvar_ResetAll_f(), Cvar_Set_f(), Cvar_SetFlag_f(), and Cvar_Toggle_f().

Cmd_If_f()

static void Cmd_If_f ( void  )

static

Definition at line 604 of file cmd.c.

{
    char *a, *b, *op;
    qboolean numeric;
    qboolean matched;
    int i, j;
 
    if (Cmd_Argc() < 5) {
        Com_Printf("Usage: if <expr> <op> <expr> [then] <command> [else <command>]\n");
        return;
    }
 
    a = Cmd_Argv(1);
    op = Cmd_Argv(2);
    b = Cmd_Argv(3);
 
    numeric = COM_IsFloat(a) && COM_IsFloat(b);
    if (!strcmp(op, "==")) {
        matched = numeric ? atof(a) == atof(b) : !strcmp(a, b);
    } else if (!strcmp(op, "!=") || !strcmp(op, "<>")) {
        matched = numeric ? atof(a) != atof(b) : strcmp(a, b);
    } else if (!strcmp(op, "<")) {
        if (!numeric) {
error:
            Com_Printf("Can't use '%s' with non-numeric expression(s)\n", op);
            return;
        }
        matched = atof(a) < atof(b);
    } else if (!strcmp(op, "<=")) {
        if (!numeric)
            goto error;
        matched = atof(a) <= atof(b);
    } else if (!strcmp(op, ">")) {
        if (!numeric)
            goto error;
        matched = atof(a) > atof(b);
    } else if (!strcmp(op, ">=")) {
        if (!numeric)
            goto error;
        matched = atof(a) >= atof(b);
    } else if (!Q_stricmp(op, "isin")) {
        matched = strstr(b, a) != NULL;
    } else if (!Q_stricmp(op, "!isin")) {
        matched = strstr(b, a) == NULL;
    } else if (!Q_stricmp(op, "isini")) {
        matched = Q_stristr(b, a) != NULL;
    } else if (!Q_stricmp(op, "!isini")) {
        matched = Q_stristr(b, a) == NULL;
    } else if (!Q_stricmp(op, "eq")) {
        matched = !Q_stricmp(a, b);
    } else if (!Q_stricmp(op, "ne")) {
        matched = Q_stricmp(a, b);
    } else {
        Com_Printf("Unknown operator '%s'\n", op);
        Com_Printf("Valid are: ==, != or <>, <, <=, >, >=, [!]isin[i], eq, ne\n");
        return;
    }
 
    // skip over optional 'then'
    i = 4;
    if (!Q_stricmp(Cmd_Argv(i), "then")) {
        i++;
    }
 
    // scan out branch 1 argument range
    for (j = i; i < Cmd_Argc(); i++) {
        if (!Q_stricmp(Cmd_Argv(i), "else")) {
            break;
        }
    }
 
    if (matched) {
        // execute branch 1
        if (i > j) {
            Cbuf_InsertText(cmd_current, Cmd_ArgsRange(j, i - 1));
        }
    } else {
        // execute branch 2
        if (++i < Cmd_Argc()) {
            Cbuf_InsertText(cmd_current, Cmd_ArgsFrom(i));
        }
    }
}

Cmd_Init()

void Cmd_Init

(

void

)

Definition at line 2046 of file cmd.c.

{
    int i;
 
    List_Init(&cmd_functions);
    for (i = 0; i < CMD_HASH_SIZE; i++) {
        List_Init(&cmd_hash[i]);
    }
 
    List_Init(&cmd_alias);
    for (i = 0; i < ALIAS_HASH_SIZE; i++) {
        List_Init(&cmd_aliasHash[i]);
    }
 
    List_Init(&cmd_triggers);
 
    Cmd_Register(c_cmd);
}

Referenced by Qcommon_Init().

Cmd_List_f()

static void Cmd_List_f ( void  )

static

Definition at line 1926 of file cmd.c.

{
    cmd_function_t  *cmd;
    int             i, total;
    char            *filter = NULL;
 
    if (cmd_argc > 1) {
        filter = cmd_argv[1];
    }
 
    i = total = 0;
    FOR_EACH_CMD(cmd) {
        total++;
        if (filter && !Com_WildCmp(filter, cmd->name)) {
            continue;
        }
        Com_Printf("%s\n", cmd->name);
        i++;
    }
    Com_Printf("%i of %i commands\n", i, total);
}

Cmd_Macro_g()

void Cmd_Macro_g

(

genctx_t *

ctx

)

Definition at line 754 of file cmd.c.

{
    cmd_macro_t *m;
 
    for (m = cmd_macros; m; m = m->next) {
        if (!Prompt_AddMatch(ctx, m->name)) {
            break;
        }
    }
}

Referenced by SCR_Draw_c().

Cmd_MacroExpandString()

char* Cmd_MacroExpandString	(	const char *	text,
		qboolean	aliasHack
	)

Definition at line 1218 of file cmd.c.

{
    size_t      i, j, len;
    int         count;
    qboolean    inquote;
    char        *scan, *start;
    static char expanded[MAX_STRING_CHARS];
    char        temporary[MAX_STRING_CHARS];
    char        buffer[MAX_STRING_CHARS];
    char        *token;
    cmd_macro_t *macro;
    cvar_t      *var;
    qboolean    rescan;
 
    len = strlen(text);
    if (len >= MAX_STRING_CHARS) {
        Com_Printf("Line exceeded %i chars, discarded.\n", MAX_STRING_CHARS);
        return NULL;
    }
 
    scan = memcpy(expanded, text, len + 1);
 
    inquote = qfalse;
    count = 0;
 
    for (i = 0; i < len; i++) {
        if (!scan[i]) {
            break;
        }
        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;
 
        if (*start == 0) {
            break;    // end of string
        }
 
        // allow $$ escape syntax
        if (*start == '$') {
            memmove(scan + i, start, len - i);
            continue;
        }
 
        // skip leading spaces
        while (*start && *start <= 32) {
            start++;
        }
 
        token = temporary;
 
        if (*start == '{') {
            // allow ${variable} syntax
            start++;
            if (*start == '$') {  // allow ${$variable} syntax
                start++;
            }
            while (*start) {
                if (*start == '}') {
                    start++;
                    break;
                }
                *token++ = *start++;
            }
        } else {
            // parse single word
            while (*start > 32) {
                if (*start == '$') {  // allow $var$ syntax
                    start++;
                    break;
                }
                *token++ = *start++;
            }
        }
 
        *token = 0;
 
        if (token == temporary) {
            continue;
        }
 
        rescan = qfalse;
 
        if (aliasHack) {
            // expand positional parameters only
            if (!strcmp(temporary, "@")) {
                token = Cmd_Args();
            } else {
                int arg1, arg2;
                char *s;
 
                // parse {arg1-arg2} format for ranges
                arg1 = strtoul(temporary, &s, 10);
                if (s[0] == '-') {
                    if (s[1]) {
                        arg2 = strtoul(s + 1, &s, 10);
                        if (s[0]) {
                            continue; // second part is not a number
                        }
                    } else {
                        arg2 = cmd_argc - 1;
                    }
                    token = Cmd_ArgsRange(arg1, arg2);
                } else if (s[0] == 0) {
                    token = Cmd_Argv(arg1);
                } else {
                    continue; // first part is not a number
                }
            }
        } else {
            // check for macros first
            macro = Cmd_FindMacro(temporary);
            if (macro) {
                macro->function(buffer, MAX_STRING_CHARS - len);
                token = buffer;
            } else {
                // than variables
                var = Cvar_FindVar(temporary);
                if (var && !(var->flags & CVAR_PRIVATE)) {
                    token = var->string;
                    rescan = qtrue;
                } else if (!strcmp(temporary, "qt")) {
                    token = "\"";
                } else if (!strcmp(temporary, "sc")) {
                    token = ";";
                } else {
                    token = "";
                }
            }
        }
 
        j = strlen(token);
        len += j;
        if (len >= MAX_STRING_CHARS) {
            Com_Printf("Expanded line exceeded %i chars, discarded.\n",
                       MAX_STRING_CHARS);
            Com_Printf("was %s\n", text);
            return NULL;
        }
 
        strncpy(temporary, scan, i);
        strcpy(temporary + i, token);
        strcpy(temporary + i + j, start);
 
        strcpy(expanded, temporary);
        scan = expanded;
        if (!rescan) {
            i += j;
        }
        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_ExecTrigger(), Cmd_ExecuteCommand(), and Cmd_TokenizeString().

Cmd_MacroList_f()

static void Cmd_MacroList_f ( void  )

static

Definition at line 1953 of file cmd.c.

{
    cmd_macro_t     *macro;
    int             i, total;
    char            *filter = NULL;
    char            buffer[MAX_QPATH];
 
    if (cmd_argc > 1) {
        filter = cmd_argv[1];
    }
 
    i = 0;
    for (macro = cmd_macros, total = 0; macro; macro = macro->next, total++) {
        if (filter && !Com_WildCmp(filter, macro->name)) {
            continue;
        }
        macro->function(buffer, sizeof(buffer));
        Com_Printf("%-16s %s\n", macro->name, buffer);
        i++;
    }
    Com_Printf("%i of %i macros\n", i, total);
}

Cmd_OpenURL_f()

static void Cmd_OpenURL_f ( void  )

static

Definition at line 693 of file cmd.c.

{
    if (Cmd_Argc() != 2)
    {
        Com_Printf("openurl expects a single argument that is the URL to open");
        return;
    }
 
    const char* url = Cmd_Argv(1);
    if (Q_stricmpn(url, "http://", 7) && Q_stricmpn(url, "https://", 8))
    {
        Com_Printf("the URL must start with http:// or https://");
        return;
    }
 
 
#ifdef __linux__
    pid_t pid = fork();
    if (pid == 0) {
    char * args[] = { "xdg-open", url, NULL};
    execv("/usr/bin/xdg-open", args);
    exit(0);
    }
#elif _WINDOWS
    ShellExecuteA(0, 0, url, 0, 0, SW_SHOW);
#endif
}

Cmd_Option_c()

void Cmd_Option_c	(	const cmd_option_t *	opt,
		xgenerator_t	g,
		genctx_t *	ctx,
		int	argnum
	)

Definition at line 1183 of file cmd.c.

{
    if (ctx->partial[0] == '-') {
        for (; opt->sh; opt++) {
            if (ctx->count >= ctx->size) {
                break;
            }
            if (ctx->partial[1] == '-') {
                if (!strncmp(opt->lo, ctx->partial + 2, ctx->length - 2)) {
                    ctx->matches[ctx->count++] = Z_CopyString(va("--%s", opt->lo));
                }
            } else if (!ctx->partial[1] || opt->sh[0] == ctx->partial[1]) {
                ctx->matches[ctx->count++] = Z_CopyString(va("-%c", opt->sh[0]));
            }
        }
    } else {
#if 0
        if (argnum > 1) {
            s = cmd_argv[argnum - 1];
        }
#endif
        if (g) {
            g(ctx);
        } else if (!ctx->partial[0] && ctx->count < ctx->size) {
            ctx->matches[ctx->count++] = Z_CopyString("-");
        }
    }
}

Referenced by CL_WriteConfig_c(), Cmd_EchoEx_c(), Cvar_List_c(), MVD_Connect_c(), and MVD_Play_c().

Cmd_ParseOptions()

int Cmd_ParseOptions

(

const cmd_option_t *

opt

)

Definition at line 1057 of file cmd.c.

{
    const cmd_option_t *o;
    char *s, *p;
 
    cmd_optopt = cmd_null_string;
 
    if (cmd_optind == cmd_argc) {
        cmd_optarg = cmd_null_string;
        return -1; // no more arguments
    }
 
    s = cmd_argv[cmd_optind];
    if (*s != '-') {
        cmd_optarg = s;
        return -1; // non-option argument
    }
    cmd_optopt = s++;
 
    if (*s == '-') {
        s++;
        if (*s == 0) {
            if (++cmd_optind < cmd_argc) {
                cmd_optarg = cmd_argv[cmd_optind];
            } else {
                cmd_optarg = cmd_null_string;
            }
            return -1; // special terminator
        }
 
        // check for long option argument
        if ((p = strchr(s, '=')) != NULL) {
            *p = 0;
        }
 
        // parse long option
        for (o = opt; o->sh; o++) {
            if (!strcmp(o->lo, s)) {
                break;
            }
        }
        if (!o->sh) {
            goto unknown;
        }
 
        // parse long option argument
        if (p) {
            if (o->sh[1] != ':') {
                Com_Printf("%s does not take an argument.\n", cmd_argv[cmd_optind]);
                Cmd_PrintHint();
                return '!';
            }
            cmd_optarg = p + 1;
        }
    } else {
        // parse short option
        for (o = opt; o->sh; o++) {
            if (o->sh[0] == *s) {
                break;
            }
        }
        if (!o->sh || s[1]) {
            goto unknown;
        }
        p = NULL;
    }
 
    // parse option argument
    if (!p && o->sh[1] == ':') {
        if (cmd_optind + 1 == cmd_argc) {
            Com_Printf("Missing argument to %s.\n", cmd_argv[cmd_optind]);
            Cmd_PrintHint();
            return ':';
        }
        cmd_optarg = cmd_argv[++cmd_optind];
    }
 
    cmd_optind++;
    return o->sh[0];
 
unknown:
    Com_Printf("Unknown option: %s.\n", cmd_argv[cmd_optind]);
    Cmd_PrintHint();
    return '?';
}

Referenced by CL_Record_f(), CL_WriteConfig_f(), Cmd_EchoEx_f(), Cmd_UnAlias_f(), Cvar_List_f(), FS_UnLink_f(), MVD_Connect_f(), MVD_Control_f(), MVD_Play_f(), MVD_StreamedRecord_f(), Parse_Action(), Parse_Bind(), Parse_Bitmap(), Parse_Field(), Parse_Pairs(), Parse_Range(), Parse_Savegame(), Parse_Spin(), Parse_Style(), Parse_Toggle(), and SV_MvdRecord_f().

Cmd_PrintHelp()

void Cmd_PrintHelp

(

const cmd_option_t *

opt

)

Definition at line 1160 of file cmd.c.

{
    char buffer[32];
 
    Com_Printf("\nAvailable options:\n");
    while (opt->sh) {
        if (opt->sh[1] == ':') {
            Q_concat(buffer, sizeof(buffer),
                     opt->lo, "=<", opt->sh + 2, ">", NULL);
        } else {
            Q_strlcpy(buffer, opt->lo, sizeof(buffer));
        }
        Com_Printf("-%c | --%-16.16s | %s\n", opt->sh[0], buffer, opt->help);
        opt++;
    }
    Com_Printf("\n");
}

Referenced by CL_Record_f(), CL_WriteConfig_f(), Cmd_EchoEx_f(), Cmd_UnAlias_f(), Cvar_List_f(), FS_UnLink_f(), MVD_Connect_f(), MVD_Control_f(), MVD_Play_f(), MVD_StreamedRecord_f(), and SV_MvdRecord_f().

Cmd_PrintHint()

void Cmd_PrintHint

(

void

)

Definition at line 1178 of file cmd.c.

{
    Com_Printf("Try '%s --help' for more information.\n", cmd_argv[0]);
}

Referenced by CL_Record_f(), CL_WriteConfig_f(), Cmd_ParseOptions(), FS_UnLink_f(), MVD_Connect_f(), MVD_Control_f(), MVD_Play_f(), MVD_StreamedRecord_f(), and SV_MvdRecord_f().

Cmd_PrintUsage()

void Cmd_PrintUsage	(	const cmd_option_t *	opt,
		const char *	suffix
	)

Definition at line 1143 of file cmd.c.

{
    Com_Printf("Usage: %s [-", cmd_argv[0]);
    while (opt->sh) {
        Com_Printf("%c", opt->sh[0]);
        if (opt->sh[1] == ':') {
            Com_Printf(":");
        }
        opt++;
    }
    if (suffix) {
        Com_Printf("] %s\n", suffix);
    } else {
        Com_Printf("]\n");
    }
}

Referenced by CL_Record_f(), CL_WriteConfig_f(), Cmd_EchoEx_f(), Cvar_List_f(), FS_UnLink_f(), MVD_Connect_f(), MVD_Control_f(), MVD_Play_f(), MVD_StreamedRecord_f(), and SV_MvdRecord_f().

Cmd_RawArgs()

char* Cmd_RawArgs

(

void

)

Definition at line 951 of file cmd.c.

{
    if (cmd_argc < 2) {
        return cmd_null_string;
    }
    return cmd_string + cmd_offsets[1];
}

Referenced by CL_ForwardToServer_f(), CL_Rcon_f(), start_message_mode(), SV_ConSay_f(), SV_InitGameProgs(), and SV_MvdStuff_f().

Cmd_RawArgsFrom()

char* Cmd_RawArgsFrom

(

int

from

)

Definition at line 1021 of file cmd.c.

{
    size_t offset;
 
    if (from < 0 || from >= cmd_argc) {
        return cmd_null_string;
    }
 
    offset = cmd_offsets[from];
 
    return cmd_string + offset;
}

Referenced by CL_ForwardToServer(), Cmd_EchoEx_f(), LOC_LoadLocations(), Prompt_CompleteCommand(), Push(), SV_CvarResult_f(), SV_Stuff_f(), SV_StuffAll_f(), and SVC_RemoteCommand().

Cmd_RawString()

char* Cmd_RawString

(

void

)

Definition at line 959 of file cmd.c.

{
    return cmd_string;
}

Cmd_RegCommand()

static void Cmd_RegCommand ( const cmdreg_t *  reg )

static

Definition at line 1523 of file cmd.c.

{
    cmd_function_t *cmd;
    unsigned hash;
 
// fail if the command is a variable name
    if (Cvar_Exists(reg->name, qfalse)) {
        Com_WPrintf("%s: %s already defined as a cvar\n", __func__, reg->name);
        return;
    }
 
// fail if the command already exists
    cmd = Cmd_Find(reg->name);
    if (cmd) {
        if (cmd->function) {
            Com_WPrintf("%s: %s already defined\n", __func__, reg->name);
            return;
        }
        cmd->function = reg->function;
        cmd->completer = reg->completer;
        return;
    }
 
    cmd = Cmd_Malloc(sizeof(*cmd));
    cmd->name = (char *)reg->name;
    cmd->function = reg->function;
    cmd->completer = reg->completer;
 
    List_Append(&cmd_functions, &cmd->listEntry);
 
    hash = Com_HashString(reg->name, CMD_HASH_SIZE);
    List_Append(&cmd_hash[hash], &cmd->hashEntry);
}

Referenced by Cmd_AddCommand(), and Cmd_Register().

Cmd_Register()

void Cmd_Register

(

const cmdreg_t *

reg

)

Definition at line 1572 of file cmd.c.

{
    while (reg->name) {
        Cmd_RegCommand(reg);
        reg++;
    }
}

Referenced by AC_Register(), CL_InitDemos(), CL_InitLocal(), Cmd_Init(), Con_Init(), Cvar_Init(), FS_Init(), IMG_Init(), Key_Init(), MVD_Register(), S_Init(), SCR_Init(), SV_InitOperatorCommands(), SV_MvdRegister(), SV_RegisterSavegames(), UI_Init(), and V_Init().

Cmd_RemoveCommand()

void Cmd_RemoveCommand

(

const char *

name

)

Definition at line 1593 of file cmd.c.

{
    cmd_function_t *cmd;
 
    cmd = Cmd_Find(name);
    if (!cmd) {
        Com_DPrintf("%s: %s not added\n", __func__, name);
        return;
    }
 
    List_Delete(&cmd->listEntry);
    List_Delete(&cmd->hashEntry);
    Z_Free(cmd);
}

Referenced by Cmd_Deregister(), GL_Unregister(), MOD_Shutdown(), NET_Shutdown(), OGG_Shutdown(), R_Shutdown_RTX(), and R_UnRegister().

Cmd_Shift()

void Cmd_Shift

(

void

)

Definition at line 1034 of file cmd.c.

{
    int i;
 
    if (!cmd_argc) {
        return;
    }
 
    if (cmd_argc == 1) {
        cmd_string[0] = 0;
        return;
    }
 
    cmd_argc--;
    for (i = 0; i < cmd_argc; i++) {
        cmd_offsets[i] = cmd_offsets[i + 1];
        cmd_argv[i] = cmd_argv[i + 1];
    }
 
    memmove(cmd_string, cmd_string + cmd_offsets[1],
            MAX_STRING_CHARS - cmd_offsets[1]);
}

Referenced by dummy_forward_f().

Cmd_Text_f()

static void Cmd_Text_f ( void  )

static

Definition at line 1976 of file cmd.c.

{
    Cbuf_AddText(cmd_current, Cmd_Args());
    Cbuf_AddText(cmd_current, "\n");
}

Cmd_TokenizeString()

void Cmd_TokenizeString	(	const char *	text,
		qboolean	macroExpand
	)

Definition at line 1399 of file cmd.c.

{
    int     i;
    char    *data, *start, *dest;
 
// clear the args from the last string
    for (i = 0; i < cmd_argc; i++) {
        cmd_argv[i] = NULL;
        cmd_offsets[i] = 0;
    }
 
    cmd_argc = 0;
    cmd_string[0] = 0;
    cmd_string_len = 0;
    cmd_string_tail = 0;
    cmd_optind = 1;
    cmd_optarg = cmd_optopt = cmd_null_string;
 
    if (!text[0]) {
        return;
    }
 
// macro expand the text
    if (macroExpand) {
        text = Cmd_MacroExpandString(text, qfalse);
        if (!text) {
            return;
        }
    }
 
    cmd_string_len = Q_strlcpy(cmd_string, text, sizeof(cmd_string));
    if (cmd_string_len >= sizeof(cmd_string)) {
        Com_Printf("Line exceeded %i chars, discarded.\n", MAX_STRING_CHARS);
        return;
    }
 
// strip off any trailing whitespace
    while (cmd_string_len) {
        if (cmd_string[cmd_string_len - 1] > ' ') {
            break;
        }
        cmd_string[cmd_string_len - 1] = 0;
        cmd_string_len--;
        cmd_string_tail++;
    }
 
    dest = cmd_data;
    start = data = cmd_string;
    while (cmd_argc < MAX_STRING_TOKENS) {
// skip whitespace up to a /n
        while (*data <= ' ') {
            if (*data == 0) {
                return; // end of text
            }
            if (*data == '\n') {
                return; // a newline seperates commands in the buffer
            }
            data++;
        }
 
// add new argument
        cmd_offsets[cmd_argc] = data - start;
        cmd_argv[cmd_argc] = dest;
        cmd_argc++;
 
        if (*data == ';') {
            data++;
            *dest++ = ';';
            *dest++ = 0;
            continue;
        }
 
// parse quoted string
        if (*data == '\"') {
            data++;
            while (*data != '\"') {
                if (*data == 0) {
                    return; // end of data
                }
                *dest++ = *data++;
            }
            data++;
            *dest++ = 0;
            continue;
        }
 
// parse reqular token
        while (*data > ' ') {
            if (*data == '\"') {
                break;
            }
            if (*data == ';') {
                break;
            }
            *dest++ = *data++;
        }
        *dest++ = 0;
 
        if (*data == 0) {
            return; // end of text
        }
    }
}

Referenced by CL_ConnectionlessPacket(), Cmd_ExecuteString(), dummy_exec_string(), exec_server_string(), LOC_LoadLocations(), Parse_File(), parse_stringcmd(), ParseMasterArgs(), Prompt_CompleteCommand(), SV_ConnectionlessPacket(), and SV_ExecuteUserCommand().

Cmd_Trigger_f()

static void Cmd_Trigger_f ( void  )

static

Definition at line 486 of file cmd.c.

{
    cmd_trigger_t *trigger;
    const char *command, *match;
    size_t cmdlen, matchlen;
 
    if (Cmd_Argc() == 1) {
        list_triggers();
        return;
    }
 
    if (Cmd_Argc() < 3) {
        Com_Printf("Usage: %s <command> <match>\n", Cmd_Argv(0));
        return;
    }
 
    command = Cmd_Argv(1);
    match = Cmd_ArgsFrom(2);
 
    // don't create the same trigger twice
    if (find_trigger(command, match)) {
        return;
    }
 
    cmdlen = strlen(command) + 1;
    matchlen = strlen(match) + 1;
    if (matchlen < 4) {
        Com_Printf("Match string is too short\n");
        return;
    }
 
    trigger = Z_Malloc(sizeof(*trigger) + cmdlen + matchlen);
    trigger->command = (char *)(trigger + 1);
    trigger->match = trigger->command + cmdlen;
    memcpy(trigger->command, command, cmdlen);
    memcpy(trigger->match, match, matchlen);
    List_Append(&cmd_triggers, &trigger->entry);
}

Cmd_UnAlias_c()

static void Cmd_UnAlias_c ( genctx_t *  ctx, int  argnum  )

static

Definition at line 425 of file cmd.c.

{
    if (argnum == 1) {
        Cmd_Alias_g(ctx);
    }
}

Cmd_UnAlias_f()

static void Cmd_UnAlias_f ( void  )

static

Definition at line 350 of file cmd.c.

{
    static const cmd_option_t options[] = {
        { "h", "help", "display this message" },
        { "a", "all", "delete everything" },
        { 0 }
    };
    char *s;
    cmdalias_t *a, *n;
    unsigned hash;
    int c;
 
    while ((c = Cmd_ParseOptions(options)) != -1) {
        switch (c) {
        case 'h':
            Com_Printf("Usage: %s [-ha] [name]\n", Cmd_Argv(0));
            Cmd_PrintHelp(options);
            return;
        case 'a':
            LIST_FOR_EACH_SAFE(cmdalias_t, a, n, &cmd_alias, listEntry) {
                Z_Free(a->value);
                Z_Free(a);
            }
            for (hash = 0; hash < ALIAS_HASH_SIZE; hash++) {
                List_Init(&cmd_aliasHash[hash]);
            }
            List_Init(&cmd_alias);
            Com_Printf("Removed all alias commands.\n");
            return;
        default:
            return;
        }
    }
 
    if (!cmd_optarg[0]) {
        Com_Printf("Missing alias name.\n"
                   "Try %s --help for more information.\n",
                   Cmd_Argv(0));
        return;
    }
 
    s = Cmd_Argv(1);
    a = Cmd_AliasFind(s);
    if (!a) {
        Com_Printf("\"%s\" is undefined.\n", s);
        return;
    }
 
    List_Delete(&a->listEntry);
    List_Delete(&a->hashEntry);
 
    Z_Free(a->value);
    Z_Free(a);
}

Cmd_UnTrigger_f()

static void Cmd_UnTrigger_f ( void  )

static

Definition at line 525 of file cmd.c.

{
    cmd_trigger_t *trigger, *next;
    const char *command, *match;
 
    if (Cmd_Argc() == 1) {
        list_triggers();
        return;
    }
 
    if (LIST_EMPTY(&cmd_triggers)) {
        Com_Printf("No current message triggers\n");
        return;
    }
 
    if (Cmd_Argc() == 2) {
        if (!Q_stricmp(Cmd_Argv(1), "all")) {
            int count = 0;
 
            FOR_EACH_TRIGGER_SAFE(trigger, next) {
                Z_Free(trigger);
                count++;
            }
 
            Com_Printf("Removed %d trigger%s\n", count, count == 1 ? "" : "s");
            List_Init(&cmd_triggers);
            return;
        }
 
        Com_Printf("Usage: %s <command> <match>\n", Cmd_Argv(0));
        return;
    }
 
    command = Cmd_Argv(1);
    match = Cmd_ArgsFrom(2);
 
    trigger = find_trigger(command, match);
    if (!trigger) {
        Com_Printf("Can't find trigger \"%s\" = \"%s\"\n", command, match);
        return;
    }
 
    List_Remove(&trigger->entry);
    Z_Free(trigger);
}

Cmd_Wait_f()

static void Cmd_Wait_f ( void  )

static

Definition at line 63 of file cmd.c.

{
    int count;
 
    count = atoi(Cmd_Argv(1));
    if (count < 1) {
        count = 1;
    }
    cmd_current->waitCount += count;
}

Cmd_WhiteSpaceTail()

size_t Cmd_WhiteSpaceTail

(

void

)

Definition at line 879 of file cmd.c.

{
    return cmd_string_tail;
}

Referenced by Prompt_CompleteCommand().

find_trigger()

static cmd_trigger_t* find_trigger ( const char *  command, const char *  match  )

static

Definition at line 453 of file cmd.c.

{
    cmd_trigger_t *trigger;
 
    FOR_EACH_TRIGGER(trigger) {
        if (!strcmp(trigger->command, command) && !strcmp(trigger->match, match)) {
            return trigger;
        }
    }
 
    return NULL;
}

Referenced by Cmd_Trigger_f(), and Cmd_UnTrigger_f().

list_triggers()

static void list_triggers ( void  )

static

Definition at line 466 of file cmd.c.

{
    cmd_trigger_t *trigger;
 
    if (LIST_EMPTY(&cmd_triggers)) {
        Com_Printf("No current message triggers\n");
        return;
    }
 
    Com_Printf("Current message triggers:\n");
    FOR_EACH_TRIGGER(trigger) {
        Com_Printf("\"%s\" = \"%s\"\n", trigger->command, trigger->match);
    }
}

Referenced by Cmd_Trigger_f(), and Cmd_UnTrigger_f().

unescape_string()

static char* unescape_string ( char *  dst, const char *  src  )

static

Definition at line 1842 of file cmd.c.

{
    int c1, c2;
    char *p = dst;
 
    while (*src) {
        if (src[0] == '\\' && src[1]) {
            switch (src[1]) {
            case 'a': *p++ = '\a'; break;
            case 'b': *p++ = '\b'; break;
            case 't': *p++ = '\t'; break;
            case 'n': *p++ = '\n'; break;
            case 'v': *p++ = '\v'; break;
            case 'f': *p++ = '\f'; break;
            case 'r': *p++ = '\r'; break;
            case '\\': *p++ = '\\'; break;
            case 'x':
                if ((c1 = Q_charhex(src[2])) == -1) {
                    break;
                }
                if ((c2 = Q_charhex(src[3])) == -1) {
                    break;
                }
                *p++ = (c1 << 4) | c2;
                src += 2;
                break;
            default:
                *p++ = src[1];
                break;
            }
            src += 2;
        } else {
            *p++ = *src++;
        }
    }
    *p = 0;
 
    return dst;
}

Referenced by Cmd_EchoEx_f().

Variable Documentation

c_cmd

const cmdreg_t c_cmd[]

static

Initial value:

= {
    { "cmdlist", Cmd_List_f },
    { "macrolist", Cmd_MacroList_f },
    { "exec", Cmd_Exec_f, Cmd_Exec_c },
    { "echo", Cmd_Echo_f },
    { "_echo", Cmd_EchoEx_f, Cmd_EchoEx_c },
    { "alias", Cmd_Alias_f, Cmd_Alias_c },
    { "unalias", Cmd_UnAlias_f, Cmd_UnAlias_c },
    { "wait", Cmd_Wait_f },
    { "text", Cmd_Text_f },
    { "complete", Cmd_Complete_f },
    { "trigger", Cmd_Trigger_f },
    { "untrigger", Cmd_UnTrigger_f },
    { "if", Cmd_If_f },
    { "openurl", Cmd_OpenURL_f },
 
    { NULL }
}

Definition at line 2022 of file cmd.c.

Referenced by Cmd_Init().

cmd_alias

list_t cmd_alias

static

Definition at line 228 of file cmd.c.

Referenced by Cmd_Alias_f(), Cmd_AliasSet(), Cmd_Init(), and Cmd_UnAlias_f().

cmd_aliasHash

list_t cmd_aliasHash[ALIAS_HASH_SIZE]

static

Definition at line 229 of file cmd.c.

Referenced by Cmd_AliasSet(), Cmd_Init(), and Cmd_UnAlias_f().

cmd_argc

int cmd_argc

static

Definition at line 829 of file cmd.c.

Referenced by Cmd_Argc(), Cmd_ArgOffset(), Cmd_Args(), Cmd_ArgsFrom(), Cmd_ArgsRange(), Cmd_Argv(), Cmd_ArgvBuffer(), Cmd_Complete_f(), Cmd_ExecuteString(), Cmd_FindArgForOffset(), Cmd_List_f(), Cmd_MacroExpandString(), Cmd_MacroList_f(), Cmd_ParseOptions(), Cmd_RawArgs(), Cmd_RawArgsFrom(), Cmd_Shift(), and Cmd_TokenizeString().

cmd_args

char cmd_args[MAX_STRING_CHARS]

static

Definition at line 845 of file cmd.c.

Referenced by Cmd_Args(), Cmd_ArgsFrom(), and Cmd_ArgsRange().

cmd_argv

char* cmd_argv[MAX_STRING_TOKENS]

static

Definition at line 830 of file cmd.c.

Referenced by Cmd_Args(), Cmd_ArgsFrom(), Cmd_ArgsRange(), Cmd_Argv(), Cmd_ArgvBuffer(), Cmd_Complete_f(), Cmd_ExecuteCommand(), Cmd_List_f(), Cmd_MacroList_f(), Cmd_Option_c(), Cmd_ParseOptions(), Cmd_PrintHint(), Cmd_PrintUsage(), Cmd_Shift(), and Cmd_TokenizeString().

cmd_buffer

cmdbuf_t cmd_buffer

Definition at line 49 of file cmd.c.

Referenced by Activate(), Cbuf_Init(), CL_FinalizeCmd(), CL_Pause_f(), CL_PlayDemo_f(), CL_ProcessEvents(), CL_Seek_f(), Cmd_ExecTrigger(), Cmd_ExecuteFile(), Com_AddConfigFile(), Com_AddLateCommands(), Con_Action(), Connect(), finish_demo(), Key_Event(), NET_OpenServer(), PF_AddCommandString(), PlayDemo(), Qcommon_Init(), S_Update(), SV_Frame(), SV_NextServer_f(), SVC_RemoteCommand(), and VID_ToggleFullscreen().

cmd_buffer_text

char cmd_buffer_text[CMD_BUFFER_SIZE]

Definition at line 48 of file cmd.c.

Referenced by Cbuf_Init().

cmd_current

cmdbuf_t* cmd_current

Definition at line 52 of file cmd.c.

Referenced by Cbuf_Execute(), CL_FollowIP_f(), Cmd_From(), Cmd_If_f(), Cmd_Text_f(), and Cmd_Wait_f().

cmd_data

char cmd_data[MAX_STRING_CHARS]

static

Definition at line 842 of file cmd.c.

Referenced by Cmd_TokenizeString().

cmd_functions

list_t cmd_functions

static

Definition at line 826 of file cmd.c.

Referenced by Cmd_Complete_f(), Cmd_Init(), and Cmd_RegCommand().

cmd_hash

list_t cmd_hash[CMD_HASH_SIZE]

static

Definition at line 827 of file cmd.c.

Referenced by Cmd_Complete_f(), Cmd_Init(), and Cmd_RegCommand().

cmd_macroHash

cmd_macro_t* cmd_macroHash[MACRO_HASH_SIZE]

static

Definition at line 732 of file cmd.c.

Referenced by Cmd_AddMacro(), and Cmd_FindMacro().

cmd_macros

cmd_macro_t* cmd_macros

static

Definition at line 731 of file cmd.c.

Referenced by Cmd_AddMacro(), Cmd_Macro_g(), and Cmd_MacroList_f().

cmd_null_string

char* cmd_null_string = ""

static

Definition at line 831 of file cmd.c.

Referenced by Cmd_Args(), Cmd_ArgsFrom(), Cmd_ArgsRange(), Cmd_Argv(), Cmd_ArgvBuffer(), Cmd_ParseOptions(), Cmd_RawArgs(), Cmd_RawArgsFrom(), and Cmd_TokenizeString().

cmd_offsets

size_t cmd_offsets[MAX_STRING_TOKENS]

static

Definition at line 839 of file cmd.c.

Referenced by Cmd_ArgOffset(), Cmd_FindArgForOffset(), Cmd_RawArgs(), Cmd_RawArgsFrom(), Cmd_Shift(), and Cmd_TokenizeString().

cmd_optarg

char* cmd_optarg

Definition at line 848 of file cmd.c.

Referenced by CL_Record_f(), CL_WriteConfig_f(), Cmd_EchoEx_f(), Cmd_ParseOptions(), Cmd_TokenizeString(), Cmd_UnAlias_f(), Cvar_List_f(), FS_UnLink_f(), MVD_Connect_f(), MVD_Control_f(), MVD_Play_f(), MVD_StreamedRecord_f(), Parse_Action(), Parse_Bind(), Parse_Bitmap(), Parse_Field(), Parse_Pairs(), Parse_Range(), Parse_Savegame(), Parse_Spin(), Parse_Toggle(), and SV_MvdRecord_f().

cmd_optind

int cmd_optind

Definition at line 847 of file cmd.c.

Referenced by Cmd_EchoEx_f(), Cmd_ParseOptions(), Cmd_TokenizeString(), MVD_Control_f(), MVD_Play_f(), MVD_StreamedRecord_f(), Parse_Action(), Parse_Bind(), Parse_Bitmap(), Parse_Field(), Parse_Pairs(), Parse_Range(), Parse_Savegame(), Parse_Spin(), and Parse_Toggle().

cmd_optopt

char* cmd_optopt

Definition at line 849 of file cmd.c.

Referenced by Cmd_ParseOptions(), Cmd_TokenizeString(), MVD_Control_f(), and MVD_Play_f().

cmd_string

char cmd_string[MAX_STRING_CHARS]

static

Definition at line 834 of file cmd.c.

Referenced by Cmd_RawArgs(), Cmd_RawArgsFrom(), Cmd_RawString(), Cmd_Shift(), and Cmd_TokenizeString().

cmd_string_len

size_t cmd_string_len

static

Definition at line 835 of file cmd.c.

Referenced by Cmd_ArgOffset(), and Cmd_TokenizeString().

cmd_string_tail

size_t cmd_string_tail

static

Definition at line 836 of file cmd.c.

Referenced by Cmd_TokenizeString(), and Cmd_WhiteSpaceTail().

cmd_triggers

list_t cmd_triggers

static

Definition at line 451 of file cmd.c.

Referenced by Cmd_Init(), Cmd_Trigger_f(), Cmd_UnTrigger_f(), and list_triggers().

o_echo

const cmd_option_t o_echo[]

static

Initial value:

= {
    { "h", "help", "display this message" },
    { "e", "escapes", "enable interpretation of backslash escapes" },
    { "c:color", "color", "print text in this color" },
    { "n", "no-newline", "do not output the trailing newline" },
    { NULL }
}

Definition at line 1829 of file cmd.c.

Referenced by Cmd_EchoEx_c(), and Cmd_EchoEx_f().