cmd.h

Go to the documentation of this file.

/*
Copyright (C) 1996-1997 Id Software, Inc.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
*/
 
// cmd.h -- Command buffer and command execution
 
//===========================================================================
 
/*
 
Any number of commands can be added in a frame, from several different sources.
Most commands come from either keybindings or console line input, but remote
servers can also send across commands and entire text files can be execed.
 
The + command line options are also added to the command buffer.
 
The game starts with a Cbuf_AddText ("exec quake.rc\n"); Cbuf_Execute ();
 
*/
 
#ifndef CMD_H
#define CMD_H
 
#include "qtypes.h"
#include "qdefs.h"
#include "com_list.h"
 
struct cmd_state_s;
 
// Command flags
#define CF_NONE 0u
#define CF_CLIENT               (1u<<0)  
#define CF_SERVER               (1u<<1)  
#define CF_CLIENT_FROM_SERVER   (1u<<2)  
#define CF_SERVER_FROM_CLIENT   (1u<<3)  
#define CF_CHEAT                (1u<<4)  
#define CF_ARCHIVE              (1u<<5)  
#define CF_READONLY             (1u<<6)  
#define CF_NOTIFY               (1u<<7)  
#define CF_SERVERINFO           (1u<<8)  
#define CF_USERINFO             (1u<<9)  
#define CF_PERSISTENT           (1u<<10) 
#define CF_PRIVATE              (1u<<11) 
#define CF_MAXFLAGSVAL          ((1u<<12) - 1) 
// for internal use only!
#define CF_REGISTERED           (1u<<29) 
#define CF_DEFAULTSET           (1u<<30)
#define CF_ALLOCATED            (1u<<31) 
// UBSan: unsigned literals because left shifting by 31 causes signed overflow, although it works as expected on x86.
 
#define CF_SHARED (CF_CLIENT | CF_SERVER)
 
typedef void(*xcommand_t) (struct cmd_state_s *cmd);
 
typedef enum cmd_source_s
{
    src_client,  
    src_local    
} cmd_source_t;
 
typedef struct cmd_alias_s
{
    struct cmd_alias_s *next;
    char name[MAX_ALIAS_NAME];
    char *value;
    qbool initstate;           
    char *initialvalue;        
} cmd_alias_t;
 
typedef struct cmd_function_s
{
    unsigned flags;
    struct cmd_function_s *next;
    const char *name;
    const char *description;
    xcommand_t function;
    qbool qcfunc;
    struct cmd_function_s *overridden; 
    qbool autofunc;
    qbool initstate;                   
} cmd_function_t;
 
typedef struct cmd_userdefined_s
{
    // csqc functions - this is a mess
    cmd_function_t *qc_functions;
 
    // aliases
    cmd_alias_t *alias;
}
cmd_userdefined_t;
 
typedef struct cmd_buf_s
{
    llist_t start;
    llist_t deferred;
    llist_t free;
    qbool wait;
    size_t maxsize;
    size_t size;
    char tokenizebuffer[CMD_TOKENIZELENGTH];
    int tokenizebufferpos;
    double deferred_oldtime;
    void *lock;
} cmd_buf_t;
 
typedef struct cmd_state_s
{
    struct mempool_s *mempool;
 
    int argc;
    const char *cmdline;
    const char *argv[MAX_ARGS];
    const char *null_string;
    const char *args;
    cmd_source_t source;
 
    cmd_buf_t *cbuf;
 
    cmd_userdefined_t *userdefined;   
 
    cmd_function_t *engine_functions;
 
    struct cvar_state_s *cvars;       
    unsigned cvars_flagsmask;         
    unsigned cmd_flagsmask;           
 
    qbool (*Handle)(struct cmd_state_s *, struct cmd_function_s *, const char *, size_t, enum cmd_source_s);
}
cmd_state_t;
 
qbool Cmd_Callback(cmd_state_t *cmd, cmd_function_t *func);
qbool Cmd_CL_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, size_t textlen, cmd_source_t src);
qbool Cmd_SV_Callback(cmd_state_t *cmd, cmd_function_t *func, const char *text, size_t textlen, cmd_source_t src);
 
typedef struct cmd_input_s
{
    llist_t list;
    cmd_state_t *source;
    vec_t delay;
    size_t size;   
    size_t length; 
    char *text;
    qbool pending;
} cmd_input_t;
 
extern cmd_userdefined_t cmd_userdefined_all;  
extern cmd_userdefined_t cmd_userdefined_null; 
 
extern cmd_state_t *cmd_local;
extern cmd_state_t *cmd_serverfromclient;
 
extern qbool host_stuffcmdsrun;
 
void Cbuf_Lock(cmd_buf_t *cbuf);
void Cbuf_Unlock(cmd_buf_t *cbuf);
 
void Cbuf_AddText (cmd_state_t *cmd, const char *text);
 
void Cbuf_InsertText (cmd_state_t *cmd, const char *text);
 
void Cbuf_Execute (cmd_buf_t *cbuf);
void Cbuf_Frame (cmd_buf_t *cbuf);
void Cbuf_Clear(cmd_buf_t *cbuf);
 
//===========================================================================
 
void Cmd_Init(void);
void Cmd_Shutdown(void);
 
void Cmd_SaveInitState(void);
void Cmd_RestoreInitState(void);
 
void Cmd_AddCommand(unsigned flags, const char *cmd_name, xcommand_t function, const char *description);
 
qbool Cmd_Exists (cmd_state_t *cmd, const char *cmd_name);
 
const char *Cmd_CompleteCommand (cmd_state_t *cmd, const char *partial);
 
int Cmd_CompleteAliasCountPossible (cmd_state_t *cmd, const char *partial);
const char **Cmd_CompleteAliasBuildList (cmd_state_t *cmd, const char *partial);
int Cmd_CompleteCountPossible (cmd_state_t *cmd, const char *partial);
const char **Cmd_CompleteBuildList (cmd_state_t *cmd, const char *partial);
void Cmd_CompleteCommandPrint (cmd_state_t *cmd, const char *partial);
const char *Cmd_CompleteAlias (cmd_state_t *cmd, const char *partial);
void Cmd_CompleteAliasPrint (cmd_state_t *cmd, const char *partial);
 
// Enhanced console completion by Fett erich@heintz.com
// Added by EvilTypeGuy eviltypeguy@qeradiant.com
 
// The functions that execute commands get their parameters with these functions.
static inline int Cmd_Argc (cmd_state_t *cmd)
{
    return cmd->argc;
}
static inline const char *Cmd_Argv(cmd_state_t *cmd, int arg)
{
    if (arg >= cmd->argc )
        return cmd->null_string;
    return cmd->argv[arg];
}
static inline const char *Cmd_Args (cmd_state_t *cmd)
{
    return cmd->args;
}
 
int Cmd_CheckParm (cmd_state_t *cmd, const char *parm);
 
void Cmd_ExecuteString(cmd_state_t *cmd, const char *text, size_t textlen, cmd_source_t src, qbool lockmutex);
void Cmd_PreprocessAndExecuteString(cmd_state_t *cmd, const char *text, size_t textlen, cmd_source_t src, qbool lockmutex);
 
qbool Cmd_QuoteString(char *out, size_t outlen, const char *in, const char *quoteset, qbool putquotes);
 
void Cmd_ClearCSQCCommands (cmd_state_t *cmd);
 
void Cmd_NoOperation_f(cmd_state_t *cmd);
 
#endif