prvm_edict.c File Reference

#include "quakedef.h"
#include "progsvm.h"
#include "csprogs.h"
#include "prvm_cmds.h"
#include "prvm_offsets.h"

Include dependency graph for prvm_edict.c:

Go to the source code of this file.

Data Structures
struct	debug_data_t
struct	po_string_t
struct	po_t

Macros
#define	PO_HASHSIZE   16384
#define	PRVM_DECLARE_clientfieldedict(x)
#define	PRVM_DECLARE_clientfieldfloat(x)
#define	PRVM_DECLARE_clientfieldfunction(x)
#define	PRVM_DECLARE_clientfieldstring(x)
#define	PRVM_DECLARE_clientfieldvector(x)
#define	PRVM_DECLARE_clientfunction(x)
#define	PRVM_DECLARE_clientglobaledict(x)
#define	PRVM_DECLARE_clientglobalfloat(x)
#define	PRVM_DECLARE_clientglobalfunction(x)
#define	PRVM_DECLARE_clientglobalstring(x)
#define	PRVM_DECLARE_clientglobalvector(x)
#define	PRVM_DECLARE_field(x)
#define	PRVM_DECLARE_function(x)
#define	PRVM_DECLARE_global(x)
#define	PRVM_DECLARE_menufieldedict(x)
#define	PRVM_DECLARE_menufieldfloat(x)
#define	PRVM_DECLARE_menufieldfunction(x)
#define	PRVM_DECLARE_menufieldstring(x)
#define	PRVM_DECLARE_menufieldvector(x)
#define	PRVM_DECLARE_menufunction(x)
#define	PRVM_DECLARE_menuglobaledict(x)
#define	PRVM_DECLARE_menuglobalfloat(x)
#define	PRVM_DECLARE_menuglobalfunction(x)
#define	PRVM_DECLARE_menuglobalstring(x)
#define	PRVM_DECLARE_menuglobalvector(x)
#define	PRVM_DECLARE_serverfieldedict(x)
#define	PRVM_DECLARE_serverfieldfloat(x)
#define	PRVM_DECLARE_serverfieldfunction(x)
#define	PRVM_DECLARE_serverfieldstring(x)
#define	PRVM_DECLARE_serverfieldvector(x)
#define	PRVM_DECLARE_serverfunction(x)
#define	PRVM_DECLARE_serverglobaledict(x)
#define	PRVM_DECLARE_serverglobalfloat(x)
#define	PRVM_DECLARE_serverglobalfunction(x)
#define	PRVM_DECLARE_serverglobalstring(x)
#define	PRVM_DECLARE_serverglobalvector(x)
#define	PRVM_KNOWNSTRINGBASE   0x40000000
#define	remapfield(index)
#define	remapglobal(index)

Functions
const char *	PRVM_AllocationOrigin (prvm_prog_t *prog)
int	PRVM_AllocString (prvm_prog_t *prog, size_t bufferlength, char **pointer)
void	PRVM_Breakpoint (prvm_prog_t *prog, int stack_index, const char *text)
static void	PRVM_Breakpoint_f (cmd_state_t *cmd)
const char *	PRVM_ChangeEngineString (prvm_prog_t *prog, int i, const char *s)
prvm_edict_t *	PRVM_ED_Alloc (prvm_prog_t *prog)
void	PRVM_ED_CallPostspawnFunction (prvm_prog_t *prog, prvm_edict_t *ent)
void	PRVM_ED_CallPrespawnFunction (prvm_prog_t *prog, prvm_edict_t *ent)
qbool	PRVM_ED_CallSpawnFunction (prvm_prog_t *prog, prvm_edict_t *ent, const char *data, const char *start)
qbool	PRVM_ED_CanAlloc (prvm_prog_t *prog, prvm_edict_t *e)
void	PRVM_ED_ClearEdict (prvm_prog_t *prog, prvm_edict_t *e)
static void	PRVM_ED_Count_f (cmd_state_t *cmd)
static void	PRVM_ED_EdictGet_f (cmd_state_t *cmd)
static void	PRVM_ED_EdictSet_f (cmd_state_t *cmd)
mdef_t *	PRVM_ED_FieldAtOfs (prvm_prog_t *prog, unsigned int ofs)
mdef_t *	PRVM_ED_FindField (prvm_prog_t *prog, const char *name)
int	PRVM_ED_FindFieldOffset (prvm_prog_t *prog, const char *field)
mfunction_t *	PRVM_ED_FindFunction (prvm_prog_t *prog, const char *name)
func_t	PRVM_ED_FindFunctionOffset (prvm_prog_t *prog, const char *function)
mdef_t *	PRVM_ED_FindGlobal (prvm_prog_t *prog, const char *name)
prvm_eval_t *	PRVM_ED_FindGlobalEval (prvm_prog_t *prog, const char *name)
int	PRVM_ED_FindGlobalOffset (prvm_prog_t *prog, const char *global)
void	PRVM_ED_Free (prvm_prog_t *prog, prvm_edict_t *ed)
static mdef_t *	PRVM_ED_GlobalAtOfs (prvm_prog_t *prog, unsigned int ofs)
static void	PRVM_ED_GlobalGet_f (cmd_state_t *cmd)
void	PRVM_ED_LoadFromFile (prvm_prog_t *prog, const char *data)
const char *	PRVM_ED_ParseEdict (prvm_prog_t *prog, const char *data, prvm_edict_t *ent, qbool saveload)
qbool	PRVM_ED_ParseEpair (prvm_prog_t *prog, prvm_edict_t *ent, mdef_t *key, const char *s, qbool parsebackslash)
void	PRVM_ED_ParseGlobals (prvm_prog_t *prog, const char *data)
void	PRVM_ED_Print (prvm_prog_t *prog, prvm_edict_t *ed, const char *wildcard_fieldname)
static void	PRVM_ED_PrintEdict_f (cmd_state_t *cmd)
void	PRVM_ED_PrintEdicts_f (cmd_state_t *cmd)
void	PRVM_ED_PrintNum (prvm_prog_t *prog, int ent, const char *wildcard_fieldname)
void	PRVM_ED_Write (prvm_prog_t *prog, qfile_t *f, prvm_edict_t *ed)
void	PRVM_ED_WriteGlobals (prvm_prog_t *prog, qfile_t *f)
unsigned int	PRVM_EDICT_NUM_ERROR (prvm_prog_t *prog, unsigned int n, const char *filename, int fileline)
static void	PRVM_EdictWatchpoint_f (cmd_state_t *cmd)
static void	PRVM_Fields_f (cmd_state_t *cmd)
static void	PRVM_FindOffsets (prvm_prog_t *prog)
void	PRVM_FreeString (prvm_prog_t *prog, int num)
prvm_prog_t *	PRVM_FriendlyProgFromString (const char *str)
	for console commands (prints error if name unknown and returns NULL, prints error if prog not loaded and returns NULL)
static void	PRVM_GameCommand (cmd_state_t *cmd, const char *whichprogs, const char *whichcmd)
static void	PRVM_GameCommand_Client_f (cmd_state_t *cmd)
static void	PRVM_GameCommand_Menu_f (cmd_state_t *cmd)
static void	PRVM_GameCommand_Server_f (cmd_state_t *cmd)
void	PRVM_GarbageCollection (prvm_prog_t *prog)
const char *	PRVM_GetString (prvm_prog_t *prog, int num)
static void	PRVM_Global_f (cmd_state_t *cmd)
static void	PRVM_Globals_f (cmd_state_t *cmd)
static void	PRVM_GlobalSet_f (cmd_state_t *cmd)
char *	PRVM_GlobalString (prvm_prog_t *prog, int ofs, char *line, size_t linelength)
char *	PRVM_GlobalStringNoContents (prvm_prog_t *prog, int ofs, char *line, size_t linelength)
static void	PRVM_GlobalWatchpoint_f (cmd_state_t *cmd)
void	PRVM_Init (void)
static qbool	PRVM_IsEdictReferenced (prvm_prog_t *prog, prvm_edict_t *edict, int mark)
static qbool	PRVM_IsEdictRelevant (prvm_prog_t *prog, prvm_edict_t *edict)
static qbool	PRVM_IsStringReferenced (prvm_prog_t *prog, string_t string)
void	PRVM_LeakTest (prvm_prog_t *prog)
static void	PRVM_LoadLNO (prvm_prog_t *prog, const char *progname)
static void	PRVM_MarkReferencedEdicts (prvm_prog_t *prog)
static void	PRVM_MEM_Alloc (prvm_prog_t *prog)
void	PRVM_MEM_IncreaseEdicts (prvm_prog_t *prog)
static void	PRVM_NewKnownString (prvm_prog_t *prog, int i, int flags, const char *s)
static void	PRVM_PO_Destroy (po_t *po)
static po_t *	PRVM_PO_Load (const char *filename, const char *filename2, mempool_t *pool)
static const char *	PRVM_PO_Lookup (po_t *po, const char *str)
static void	PRVM_PO_ParseString (char *out, const char *in, size_t outsize)
static void	PRVM_PO_UnparseString (char *out, const char *in, size_t outsize)
void	PRVM_Prog_Init (prvm_prog_t *prog, cmd_state_t *cmd)
void	PRVM_Prog_Load (prvm_prog_t *prog, const char *filename, unsigned char *data, fs_offset_t size, void CheckRequiredFuncs(prvm_prog_t *prog, const char *filename), int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, prvm_required_field_t *required_global)
void	PRVM_Prog_Reset (prvm_prog_t *prog)
prvm_prog_t *	PRVM_ProgFromString (const char *str)
int	PRVM_SetEngineString (prvm_prog_t *prog, const char *s)
int	PRVM_SetTempString (prvm_prog_t *prog, const char *s, size_t slen)
	Takes an strlen (not a buffer size).
char *	PRVM_UglyValueString (prvm_prog_t *prog, etype_t type, prvm_eval_t *val, char *line, size_t linelength)
static void	PRVM_UpdateBreakpoints (prvm_prog_t *prog)
static char *	PRVM_ValueString (prvm_prog_t *prog, etype_t type, prvm_eval_t *val, char *line, size_t linelength)
void	PRVM_Watchpoint (prvm_prog_t *prog, int stack_index, const char *text, etype_t type, prvm_eval_t *o, prvm_eval_t *n)

Variables
static debug_data_t	debug_data [PRVM_PROG_MAX]
cvar_t	prvm_backtraceforwarnings = {CF_CLIENT | CF_SERVER, "prvm_backtraceforwarnings", "0", "print a backtrace for warnings too"}
prvm_eval_t	prvm_badvalue
cvar_t	prvm_breakpointdump = {CF_CLIENT | CF_SERVER, "prvm_breakpointdump", "0", "write a savegame on breakpoint to breakpoint-server.dmp"}
cvar_t	prvm_coverage = {CF_CLIENT | CF_SERVER, "prvm_coverage", "0", "report and count coverage events (1: per-function, 2: coverage() builtin, 4: per-statement)"}
cvar_t	prvm_errordump = {CF_CLIENT | CF_SERVER, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"}
cvar_t	prvm_gameplayfix_div0is0 = {CF_SERVER, "prvm_gameplayfix_div0is0", "0", "When set to 1, floating point division by 0 will return zero instead of returning the IEEE standardized result (likely nan or inf). Other ways of getting non-finite values are not affected, and the warning will still print."}
cvar_t	prvm_garbagecollection_enable = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_enable", "1", "automatically scan for and free resources that are not referenced by the code being executed in the VM"}
cvar_t	prvm_garbagecollection_notify = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_notify", "0", "print out a notification for each resource freed by garbage collection (set developer >= 1 to see these)"}
cvar_t	prvm_garbagecollection_scan_limit = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_scan_limit", "50000", "scan this many fields or resources per second to free up unreferenced resources"}
	At 50k in Xonotic with 8 bots scans take about: 24s server, 25s menu, 9s client.
cvar_t	prvm_garbagecollection_strings = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_strings", "1", "automatically call strunzone() on strings that are not referenced"}
cvar_t	prvm_language = {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "prvm_language", "", "when set, loads PROGSFILE.LANGUAGENAME.po and common.LANGUAGENAME.po for string translations; when set to dump, PROGSFILE.pot is written from the strings in the progs"}
cvar_t	prvm_leaktest = {CF_CLIENT | CF_SERVER, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"}
cvar_t	prvm_leaktest_follow_targetname = {CF_CLIENT | CF_SERVER, "prvm_leaktest_follow_targetname", "0", "if set, target/targetname links are considered when leak testing; this should normally not be required, as entities created during startup - e.g. info_notnull - are never considered leaky"}
cvar_t	prvm_leaktest_ignore_classnames = {CF_CLIENT | CF_SERVER, "prvm_leaktest_ignore_classnames", "", "classnames of entities to NOT leak check because they are found by find(world, classname, ...) but are actually spawned by QC code (NOT map entities)"}
prvm_prog_t	prvm_prog_list [PRVM_PROG_MAX]
static double	prvm_reuseedicts_always_allow = 0
cvar_t	prvm_reuseedicts_neverinsameframe = {CF_CLIENT | CF_SERVER, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"}
cvar_t	prvm_reuseedicts_startuptime = {CF_CLIENT | CF_SERVER, "prvm_reuseedicts_startuptime", "2", "allows immediate re-use of freed entity slots during start of new level (value in seconds)"}
qbool	prvm_runawaycheck = true
cvar_t	prvm_statementprofiling = {CF_CLIENT | CF_SERVER, "prvm_statementprofiling", "0", "counts how many times each QuakeC statement has been executed, these counts are displayed in prvm_printfunction output (if enabled)"}
cvar_t	prvm_stringdebug = {CF_CLIENT | CF_SERVER, "prvm_stringdebug", "0", "Print debug and warning messages related to strings"}
cvar_t	prvm_timeprofiling = {CF_CLIENT | CF_SERVER, "prvm_timeprofiling", "0", "counts how long each function has been executed, these counts are displayed in prvm_profile output (if enabled)"}
cvar_t	prvm_traceqc = {CF_CLIENT | CF_SERVER, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"}
int	prvm_type_size [8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4}
	for consistency : I think a goal of this sub-project is to make the new vm mostly independent from the old one, thus if it's necessary, I copy everything
cvar_t	sv_entfields_noescapes = {CF_SERVER, "sv_entfields_noescapes", "wad", "Space-separated list of fields in which backslashes won't be parsed as escapes when loading entities from .bsp or .ent files. This is a workaround for buggy maps with unescaped backslashes used as path separators (only forward slashes are allowed in Quake VFS paths)."}

Macro Definition Documentation

PO_HASHSIZE

#define PO_HASHSIZE   16384

Definition at line 1688 of file prvm_edict.c.

Referenced by PRVM_PO_Destroy(), PRVM_PO_Load(), and PRVM_PO_Lookup().

PRVM_DECLARE_clientfieldedict

#define PRVM_DECLARE_clientfieldedict

(

x

)

PRVM_DECLARE_clientfieldfloat

#define PRVM_DECLARE_clientfieldfloat

(

x

)

PRVM_DECLARE_clientfieldfunction

#define PRVM_DECLARE_clientfieldfunction

(

x

)

PRVM_DECLARE_clientfieldstring

#define PRVM_DECLARE_clientfieldstring

(

x

)

PRVM_DECLARE_clientfieldvector

#define PRVM_DECLARE_clientfieldvector

(

x

)

PRVM_DECLARE_clientfunction

#define PRVM_DECLARE_clientfunction

(

x

)

PRVM_DECLARE_clientglobaledict

#define PRVM_DECLARE_clientglobaledict

(

x

)

PRVM_DECLARE_clientglobalfloat

#define PRVM_DECLARE_clientglobalfloat

(

x

)

PRVM_DECLARE_clientglobalfunction

#define PRVM_DECLARE_clientglobalfunction

(

x

)

PRVM_DECLARE_clientglobalstring

#define PRVM_DECLARE_clientglobalstring

(

x

)

PRVM_DECLARE_clientglobalvector

#define PRVM_DECLARE_clientglobalvector

(

x

)

PRVM_DECLARE_field

#define PRVM_DECLARE_field

(

x

)

Value:

prog->fieldoffsets.x = PRVM_ED_FindFieldOffset(prog, #x);

PRVM_DECLARE_function

#define PRVM_DECLARE_function

(

x

)

Value:

prog->funcoffsets.x = PRVM_ED_FindFunctionOffset(prog, #x);

PRVM_DECLARE_global

#define PRVM_DECLARE_global

(

x

)

Value:

prog->globaloffsets.x = PRVM_ED_FindGlobalOffset(prog, #x);

PRVM_DECLARE_menufieldedict

#define PRVM_DECLARE_menufieldedict

(

x

)

PRVM_DECLARE_menufieldfloat

#define PRVM_DECLARE_menufieldfloat

(

x

)

PRVM_DECLARE_menufieldfunction

#define PRVM_DECLARE_menufieldfunction

(

x

)

PRVM_DECLARE_menufieldstring

#define PRVM_DECLARE_menufieldstring

(

x

)

PRVM_DECLARE_menufieldvector

#define PRVM_DECLARE_menufieldvector

(

x

)

PRVM_DECLARE_menufunction

#define PRVM_DECLARE_menufunction

(

x

)

PRVM_DECLARE_menuglobaledict

#define PRVM_DECLARE_menuglobaledict

(

x

)

PRVM_DECLARE_menuglobalfloat

#define PRVM_DECLARE_menuglobalfloat

(

x

)

PRVM_DECLARE_menuglobalfunction

#define PRVM_DECLARE_menuglobalfunction

(

x

)

PRVM_DECLARE_menuglobalstring

#define PRVM_DECLARE_menuglobalstring

(

x

)

PRVM_DECLARE_menuglobalvector

#define PRVM_DECLARE_menuglobalvector

(

x

)

PRVM_DECLARE_serverfieldedict

#define PRVM_DECLARE_serverfieldedict

(

x

)

PRVM_DECLARE_serverfieldfloat

#define PRVM_DECLARE_serverfieldfloat

(

x

)

PRVM_DECLARE_serverfieldfunction

#define PRVM_DECLARE_serverfieldfunction

(

x

)

PRVM_DECLARE_serverfieldstring

#define PRVM_DECLARE_serverfieldstring

(

x

)

PRVM_DECLARE_serverfieldvector

#define PRVM_DECLARE_serverfieldvector

(

x

)

PRVM_DECLARE_serverfunction

#define PRVM_DECLARE_serverfunction

(

x

)

PRVM_DECLARE_serverglobaledict

#define PRVM_DECLARE_serverglobaledict

(

x

)

PRVM_DECLARE_serverglobalfloat

#define PRVM_DECLARE_serverglobalfloat

(

x

)

PRVM_DECLARE_serverglobalfunction

#define PRVM_DECLARE_serverglobalfunction

(

x

)

PRVM_DECLARE_serverglobalstring

#define PRVM_DECLARE_serverglobalstring

(

x

)

PRVM_DECLARE_serverglobalvector

#define PRVM_DECLARE_serverglobalvector

(

x

)

PRVM_KNOWNSTRINGBASE

#define PRVM_KNOWNSTRINGBASE   0x40000000

Definition at line 3281 of file prvm_edict.c.

Referenced by PRVM_AllocString(), PRVM_ChangeEngineString(), PRVM_FreeString(), PRVM_GarbageCollection(), PRVM_GetString(), PRVM_LeakTest(), and PRVM_SetEngineString().

remapfield

#define remapfield

(

index

)

Value:

(index)

remapglobal

#define remapglobal

(

index

)

Value:

(index)

Referenced by PRVM_Prog_Load().

Function Documentation

PRVM_AllocationOrigin()

const char * PRVM_AllocationOrigin

(

prvm_prog_t *

prog

)

Definition at line 223 of file prvm_edict.c.

{
    char *buf = NULL;
    if(prog->leaktest_active)
    if(prog->depth > 0) // actually in QC code and not just parsing the entities block of a map/savegame
    {
        // bones_was_here: this is the smallest 64 multiple that avoids truncation in Xonotic (was 256)
        buf = (char *)PRVM_Alloc(448);
        PRVM_ShortStackTrace(prog, buf, 448);
    }
    return buf;
}

References buf, prvm_prog_t::depth, prvm_prog_t::leaktest_active, NULL, PRVM_Alloc, and PRVM_ShortStackTrace().

Referenced by PRVM_AllocString(), PRVM_ED_ClearEdict(), VM_buf_create(), VM_fopen(), and VM_search_begin().

PRVM_AllocString()

int PRVM_AllocString	(	prvm_prog_t *	prog,
		size_t	bufferlength,
		char **	pointer )

Definition at line 3459 of file prvm_edict.c.

{
    int i;
    char *s;
    if (!bufferlength)
    {
        if (pointer)
            *pointer = NULL;
        return 0;
    }
    for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
        if (!prog->knownstrings[i])
            break;
    s = (char *)PRVM_Alloc(bufferlength);
    PRVM_NewKnownString(prog, i, KNOWNSTRINGFLAG_GCMARK, s);
    if(prog->leaktest_active)
        prog->knownstrings_origin[i] = PRVM_AllocationOrigin(prog);
    if (pointer)
        *pointer = (char *)(prog->knownstrings[i]);
    return PRVM_KNOWNSTRINGBASE + i;
}

References prvm_prog_t::firstfreeknownstring, i, KNOWNSTRINGFLAG_GCMARK, prvm_prog_t::knownstrings, prvm_prog_t::knownstrings_origin, prvm_prog_t::leaktest_active, NULL, pointer, PRVM_Alloc, PRVM_AllocationOrigin(), PRVM_KNOWNSTRINGBASE, and PRVM_NewKnownString().

Referenced by PRVM_ED_CallSpawnFunction(), PRVM_ED_ParseEpair(), and VM_strzone().

PRVM_Breakpoint()

void PRVM_Breakpoint	(	prvm_prog_t *	prog,
		int	stack_index,
		const char *	text )

Definition at line 3000 of file prvm_edict.c.

{
    char vabuf[1024];
    Con_Printf("PRVM_Breakpoint: %s\n", text);
    PRVM_PrintState(prog, stack_index);
    if (prvm_breakpointdump.integer)
        SV_Savegame_to(prog, va(vabuf, sizeof(vabuf), "breakpoint-%s.dmp", prog->name));
}

References Con_Printf(), cvar_t::integer, prvm_prog_t::name, prvm_breakpointdump, PRVM_PrintState(), SV_Savegame_to(), and va().

Referenced by PRVM_Watchpoint(), and while().

PRVM_Breakpoint_f()

static void PRVM_Breakpoint_f ( cmd_state_t * cmd )

static

Definition at line 3105 of file prvm_edict.c.

{
    prvm_prog_t *prog;
 
    if( Cmd_Argc(cmd) == 2 ) {
        if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
            return;
        {
            debug_data_t *debug = &debug_data[prog - prvm_prog_list];
            debug->break_statement[0] = 0;
        }
        PRVM_UpdateBreakpoints(prog);
        return;
    }
    if( Cmd_Argc(cmd) != 3 ) {
        Con_Printf( "prvm_breakpoint <program name> <function name | statement>\n" );
        return;
    }
 
    if (!(prog = PRVM_ProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    {
        debug_data_t *debug = &debug_data[prog - prvm_prog_list];
        dp_strlcpy(debug->break_statement, Cmd_Argv(cmd, 2), sizeof(debug->break_statement));
    }
    PRVM_UpdateBreakpoints(prog);
}

References debug_data_t::break_statement, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), debug_data, dp_strlcpy, PRVM_FriendlyProgFromString(), prvm_prog_list, PRVM_ProgFromString(), and PRVM_UpdateBreakpoints().

Referenced by PRVM_Init().

PRVM_ChangeEngineString()

const char * PRVM_ChangeEngineString	(	prvm_prog_t *	prog,
		int	i,
		const char *	s )

Definition at line 3345 of file prvm_edict.c.

{
    const char *old;
    i = i - PRVM_KNOWNSTRINGBASE;
    if (i < 0 || i >= prog->numknownstrings)
        prog->error_cmd("PRVM_ChangeEngineString: string index %i is out of bounds", i);
    else if ((prog->knownstrings_flags[i] & KNOWNSTRINGFLAG_ENGINE) == 0)
        prog->error_cmd("PRVM_ChangeEngineString: string index %i is not an engine string", i);
    old = prog->knownstrings[i];
    prog->knownstrings[i] = s;
    return old;
}

References prvm_prog_t::error_cmd, i, KNOWNSTRINGFLAG_ENGINE, prvm_prog_t::knownstrings, prvm_prog_t::knownstrings_flags, prvm_prog_t::numknownstrings, and PRVM_KNOWNSTRINGBASE.

Referenced by Cvar_UpdateAutoCvar().

PRVM_ED_Alloc()

prvm_edict_t * PRVM_ED_Alloc

(

prvm_prog_t *

prog

)

Definition at line 269 of file prvm_edict.c.

{
    int i;
    prvm_edict_t *e;
 
    // the client qc dont need maxclients
    // thus it doesnt need to use svs.maxclients
    // AK:  changed i=svs.maxclients+1
    // AK:  changed so the edict 0 wont spawn -> used as reserved/world entity
    //      although the menu/client has no world
    for (i = prog->reserved_edicts + 1;i < prog->num_edicts;i++)
    {
        e = PRVM_EDICT_NUM(i);
        if(PRVM_ED_CanAlloc(prog, e))
        {
            PRVM_ED_ClearEdict (prog, e);
            return e;
        }
    }
 
    if (i == prog->limit_edicts)
        prog->error_cmd("%s: PRVM_ED_Alloc: no free edicts", prog->name);
 
    prog->num_edicts++;
    if (prog->num_edicts >= prog->max_edicts)
        PRVM_MEM_IncreaseEdicts(prog);
 
    e = PRVM_EDICT_NUM(i);
 
    PRVM_ED_ClearEdict(prog, e);
    return e;
}

References prvm_prog_t::error_cmd, i, prvm_prog_t::limit_edicts, prvm_prog_t::max_edicts, prvm_prog_t::name, prvm_prog_t::num_edicts, PRVM_ED_CanAlloc(), PRVM_ED_ClearEdict(), PRVM_EDICT_NUM, PRVM_MEM_IncreaseEdicts(), and prvm_prog_t::reserved_edicts.

Referenced by CSQC_ReadEntities(), PRVM_ED_LoadFromFile(), SV_Ent_Create_f(), VM_CL_spawn(), and VM_spawn().

PRVM_ED_CallPostspawnFunction()

void PRVM_ED_CallPostspawnFunction	(	prvm_prog_t *	prog,
		prvm_edict_t *	ent )

Definition at line 1484 of file prvm_edict.c.

{
    if(!ent->free)
    if (PRVM_serverfunction(SV_OnEntityPostSpawnFunction))
    {
        // self = ent
        PRVM_serverglobalfloat(time) = sv.time;
        PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
        prog->ExecuteProgram(prog, PRVM_serverfunction(SV_OnEntityPostSpawnFunction), "QC function SV_OnEntityPostSpawnFunction is missing");
    }
}

References prvm_prog_t::ExecuteProgram, prvm_edict_t::free, PRVM_EDICT_TO_PROG, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, self, sv, server_t::time, and time.

Referenced by PRVM_ED_LoadFromFile(), and SV_Ent_Create_f().

PRVM_ED_CallPrespawnFunction()

void PRVM_ED_CallPrespawnFunction	(	prvm_prog_t *	prog,
		prvm_edict_t *	ent )

Definition at line 1389 of file prvm_edict.c.

{
    if (PRVM_serverfunction(SV_OnEntityPreSpawnFunction))
    {
        // self = ent
        PRVM_serverglobalfloat(time) = sv.time;
        PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
        prog->ExecuteProgram(prog, PRVM_serverfunction(SV_OnEntityPreSpawnFunction), "QC function SV_OnEntityPreSpawnFunction is missing");
    }
}

References prvm_prog_t::ExecuteProgram, PRVM_EDICT_TO_PROG, PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, self, sv, server_t::time, and time.

Referenced by PRVM_ED_LoadFromFile(), and SV_Ent_Create_f().

PRVM_ED_CallSpawnFunction()

qbool PRVM_ED_CallSpawnFunction	(	prvm_prog_t *	prog,
		prvm_edict_t *	ent,
		const char *	data,
		const char *	start )

Definition at line 1400 of file prvm_edict.c.

{
    const char *funcname;
    mfunction_t *func;
    prvm_eval_t *fulldata = NULL;
    char vabuf[1024];
 
//
// immediately call spawn function, but only if there is a self global and a classname
//
    if (!ent->free)
    {
        if (!PRVM_alledictstring(ent, classname))
        {
            Con_Print("No classname for:\n");
            PRVM_ED_Print(prog, ent, NULL);
            PRVM_ED_Free (prog, ent);
            return false;
        }
        /*
         * This is required for FTE compatibility (FreeCS).
         * It copies the key/value pairs themselves into a
         * global for QC to parse on its own.
         */
        else if (data && start)
        {
            if((fulldata = PRVM_ED_FindGlobalEval(prog, "__fullspawndata")))
            {
                const char *in;
                char *spawndata;
                fulldata->string = PRVM_AllocString(prog, data - start + 1, &spawndata);
                for(in = start; in < data; )
                {
                    char c = *in++;
                    if(c == '\n')
                        *spawndata++ = '\t';
                    else
                        *spawndata++ = c;
                }
                *spawndata = 0;
            }
        }
 
        // look for the spawn function
        funcname = PRVM_GetString(prog, PRVM_alledictstring(ent, classname));
        func = PRVM_ED_FindFunction (prog, va(vabuf, sizeof(vabuf), "spawnfunc_%s", funcname));
        if(!func)
            if(!PRVM_allglobalfloat(require_spawnfunc_prefix))
                func = PRVM_ED_FindFunction (prog, funcname);
 
        if (!func)
        {
            // check for OnEntityNoSpawnFunction
            if (PRVM_serverfunction(SV_OnEntityNoSpawnFunction))
            {
                // self = ent
                PRVM_serverglobalfloat(time) = sv.time;
                PRVM_serverglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
                prog->ExecuteProgram(prog, PRVM_serverfunction(SV_OnEntityNoSpawnFunction), "QC function SV_OnEntityNoSpawnFunction is missing");
            }
            else
            {
 
                Con_DPrint("No spawn function for:\n");
                if (developer.integer > 0) // don't confuse non-developers with errors
                    PRVM_ED_Print(prog, ent, NULL);
 
                PRVM_ED_Free (prog, ent);
                return false; // not included in "inhibited" count
            }
        }
        else
        {
            // self = ent
            PRVM_serverglobalfloat(time) = sv.time;
            PRVM_allglobaledict(self) = PRVM_EDICT_TO_PROG(ent);
            prog->ExecuteProgram(prog, func - prog->functions, "");
        }
        return true;
    }
    PRVM_ED_Free(prog, ent);
    return false;
}

References classname, Con_DPrint(), Con_Print(), data, developer, prvm_prog_t::ExecuteProgram, prvm_edict_t::free, prvm_prog_t::functions, cvar_t::integer, NULL, PRVM_alledictstring, PRVM_allglobaledict, PRVM_allglobalfloat, PRVM_AllocString(), PRVM_ED_FindFunction(), PRVM_ED_FindGlobalEval(), PRVM_ED_Free(), PRVM_ED_Print(), PRVM_EDICT_TO_PROG, PRVM_GetString(), PRVM_serverfunction, PRVM_serverglobaledict, PRVM_serverglobalfloat, self, prvm_eval_t::string, sv, server_t::time, time, and va().

Referenced by PRVM_ED_LoadFromFile(), and SV_Ent_Create_f().

PRVM_ED_CanAlloc()

qbool PRVM_ED_CanAlloc	(	prvm_prog_t *	prog,
		prvm_edict_t *	e )

Definition at line 243 of file prvm_edict.c.

{
    if(!e->free)
        return false;
    if(prvm_reuseedicts_always_allow == host.realtime)
        return true;
    if(host.realtime <= e->freetime + 0.1 && prvm_reuseedicts_neverinsameframe.integer)
        return false; // never allow reuse in same frame (causes networking trouble)
    if(e->freetime < prog->starttime + prvm_reuseedicts_startuptime.value)
        return true;
    if(host.realtime > e->freetime + 1)
        return true;
    return false; // entity slot still blocked because the entity was freed less than one second ago
}

References prvm_edict_t::free, prvm_edict_t::freetime, host, cvar_t::integer, prvm_reuseedicts_always_allow, prvm_reuseedicts_neverinsameframe, prvm_reuseedicts_startuptime, host_static_t::realtime, prvm_prog_t::starttime, and cvar_t::value.

Referenced by PRVM_ED_Alloc(), and SV_Physics().

PRVM_ED_ClearEdict()

void PRVM_ED_ClearEdict	(	prvm_prog_t *	prog,
		prvm_edict_t *	e )

Definition at line 210 of file prvm_edict.c.

{
    memset(e->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
    e->free = false;
    e->freetime = host.realtime;
    if(e->priv.required->allocation_origin)
        Mem_Free((char *)e->priv.required->allocation_origin);
    e->priv.required->allocation_origin = PRVM_AllocationOrigin(prog);
 
    // AK: Let the init_edict function determine if something needs to be initialized
    prog->init_edict(prog, e);
}

References prvm_edict_private_t::allocation_origin, prvm_prog_t::entityfields, prvm_edict_t::fields, prvm_edict_t::fp, prvm_edict_t::free, prvm_edict_t::freetime, host, prvm_prog_t::init_edict, Mem_Free, prvm_edict_t::priv, PRVM_AllocationOrigin(), host_static_t::realtime, and prvm_edict_t::required.

Referenced by PRVM_ED_Alloc(), SV_ConnectClient(), SV_DropClient(), SV_Ent_Remove_All_f(), SV_Ent_Remove_f(), and SV_SpawnServer().

PRVM_ED_Count_f()

static void PRVM_ED_Count_f ( cmd_state_t * cmd )

static

Definition at line 871 of file prvm_edict.c.

{
    prvm_prog_t *prog;
 
    if(Cmd_Argc(cmd) != 2)
    {
        Con_Print("prvm_count <program name>\n");
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    prog->count_edicts(prog);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), prvm_prog_t::count_edicts, and PRVM_FriendlyProgFromString().

Referenced by PRVM_Init().

PRVM_ED_EdictGet_f()

static void PRVM_ED_EdictGet_f ( cmd_state_t * cmd )

static

Definition at line 1157 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    prvm_edict_t *ed;
    mdef_t *key;
    const char *s;
    prvm_eval_t *v;
    char valuebuf[MAX_INPUTLINE];
 
    if(Cmd_Argc(cmd) != 4 && Cmd_Argc(cmd) != 5)
    {
        Con_Print("prvm_edictget <program name> <edict number> <field> [<cvar>]\n");
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(cmd, 2)));
 
    if((key = PRVM_ED_FindField(prog, Cmd_Argv(cmd, 3))) == 0)
    {
        Con_Printf("Key %s not found !\n", Cmd_Argv(cmd, 3));
        goto fail;
    }
 
    v = (prvm_eval_t *)(ed->fields.fp + key->ofs);
    s = PRVM_UglyValueString(prog, (etype_t)key->type, v, valuebuf, sizeof(valuebuf));
    if(Cmd_Argc(cmd) == 5)
    {
        cvar_t *cvar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 4), cmd->cvars_flagsmask);
        if (cvar)
            if(Cvar_Readonly(cvar, "prvm_edictget"))
                goto fail;
 
        Cvar_Get(cmd->cvars, Cmd_Argv(cmd, 4), s, cmd->cvars_flagsmask, NULL);
    }
    else
        Con_Printf("%s\n", s);
 
fail:
    ;
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), cvar(), Cvar_FindVar(), Cvar_Get(), Cvar_Readonly(), prvm_edict_t::fields, prvm_edict_t::fp, MAX_INPUTLINE, NULL, mdef_t::ofs, PRVM_ED_FindField(), PRVM_EDICT_NUM, PRVM_FriendlyProgFromString(), PRVM_UglyValueString(), mdef_t::type, and v.

Referenced by PRVM_Init().

PRVM_ED_EdictSet_f()

static void PRVM_ED_EdictSet_f ( cmd_state_t * cmd )

static

Definition at line 1249 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    prvm_edict_t *ed;
    mdef_t *key;
 
    if(Cmd_Argc(cmd) != 5)
    {
        Con_Print("prvm_edictset <program name> <edict number> <field> <value>\n");
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(cmd, 2)));
 
    if((key = PRVM_ED_FindField(prog, Cmd_Argv(cmd, 3))) == 0)
        Con_Printf("Key %s not found!\n", Cmd_Argv(cmd, 3));
    else
        PRVM_ED_ParseEpair(prog, ed, key, Cmd_Argv(cmd, 4), true);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), PRVM_ED_FindField(), PRVM_ED_ParseEpair(), PRVM_EDICT_NUM, and PRVM_FriendlyProgFromString().

Referenced by PRVM_Init().

PRVM_ED_FieldAtOfs()

mdef_t * PRVM_ED_FieldAtOfs	(	prvm_prog_t *	prog,
		unsigned int	ofs )

Definition at line 357 of file prvm_edict.c.

{
    mdef_t      *def;
    int         i;
 
    for (i = 0;i < prog->numfielddefs;i++)
    {
        def = &prog->fielddefs[i];
        if (def->ofs == ofs)
            return def;
    }
    return NULL;
}

References prvm_prog_t::fielddefs, i, NULL, prvm_prog_t::numfielddefs, mdef_t::ofs, and ofs.

Referenced by PRVM_UglyValueString(), PRVM_ValueString(), and while().

PRVM_ED_FindField()

mdef_t * PRVM_ED_FindField	(	prvm_prog_t *	prog,
		const char *	name )

Definition at line 376 of file prvm_edict.c.

{
    mdef_t *def;
    int i;
 
    for (i = 0;i < prog->numfielddefs;i++)
    {
        def = &prog->fielddefs[i];
        if (!strcmp(PRVM_GetString(prog, def->s_name), name))
            return def;
    }
    return NULL;
}

References prvm_prog_t::fielddefs, i, name, NULL, prvm_prog_t::numfielddefs, PRVM_GetString(), and mdef_t::s_name.

Referenced by PRVM_ED_EdictGet_f(), PRVM_ED_EdictSet_f(), PRVM_ED_FindFieldOffset(), PRVM_ED_ParseEdict(), PRVM_ED_ParseEpair(), PRVM_UpdateBreakpoints(), and SV_Ent_Create_f().

PRVM_ED_FindFieldOffset()

int PRVM_ED_FindFieldOffset	(	prvm_prog_t *	prog,
		const char *	field )

Definition at line 134 of file prvm_edict.c.

{
    mdef_t *d;
    d = PRVM_ED_FindField(prog, field);
    if (!d)
        return -1;
    return d->ofs;
}

References mdef_t::ofs, and PRVM_ED_FindField().

PRVM_ED_FindFunction()

mfunction_t * PRVM_ED_FindFunction	(	prvm_prog_t *	prog,
		const char *	name )

Definition at line 425 of file prvm_edict.c.

{
    mfunction_t     *func;
    int             i;
 
    for (i = 0;i < prog->numfunctions;i++)
    {
        func = &prog->functions[i];
        if (!strcmp(PRVM_GetString(prog, func->s_name), name))
            return func;
    }
    return NULL;
}

References prvm_prog_t::functions, i, name, NULL, prvm_prog_t::numfunctions, PRVM_GetString(), and mfunction_t::s_name.

Referenced by CL_CheckRequiredFuncs(), MP_CheckRequiredFuncs(), PRVM_ED_CallSpawnFunction(), PRVM_ED_FindFunctionOffset(), PRVM_ED_ParseEpair(), PRVM_PrintFunctionStatements(), PRVM_UpdateBreakpoints(), VM_callfunction(), and VM_isfunction().

PRVM_ED_FindFunctionOffset()

func_t PRVM_ED_FindFunctionOffset	(	prvm_prog_t *	prog,
		const char *	function )

Definition at line 152 of file prvm_edict.c.

{
    mfunction_t *f;
    f = PRVM_ED_FindFunction(prog, function);
    if (!f)
        return 0;
    return (func_t)(f - prog->functions);
}

References f, prvm_prog_t::functions, and PRVM_ED_FindFunction().

PRVM_ED_FindGlobal()

mdef_t * PRVM_ED_FindGlobal	(	prvm_prog_t *	prog,
		const char *	name )

Definition at line 395 of file prvm_edict.c.

{
    mdef_t *def;
    int i;
 
    for (i = 0;i < prog->numglobaldefs;i++)
    {
        def = &prog->globaldefs[i];
        if (!strcmp(PRVM_GetString(prog, def->s_name), name))
            return def;
    }
    return NULL;
}

References prvm_prog_t::globaldefs, i, name, NULL, prvm_prog_t::numglobaldefs, PRVM_GetString(), and mdef_t::s_name.

Referenced by PRVM_ED_FindGlobalEval(), PRVM_ED_FindGlobalOffset(), PRVM_ED_GlobalGet_f(), PRVM_ED_ParseGlobals(), PRVM_Global_f(), PRVM_GlobalSet_f(), and PRVM_UpdateBreakpoints().

PRVM_ED_FindGlobalEval()

prvm_eval_t * PRVM_ED_FindGlobalEval	(	prvm_prog_t *	prog,
		const char *	name )

Definition at line 414 of file prvm_edict.c.

{
    mdef_t *def = PRVM_ED_FindGlobal(prog, name);
    return def ? (prvm_eval_t *) &prog->globals.fp[def->ofs] : NULL;
}

References prvm_prog_t::fp, prvm_prog_t::globals, name, NULL, mdef_t::ofs, and PRVM_ED_FindGlobal().

Referenced by PRVM_ED_CallSpawnFunction().

PRVM_ED_FindGlobalOffset()

int PRVM_ED_FindGlobalOffset	(	prvm_prog_t *	prog,
		const char *	global )

Definition at line 143 of file prvm_edict.c.

{
    mdef_t *d;
    d = PRVM_ED_FindGlobal(prog, global);
    if (!d)
        return -1;
    return d->ofs;
}

References mdef_t::ofs, and PRVM_ED_FindGlobal().

PRVM_ED_Free()

void PRVM_ED_Free	(	prvm_prog_t *	prog,
		prvm_edict_t *	ed )

Definition at line 314 of file prvm_edict.c.

{
    // dont delete the null entity (world) or reserved edicts
    if (ed - prog->edicts <= prog->reserved_edicts)
        return;
 
    prog->free_edict(prog, ed);
 
    ed->free = true;
    ed->freetime = host.realtime;
    if(ed->priv.required->allocation_origin)
    {
        Mem_Free((char *)ed->priv.required->allocation_origin);
        ed->priv.required->allocation_origin = NULL;
    }
}

References prvm_edict_private_t::allocation_origin, prvm_prog_t::edicts, prvm_edict_t::free, prvm_prog_t::free_edict, prvm_edict_t::freetime, host, Mem_Free, NULL, prvm_edict_t::priv, host_static_t::realtime, prvm_edict_t::required, and prvm_prog_t::reserved_edicts.

Referenced by PRVM_ED_CallSpawnFunction(), PRVM_ED_LoadFromFile(), SV_Ent_Create_f(), SV_Ent_Remove_All_f(), SV_Ent_Remove_f(), VM_CL_makestatic(), VM_objerror(), VM_remove(), and VM_SV_makestatic().

PRVM_ED_GlobalAtOfs()

static mdef_t * PRVM_ED_GlobalAtOfs ( prvm_prog_t * prog, unsigned int ofs )

static

Definition at line 338 of file prvm_edict.c.

{
    mdef_t      *def;
    int         i;
 
    for (i = 0;i < prog->numglobaldefs;i++)
    {
        def = &prog->globaldefs[i];
        if (def->ofs == ofs)
            return def;
    }
    return NULL;
}

References prvm_prog_t::globaldefs, i, NULL, prvm_prog_t::numglobaldefs, mdef_t::ofs, and ofs.

Referenced by PRVM_GlobalString(), and PRVM_GlobalStringNoContents().

PRVM_ED_GlobalGet_f()

static void PRVM_ED_GlobalGet_f ( cmd_state_t * cmd )

static

Definition at line 1201 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    mdef_t *key;
    const char *s;
    prvm_eval_t *v;
    char valuebuf[MAX_INPUTLINE];
 
    if(Cmd_Argc(cmd) != 3 && Cmd_Argc(cmd) != 4)
    {
        Con_Print("prvm_globalget <program name> <global> [<cvar>]\n");
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    key = PRVM_ED_FindGlobal(prog, Cmd_Argv(cmd, 2));
    if(!key)
    {
        Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(cmd, 2), Cmd_Argv(cmd, 1) );
        goto fail;
    }
 
    v = (prvm_eval_t *) &prog->globals.fp[key->ofs];
    s = PRVM_UglyValueString(prog, (etype_t)key->type, v, valuebuf, sizeof(valuebuf));
    if(Cmd_Argc(cmd) == 4)
    {
        cvar_t *cvar = Cvar_FindVar(cmd->cvars, Cmd_Argv(cmd, 3), cmd->cvars_flagsmask);
        if (cvar)
            if(Cvar_Readonly(cvar, "prvm_globalget"))
                goto fail;
        Cvar_Get(cmd->cvars, Cmd_Argv(cmd, 3), s, cmd->cvars_flagsmask, NULL);
    }
    else
        Con_Printf("%s\n", s);
 
fail:
    ;
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), cvar(), Cvar_FindVar(), Cvar_Get(), Cvar_Readonly(), prvm_prog_t::fp, prvm_prog_t::globals, MAX_INPUTLINE, NULL, mdef_t::ofs, PRVM_ED_FindGlobal(), PRVM_FriendlyProgFromString(), PRVM_UglyValueString(), mdef_t::type, and v.

Referenced by PRVM_Init().

PRVM_ED_LoadFromFile()

void PRVM_ED_LoadFromFile	(	prvm_prog_t *	prog,
		const char *	data )

Definition at line 1511 of file prvm_edict.c.

{
    prvm_edict_t *ent;
    const char *start;
    int parsed, inhibited, spawned, died;
 
    parsed = 0;
    inhibited = 0;
    spawned = 0;
    died = 0;
 
    prvm_reuseedicts_always_allow = host.realtime;
 
    // parse ents
    while (1)
    {
        start = data;
 
        // parse the opening brace
        if (!COM_ParseToken_Simple(&data, false, false, true))
            break;
        if (com_token[0] != '{')
            prog->error_cmd("PRVM_ED_LoadFromFile: %s: found %s when expecting {", prog->name, com_token);
 
        // CHANGED: this is not conform to PR_LoadFromFile
        if(prog->loadintoworld)
        {
            prog->loadintoworld = false;
            ent = PRVM_EDICT_NUM(0);
        }
        else
            ent = PRVM_ED_Alloc(prog);
 
        // clear it
        if (ent != prog->edicts)    // hack
            memset (ent->fields.fp, 0, prog->entityfields * sizeof(prvm_vec_t));
 
        data = PRVM_ED_ParseEdict (prog, data, ent, false);
        parsed++;
 
        // remove the entity ?
        if(!prog->load_edict(prog, ent))
        {
            PRVM_ED_Free(prog, ent);
            inhibited++;
            continue;
        }
 
        PRVM_ED_CallPrespawnFunction(prog, ent);
 
        if(ent->free)
        {
            inhibited++;
            continue;
        }
 
        SV_LinkEdict(ent);
 
        if(!PRVM_ED_CallSpawnFunction(prog, ent, data, start))
            continue;
 
        PRVM_ED_CallPostspawnFunction(prog, ent);
 
        spawned++;
        if (ent->free)
            died++;
    }
 
    Con_DPrintf("%s: %i new entities parsed, %i new inhibited, %i (%i new) spawned (whereas %i removed self, %i stayed)\n", prog->name, parsed, inhibited, prog->num_edicts, spawned, died, spawned - died);
 
    prvm_reuseedicts_always_allow = 0;
}

References COM_ParseToken_Simple(), com_token, Con_DPrintf(), data, prvm_prog_t::edicts, prvm_prog_t::entityfields, prvm_prog_t::error_cmd, prvm_edict_t::fields, prvm_edict_t::fp, prvm_edict_t::free, host, prvm_prog_t::load_edict, prvm_prog_t::loadintoworld, prvm_prog_t::name, prvm_prog_t::num_edicts, PRVM_ED_Alloc(), PRVM_ED_CallPostspawnFunction(), PRVM_ED_CallPrespawnFunction(), PRVM_ED_CallSpawnFunction(), PRVM_ED_Free(), PRVM_ED_ParseEdict(), PRVM_EDICT_NUM, prvm_reuseedicts_always_allow, host_static_t::realtime, and SV_LinkEdict().

Referenced by SV_SpawnServer(), VM_loadfromdata(), and VM_loadfromfile().

PRVM_ED_ParseEdict()

const char * PRVM_ED_ParseEdict	(	prvm_prog_t *	prog,
		const char *	data,
		prvm_edict_t *	ent,
		qbool	saveload )

Definition at line 1281 of file prvm_edict.c.

{
    mdef_t *key;
    qbool anglehack;
    qbool init = false;
    qbool parsebackslash = true;
    char keyname[256];
    size_t n;
 
// go through all the dictionary pairs
    while (1)
    {
    // parse key
        if (!COM_ParseToken_Simple(&data, false, false, true))
            prog->error_cmd("PRVM_ED_ParseEdict: EOF without closing brace");
        if (developer_entityparsing.integer)
            Con_Printf("Key: \"%s\"", com_token);
        if (com_token[0] == '}')
            break;
 
        // anglehack is to allow QuakeEd to write single scalar angles
        // and allow them to be turned into vectors. (FIXME...)
        if (!strcmp(com_token, "angle"))
        {
            dp_strlcpy (com_token, "angles", sizeof(com_token));
            anglehack = true;
        }
        else
            anglehack = false;
 
        // FIXME: change light to _light to get rid of this hack
        if (!strcmp(com_token, "light"))
            dp_strlcpy (com_token, "light_lev", sizeof(com_token)); // hack for single light def
 
        n = dp_strlcpy (keyname, com_token, sizeof(keyname));
 
        // another hack to fix keynames with trailing spaces
        while (n && keyname[n-1] == ' ')
        {
            keyname[n-1] = 0;
            n--;
        }
 
    // Check if escape parsing is disabled for this key (see cvar description).
    // Escapes are always used in savegames and DP_QC_ENTITYSTRING for compatibility.
        if (!saveload)
        {
            const char *cvarpos = sv_entfields_noescapes.string;
 
            while (COM_ParseToken_Console(&cvarpos))
            {
                if (strcmp(com_token, keyname) == 0)
                {
                    parsebackslash = false;
                    break;
                }
            }
        }
 
    // parse value
        // If loading a save, unescape characters (they're escaped when saving).
        // Otherwise, load them as they are (BSP compilers don't support escaping).
        if (!COM_ParseToken_Simple(&data, false, parsebackslash, true))
            prog->error_cmd("PRVM_ED_ParseEdict: EOF without closing brace");
        if (developer_entityparsing.integer)
            Con_Printf(" \"%s\"\n", com_token);
 
        if (com_token[0] == '}')
            prog->error_cmd("PRVM_ED_ParseEdict: closing brace without data");
 
        init = true;
 
        // ignore attempts to set key "" (this problem occurs in nehahra neh1m8.bsp)
        if (!keyname[0])
            continue;
 
// keynames with a leading underscore are used for utility comments,
// and are immediately discarded by quake
        if (keyname[0] == '_')
            continue;
 
        key = PRVM_ED_FindField (prog, keyname);
        if (!key)
        {
            Con_DPrintf("%s: '%s' is not a field\n", prog->name, keyname);
            continue;
        }
 
        if (anglehack)
        {
            char    temp[32];
            dp_strlcpy (temp, com_token, sizeof(temp));
            dpsnprintf (com_token, sizeof(com_token), "0 %s 0", temp);
        }
 
        if (!PRVM_ED_ParseEpair(prog, ent, key, com_token, false))
            prog->error_cmd("PRVM_ED_ParseEdict: parse error");
    }
 
    if (!init)
    {
        ent->free = true;
        ent->freetime = host.realtime;
    }
 
    return data;
}

References COM_ParseToken_Console(), COM_ParseToken_Simple(), com_token, Con_DPrintf(), Con_Printf(), data, developer_entityparsing, dp_strlcpy, dpsnprintf(), prvm_prog_t::error_cmd, prvm_edict_t::free, prvm_edict_t::freetime, host, cvar_t::integer, n, prvm_prog_t::name, PRVM_ED_FindField(), PRVM_ED_ParseEpair(), host_static_t::realtime, cvar_t::string, and sv_entfields_noescapes.

Referenced by PRVM_ED_LoadFromFile(), SV_Loadgame_f(), and VM_parseentitydata().

PRVM_ED_ParseEpair()

qbool PRVM_ED_ParseEpair	(	prvm_prog_t *	prog,
		prvm_edict_t *	ent,
		mdef_t *	key,
		const char *	s,
		qbool	parsebackslash )

Definition at line 991 of file prvm_edict.c.

{
    int i, l;
    char *new_p;
    mdef_t *def;
    prvm_eval_t *val;
    mfunction_t *func;
 
    if (ent)
        val = (prvm_eval_t *)(ent->fields.fp + key->ofs);
    else
        val = (prvm_eval_t *)(prog->globals.fp + key->ofs);
    switch (key->type & ~DEF_SAVEGLOBAL)
    {
    case ev_string:
        l = (int)strlen(s) + 1;
        val->string = PRVM_AllocString(prog, l, &new_p);
        for (i = 0;i < l;i++)
        {
            if (s[i] == '\\' && s[i+1] && parsebackslash)
            {
                i++;
                if (s[i] == 'n')
                    *new_p++ = '\n';
                else if (s[i] == 'r')
                    *new_p++ = '\r';
                else
                    *new_p++ = s[i];
            }
            else
                *new_p++ = s[i];
        }
        break;
 
    case ev_float:
        while (*s && ISWHITESPACE(*s))
            s++;
        val->_float = atof(s);
        break;
 
    case ev_vector:
        for (i = 0;i < 3;i++)
        {
            while (*s && ISWHITESPACE(*s))
                s++;
            if (!*s)
                break;
            val->vector[i] = atof(s);
            while (!ISWHITESPACE(*s))
                s++;
            if (!*s)
                break;
        }
        break;
 
    case ev_entity:
        while (*s && ISWHITESPACE(*s))
            s++;
        i = atoi(s);
        if (i >= prog->limit_edicts)
            Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, prog->limit_edicts, prog->name);
        while (i >= prog->max_edicts)
            PRVM_MEM_IncreaseEdicts(prog);
        // if IncreaseEdicts was called the base pointer needs to be updated
        if (ent)
            val = (prvm_eval_t *)(ent->fields.fp + key->ofs);
        val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM((int)i));
        break;
 
    case ev_field:
        if (*s != '.')
        {
            Con_DPrintf("PRVM_ED_ParseEpair: Bogus field name %s in %s\n", s, prog->name);
            return false;
        }
        def = PRVM_ED_FindField(prog, s + 1);
        if (!def)
        {
            Con_DPrintf("PRVM_ED_ParseEpair: Can't find field %s in %s\n", s, prog->name);
            return false;
        }
        val->_int = def->ofs;
        break;
 
    case ev_function:
        func = PRVM_ED_FindFunction(prog, s);
        if (!func)
        {
            Con_Printf("PRVM_ED_ParseEpair: Can't find function %s in %s\n", s, prog->name);
            return false;
        }
        val->function = func - prog->functions;
        break;
 
    default:
        Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PRVM_GetString(prog, key->s_name), prog->name);
        return false;
    }
    return true;
}

References prvm_eval_t::_float, prvm_eval_t::_int, Con_DPrintf(), Con_Printf(), DEF_SAVEGLOBAL, prvm_eval_t::edict, ev_entity, ev_field, ev_float, ev_function, ev_string, ev_vector, prvm_edict_t::fields, prvm_edict_t::fp, prvm_prog_t::fp, prvm_eval_t::function, prvm_prog_t::functions, prvm_prog_t::globals, i, int(), ISWHITESPACE, prvm_prog_t::limit_edicts, prvm_prog_t::max_edicts, prvm_prog_t::name, mdef_t::ofs, PRVM_AllocString(), PRVM_ED_FindField(), PRVM_ED_FindFunction(), PRVM_EDICT_NUM, PRVM_EDICT_TO_PROG, PRVM_GetString(), PRVM_MEM_IncreaseEdicts(), mdef_t::s_name, prvm_eval_t::string, strlen(), mdef_t::type, and prvm_eval_t::vector.

Referenced by PRVM_ED_EdictSet_f(), PRVM_ED_ParseEdict(), PRVM_ED_ParseGlobals(), PRVM_GlobalSet_f(), SV_Ent_Create_f(), and VM_putentityfieldstring().

PRVM_ED_ParseGlobals()

void PRVM_ED_ParseGlobals	(	prvm_prog_t *	prog,
		const char *	data )

Definition at line 940 of file prvm_edict.c.

{
    char keyname[MAX_INPUTLINE];
    mdef_t *key;
 
    while (1)
    {
        // parse key
        if (!COM_ParseToken_Simple(&data, false, false, true))
            prog->error_cmd("PRVM_ED_ParseGlobals: EOF without closing brace");
        if (com_token[0] == '}')
            break;
 
        if (developer_entityparsing.integer)
            Con_Printf("Key: \"%s\"", com_token);
 
        dp_strlcpy (keyname, com_token, sizeof(keyname));
 
        // parse value
        if (!COM_ParseToken_Simple(&data, false, true, true))
            prog->error_cmd("PRVM_ED_ParseGlobals: EOF without closing brace");
 
        if (developer_entityparsing.integer)
            Con_Printf(" \"%s\"\n", com_token);
 
        if (com_token[0] == '}')
            prog->error_cmd("PRVM_ED_ParseGlobals: closing brace without data");
 
        key = PRVM_ED_FindGlobal (prog, keyname);
        if (!key)
        {
            Con_DPrintf("'%s' is not a global on %s\n", keyname, prog->name);
            continue;
        }
 
        if (!PRVM_ED_ParseEpair(prog, NULL, key, com_token, true))
            prog->error_cmd("PRVM_ED_ParseGlobals: parse error");
    }
}

References COM_ParseToken_Simple(), com_token, Con_DPrintf(), Con_Printf(), data, developer_entityparsing, dp_strlcpy, prvm_prog_t::error_cmd, cvar_t::integer, MAX_INPUTLINE, prvm_prog_t::name, NULL, PRVM_ED_FindGlobal(), and PRVM_ED_ParseEpair().

Referenced by SV_Loadgame_f().

PRVM_ED_Print()

void PRVM_ED_Print	(	prvm_prog_t *	prog,
		prvm_edict_t *	ed,
		const char *	wildcard_fieldname )

Definition at line 657 of file prvm_edict.c.

{
    size_t  l;
    mdef_t  *d;
    prvm_eval_t *val;
    int     i, j;
    const char  *name;
    int     type;
    char    tempstring[MAX_INPUTLINE], tempstring2[260]; // temporary string buffers
    char    valuebuf[MAX_INPUTLINE];
 
    if (ed->free)
    {
        Con_Printf("%s: FREE\n",prog->name);
        return;
    }
 
    tempstring[0] = 0;
    dpsnprintf(tempstring, sizeof(tempstring), "\n%s EDICT %i:\n", prog->name, PRVM_NUM_FOR_EDICT(ed));
    for (i = 1;i < prog->numfielddefs;i++)
    {
        d = &prog->fielddefs[i];
        name = PRVM_GetString(prog, d->s_name);
        if(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z'))
            continue;   // skip _x, _y, _z vars
 
        // Check Field Name Wildcard
        if(wildcard_fieldname)
            if( !matchpattern(name, wildcard_fieldname, 1) )
                // Didn't match; skip
                continue;
 
        val = (prvm_eval_t *)(ed->fields.fp + d->ofs);
 
    // if the value is still all 0, skip the field
        type = d->type & ~DEF_SAVEGLOBAL;
 
        for (j=0 ; j<prvm_type_size[type] ; j++)
            if (val->ivector[j])
                break;
        if (j == prvm_type_size[type])
            continue;
 
        if (strlen(name) > sizeof(tempstring2)-4)
        {
            memcpy (tempstring2, name, sizeof(tempstring2)-4);
            tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
            tempstring2[sizeof(tempstring2)-1] = 0;
            name = tempstring2;
        }
        dp_strlcat(tempstring, name, sizeof(tempstring));
        for (l = strlen(name);l < 14;l++)
            dp_strlcat(tempstring, " ", sizeof(tempstring));
        dp_strlcat(tempstring, " ", sizeof(tempstring));
 
        name = PRVM_ValueString(prog, (etype_t)d->type, val, valuebuf, sizeof(valuebuf));
        if (strlen(name) > sizeof(tempstring2)-4)
        {
            memcpy (tempstring2, name, sizeof(tempstring2)-4);
            tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
            tempstring2[sizeof(tempstring2)-1] = 0;
            name = tempstring2;
        }
        dp_strlcat(tempstring, name, sizeof(tempstring));
        dp_strlcat(tempstring, "\n", sizeof(tempstring));
        if (strlen(tempstring) >= sizeof(tempstring)/2)
        {
            Con_Print(tempstring);
            tempstring[0] = 0;
        }
    }
    if (tempstring[0])
        Con_Print(tempstring);
}

References Con_Print(), Con_Printf(), dp_strlcat, dpsnprintf(), prvm_prog_t::fielddefs, prvm_edict_t::fields, prvm_edict_t::fp, prvm_edict_t::free, i, prvm_eval_t::ivector, matchpattern(), MAX_INPUTLINE, name, prvm_prog_t::name, prvm_prog_t::numfielddefs, mdef_t::ofs, PRVM_GetString(), PRVM_NUM_FOR_EDICT, prvm_type_size, PRVM_ValueString(), mdef_t::s_name, strlen(), mdef_t::type, and type.

Referenced by CLVM_ExecuteProgram(), PRVM_ED_CallSpawnFunction(), PRVM_ED_PrintNum(), PRVM_LeakTest(), SVVM_ExecuteProgram(), VM_error(), and VM_objerror().

PRVM_ED_PrintEdict_f()

static void PRVM_ED_PrintEdict_f ( cmd_state_t * cmd )

static

Definition at line 832 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    int     i;
    const char  *wildcard_fieldname;
 
    if(Cmd_Argc(cmd) < 3 || Cmd_Argc(cmd) > 4)
    {
        Con_Print("prvm_edict <program name> <edict number> <optional field name wildcard>\n");
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    i = atoi (Cmd_Argv(cmd, 2));
    if (i >= prog->num_edicts)
    {
        Con_Print("Bad edict number\n");
        return;
    }
    if( Cmd_Argc(cmd) == 4)
        // Optional Wildcard Provided
        wildcard_fieldname = Cmd_Argv(cmd, 3);
    else
        // Use All
        wildcard_fieldname = NULL;
    PRVM_ED_PrintNum (prog, i, wildcard_fieldname);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), i, NULL, prvm_prog_t::num_edicts, PRVM_ED_PrintNum(), and PRVM_FriendlyProgFromString().

Referenced by PRVM_Init().

PRVM_ED_PrintEdicts_f()

void PRVM_ED_PrintEdicts_f

(

cmd_state_t *

cmd

)

Definition at line 800 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    int     i;
    const char *wildcard_fieldname;
 
    if(Cmd_Argc(cmd) < 2 || Cmd_Argc(cmd) > 3)
    {
        Con_Print("prvm_edicts <program name> <optional field name wildcard>\n");
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    if( Cmd_Argc(cmd) == 3)
        wildcard_fieldname = Cmd_Argv(cmd, 2);
    else
        wildcard_fieldname = NULL;
 
    Con_Printf("%s: %i entities\n", prog->name, prog->num_edicts);
    for (i=0 ; i<prog->num_edicts ; i++)
        PRVM_ED_PrintNum (prog, i, wildcard_fieldname);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), i, prvm_prog_t::name, NULL, prvm_prog_t::num_edicts, PRVM_ED_PrintNum(), and PRVM_FriendlyProgFromString().

Referenced by PRVM_Init().

PRVM_ED_PrintNum()

void PRVM_ED_PrintNum	(	prvm_prog_t *	prog,
		int	ent,
		const char *	wildcard_fieldname )

Definition at line 788 of file prvm_edict.c.

{
    PRVM_ED_Print(prog, PRVM_EDICT_NUM(ent), wildcard_fieldname);
}

References PRVM_ED_Print(), and PRVM_EDICT_NUM.

Referenced by PRVM_ED_PrintEdict_f(), PRVM_ED_PrintEdicts_f(), and VM_eprint().

PRVM_ED_Write()

void PRVM_ED_Write	(	prvm_prog_t *	prog,
		qfile_t *	f,
		prvm_edict_t *	ed )

Definition at line 739 of file prvm_edict.c.

{
    mdef_t  *d;
    prvm_eval_t *val;
    int     i, j;
    const char  *name;
    int     type;
    char vabuf[1024];
    char valuebuf[MAX_INPUTLINE];
 
    FS_Print(f, "{\n");
 
    if (ed->free)
    {
        FS_Print(f, "}\n");
        return;
    }
 
    for (i = 1;i < prog->numfielddefs;i++)
    {
        d = &prog->fielddefs[i];
        name = PRVM_GetString(prog, d->s_name);
 
        if(developer_entityparsing.integer)
            Con_Printf("PRVM_ED_Write: at entity %d field %s\n", PRVM_NUM_FOR_EDICT(ed), name);
 
        //if(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z'))
        if(strlen(name) > 1 && name[strlen(name)-2] == '_')
            continue;   // skip _x, _y, _z vars, and ALSO other _? vars as some mods expect them to be never saved (TODO: a gameplayfix for using the "more precise" condition above?)
 
        val = (prvm_eval_t *)(ed->fields.fp + d->ofs);
 
    // if the value is still all 0, skip the field
        type = d->type & ~DEF_SAVEGLOBAL;
        for (j=0 ; j<prvm_type_size[type] ; j++)
            if (val->ivector[j])
                break;
        if (j == prvm_type_size[type])
            continue;
 
        FS_Printf(f,"\"%s\" ",name);
        prog->statestring = va(vabuf, sizeof(vabuf), "PRVM_ED_Write, ent=%d, name=%s", i, name);
        FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(prog, (etype_t)d->type, val, valuebuf, sizeof(valuebuf)));
        prog->statestring = NULL;
    }
 
    FS_Print(f, "}\n");
}

References Con_Printf(), developer_entityparsing, f, prvm_prog_t::fielddefs, prvm_edict_t::fields, prvm_edict_t::fp, prvm_edict_t::free, FS_Print(), FS_Printf(), i, cvar_t::integer, prvm_eval_t::ivector, MAX_INPUTLINE, name, NULL, prvm_prog_t::numfielddefs, mdef_t::ofs, PRVM_GetString(), PRVM_NUM_FOR_EDICT, prvm_type_size, PRVM_UglyValueString(), mdef_t::s_name, prvm_prog_t::statestring, strlen(), mdef_t::type, type, and va().

PRVM_ED_WriteGlobals()

void PRVM_ED_WriteGlobals	(	prvm_prog_t *	prog,
		qfile_t *	f )

Definition at line 901 of file prvm_edict.c.

{
    mdef_t      *def;
    int         i;
    const char      *name;
    int         type;
    char vabuf[1024];
    char valuebuf[MAX_INPUTLINE];
 
    FS_Print(f,"{\n");
    for (i = 0;i < prog->numglobaldefs;i++)
    {
        def = &prog->globaldefs[i];
        type = def->type;
        if ( !(def->type & DEF_SAVEGLOBAL) )
            continue;
        type &= ~DEF_SAVEGLOBAL;
 
        if (type != ev_string && type != ev_float && type != ev_entity)
            continue;
 
        name = PRVM_GetString(prog, def->s_name);
 
        if(developer_entityparsing.integer)
            Con_Printf("PRVM_ED_WriteGlobals: at global %s\n", name);
 
        prog->statestring = va(vabuf, sizeof(vabuf), "PRVM_ED_WriteGlobals, name=%s", name);
        FS_Printf(f,"\"%s\" ", name);
        FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(prog, (etype_t)type, (prvm_eval_t *)&prog->globals.fp[def->ofs], valuebuf, sizeof(valuebuf)));
        prog->statestring = NULL;
    }
    FS_Print(f,"}\n");
}

References Con_Printf(), DEF_SAVEGLOBAL, developer_entityparsing, ev_entity, ev_float, ev_string, f, prvm_prog_t::fp, FS_Print(), FS_Printf(), prvm_prog_t::globaldefs, prvm_prog_t::globals, i, cvar_t::integer, MAX_INPUTLINE, name, NULL, prvm_prog_t::numglobaldefs, mdef_t::ofs, PRVM_GetString(), PRVM_UglyValueString(), mdef_t::s_name, prvm_prog_t::statestring, mdef_t::type, type, and va().

PRVM_EDICT_NUM_ERROR()

unsigned int PRVM_EDICT_NUM_ERROR	(	prvm_prog_t *	prog,
		unsigned int	n,
		const char *	filename,
		int	fileline )

Definition at line 3275 of file prvm_edict.c.

{
    prog->error_cmd("PRVM_EDICT_NUM: %s: bad number %i (called at %s:%i)", prog->name, n, filename, fileline);
    return 0;
}

References prvm_prog_t::error_cmd, n, and prvm_prog_t::name.

PRVM_EdictWatchpoint_f()

static void PRVM_EdictWatchpoint_f ( cmd_state_t * cmd )

static

Definition at line 3163 of file prvm_edict.c.

{
    prvm_prog_t *prog;
 
    if( Cmd_Argc(cmd) == 2 ) {
        if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
            return;
        {
            debug_data_t *debug = &debug_data[prog - prvm_prog_list];
            debug->watch_field[0] = 0;
        }
        PRVM_UpdateBreakpoints(prog);
        return;
    }
    if( Cmd_Argc(cmd) != 4 ) {
        Con_Printf( "prvm_edictwatchpoint <program name> <edict number> <field name>\n" );
        return;
    }
 
    if (!(prog = PRVM_ProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    {
        debug_data_t *debug = &debug_data[prog - prvm_prog_list];
        debug->watch_edict = atoi(Cmd_Argv(cmd, 2));
        dp_strlcpy(debug->watch_field, Cmd_Argv(cmd, 3), sizeof(debug->watch_field));
    }
    PRVM_UpdateBreakpoints(prog);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), debug_data, dp_strlcpy, PRVM_FriendlyProgFromString(), prvm_prog_list, PRVM_ProgFromString(), PRVM_UpdateBreakpoints(), debug_data_t::watch_edict, and debug_data_t::watch_field.

Referenced by PRVM_Init().

PRVM_Fields_f()

static void PRVM_Fields_f ( cmd_state_t * cmd )

static

Definition at line 2773 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    int i, j, ednum, used, usedamount;
    int *counts;
    char tempstring[MAX_INPUTLINE], tempstring2[260];
    const char *name;
    prvm_edict_t *ed;
    mdef_t *d;
    prvm_eval_t *val;
 
    // TODO
    /*
    if (!sv.active)
    {
        Con_Print("no progs loaded\n");
        return;
    }
    */
 
    if(Cmd_Argc(cmd) != 2)
    {
        Con_Print("prvm_fields <program name>\n");
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    counts = (int *)Mem_Alloc(tempmempool, prog->numfielddefs * sizeof(int));
    for (ednum = 0;ednum < prog->max_edicts;ednum++)
    {
        ed = PRVM_EDICT_NUM(ednum);
        if (ed->free)
            continue;
        for (i = 1;i < prog->numfielddefs;i++)
        {
            d = &prog->fielddefs[i];
            name = PRVM_GetString(prog, d->s_name);
            if (name[strlen(name)-2] == '_')
                continue;   // skip _x, _y, _z vars
            val = (prvm_eval_t *)(ed->fields.fp + d->ofs);
            // if the value is still all 0, skip the field
            for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++)
            {
                if (val->ivector[j])
                {
                    counts[i]++;
                    break;
                }
            }
        }
    }
    used = 0;
    usedamount = 0;
    tempstring[0] = 0;
    for (i = 0;i < prog->numfielddefs;i++)
    {
        d = &prog->fielddefs[i];
        name = PRVM_GetString(prog, d->s_name);
        if (name[strlen(name)-2] == '_')
            continue;   // skip _x, _y, _z vars
        switch(d->type & ~DEF_SAVEGLOBAL)
        {
        case ev_string:
            dp_strlcat(tempstring, "string   ", sizeof(tempstring));
            break;
        case ev_entity:
            dp_strlcat(tempstring, "entity   ", sizeof(tempstring));
            break;
        case ev_function:
            dp_strlcat(tempstring, "function ", sizeof(tempstring));
            break;
        case ev_field:
            dp_strlcat(tempstring, "field    ", sizeof(tempstring));
            break;
        case ev_void:
            dp_strlcat(tempstring, "void     ", sizeof(tempstring));
            break;
        case ev_float:
            dp_strlcat(tempstring, "float    ", sizeof(tempstring));
            break;
        case ev_vector:
            dp_strlcat(tempstring, "vector   ", sizeof(tempstring));
            break;
        case ev_pointer:
            dp_strlcat(tempstring, "pointer  ", sizeof(tempstring));
            break;
        default:
            dpsnprintf (tempstring2, sizeof(tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
            dp_strlcat(tempstring, tempstring2, sizeof(tempstring));
            break;
        }
        if (strlen(name) > sizeof(tempstring2)-4)
        {
            memcpy (tempstring2, name, sizeof(tempstring2)-4);
            tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
            tempstring2[sizeof(tempstring2)-1] = 0;
            name = tempstring2;
        }
        dp_strlcat(tempstring, name, sizeof(tempstring));
        for (j = (int)strlen(name);j < 25;j++)
            dp_strlcat(tempstring, " ", sizeof(tempstring));
        dpsnprintf(tempstring2, sizeof(tempstring2), "%5d", counts[i]);
        dp_strlcat(tempstring, tempstring2, sizeof(tempstring));
        dp_strlcat(tempstring, "\n", sizeof(tempstring));
        if (strlen(tempstring) >= sizeof(tempstring)/2)
        {
            Con_Print(tempstring);
            tempstring[0] = 0;
        }
        if (counts[i])
        {
            used++;
            usedamount += prvm_type_size[d->type & ~DEF_SAVEGLOBAL];
        }
    }
    Mem_Free(counts);
    Con_Printf("%s: %i entity fields (%i in use), totalling %i bytes per edict (%i in use), %i edicts allocated, %i bytes total spent on edict fields (%i needed)\n", prog->name, prog->entityfields, used, prog->entityfields * 4, usedamount * 4, prog->max_edicts, prog->entityfields * 4 * prog->max_edicts, usedamount * 4 * prog->max_edicts);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), DEF_SAVEGLOBAL, dp_strlcat, dpsnprintf(), prvm_prog_t::entityfields, ev_entity, ev_field, ev_float, ev_function, ev_pointer, ev_string, ev_vector, ev_void, prvm_prog_t::fielddefs, prvm_edict_t::fields, prvm_edict_t::fp, prvm_edict_t::free, i, prvm_eval_t::ivector, prvm_prog_t::max_edicts, MAX_INPUTLINE, Mem_Alloc, Mem_Free, name, prvm_prog_t::name, prvm_prog_t::numfielddefs, mdef_t::ofs, PRVM_EDICT_NUM, PRVM_FriendlyProgFromString(), PRVM_GetString(), prvm_type_size, mdef_t::s_name, strlen(), tempmempool, and mdef_t::type.

Referenced by PRVM_Init().

PRVM_FindOffsets()

static void PRVM_FindOffsets ( prvm_prog_t * prog )

static

Definition at line 1584 of file prvm_edict.c.

{
    // field and global searches use -1 for NULL
    memset(&prog->fieldoffsets, -1, sizeof(prog->fieldoffsets));
    memset(&prog->globaloffsets, -1, sizeof(prog->globaloffsets));
    // function searches use 0 for NULL
    memset(&prog->funcoffsets, 0, sizeof(prog->funcoffsets));
#define PRVM_DECLARE_serverglobalfloat(x)
#define PRVM_DECLARE_serverglobalvector(x)
#define PRVM_DECLARE_serverglobalstring(x)
#define PRVM_DECLARE_serverglobaledict(x)
#define PRVM_DECLARE_serverglobalfunction(x)
#define PRVM_DECLARE_clientglobalfloat(x)
#define PRVM_DECLARE_clientglobalvector(x)
#define PRVM_DECLARE_clientglobalstring(x)
#define PRVM_DECLARE_clientglobaledict(x)
#define PRVM_DECLARE_clientglobalfunction(x)
#define PRVM_DECLARE_menuglobalfloat(x)
#define PRVM_DECLARE_menuglobalvector(x)
#define PRVM_DECLARE_menuglobalstring(x)
#define PRVM_DECLARE_menuglobaledict(x)
#define PRVM_DECLARE_menuglobalfunction(x)
#define PRVM_DECLARE_serverfieldfloat(x)
#define PRVM_DECLARE_serverfieldvector(x)
#define PRVM_DECLARE_serverfieldstring(x)
#define PRVM_DECLARE_serverfieldedict(x)
#define PRVM_DECLARE_serverfieldfunction(x)
#define PRVM_DECLARE_clientfieldfloat(x)
#define PRVM_DECLARE_clientfieldvector(x)
#define PRVM_DECLARE_clientfieldstring(x)
#define PRVM_DECLARE_clientfieldedict(x)
#define PRVM_DECLARE_clientfieldfunction(x)
#define PRVM_DECLARE_menufieldfloat(x)
#define PRVM_DECLARE_menufieldvector(x)
#define PRVM_DECLARE_menufieldstring(x)
#define PRVM_DECLARE_menufieldedict(x)
#define PRVM_DECLARE_menufieldfunction(x)
#define PRVM_DECLARE_serverfunction(x)
#define PRVM_DECLARE_clientfunction(x)
#define PRVM_DECLARE_menufunction(x)
#define PRVM_DECLARE_field(x) prog->fieldoffsets.x = PRVM_ED_FindFieldOffset(prog, #x);
#define PRVM_DECLARE_global(x) prog->globaloffsets.x = PRVM_ED_FindGlobalOffset(prog, #x);
#define PRVM_DECLARE_function(x) prog->funcoffsets.x = PRVM_ED_FindFunctionOffset(prog, #x);
#include "prvm_offsets.h"
#undef PRVM_DECLARE_serverglobalfloat
#undef PRVM_DECLARE_serverglobalvector
#undef PRVM_DECLARE_serverglobalstring
#undef PRVM_DECLARE_serverglobaledict
#undef PRVM_DECLARE_serverglobalfunction
#undef PRVM_DECLARE_clientglobalfloat
#undef PRVM_DECLARE_clientglobalvector
#undef PRVM_DECLARE_clientglobalstring
#undef PRVM_DECLARE_clientglobaledict
#undef PRVM_DECLARE_clientglobalfunction
#undef PRVM_DECLARE_menuglobalfloat
#undef PRVM_DECLARE_menuglobalvector
#undef PRVM_DECLARE_menuglobalstring
#undef PRVM_DECLARE_menuglobaledict
#undef PRVM_DECLARE_menuglobalfunction
#undef PRVM_DECLARE_serverfieldfloat
#undef PRVM_DECLARE_serverfieldvector
#undef PRVM_DECLARE_serverfieldstring
#undef PRVM_DECLARE_serverfieldedict
#undef PRVM_DECLARE_serverfieldfunction
#undef PRVM_DECLARE_clientfieldfloat
#undef PRVM_DECLARE_clientfieldvector
#undef PRVM_DECLARE_clientfieldstring
#undef PRVM_DECLARE_clientfieldedict
#undef PRVM_DECLARE_clientfieldfunction
#undef PRVM_DECLARE_menufieldfloat
#undef PRVM_DECLARE_menufieldvector
#undef PRVM_DECLARE_menufieldstring
#undef PRVM_DECLARE_menufieldedict
#undef PRVM_DECLARE_menufieldfunction
#undef PRVM_DECLARE_serverfunction
#undef PRVM_DECLARE_clientfunction
#undef PRVM_DECLARE_menufunction
#undef PRVM_DECLARE_field
#undef PRVM_DECLARE_global
#undef PRVM_DECLARE_function
}

References prvm_prog_t::fieldoffsets, prvm_prog_t::funcoffsets, and prvm_prog_t::globaloffsets.

Referenced by PRVM_Prog_Load().

PRVM_FreeString()

void PRVM_FreeString	(	prvm_prog_t *	prog,
		int	num )

Definition at line 3481 of file prvm_edict.c.

{
    if (num == 0)
        prog->error_cmd("PRVM_FreeString %s: attempt to free a NULL string", prog->name);
    else if (num >= 0 && num < prog->stringssize)
        prog->error_cmd("PRVM_FreeString %s: attempt to free a constant string", prog->name);
    else if (num >= PRVM_KNOWNSTRINGBASE && num < PRVM_KNOWNSTRINGBASE + prog->numknownstrings)
    {
        num = num - PRVM_KNOWNSTRINGBASE;
        if (!prog->knownstrings[num])
            prog->error_cmd("PRVM_FreeString %s: attempt to free a non-existent or already freed string", prog->name);
        if (!prog->knownstrings_flags[num])
            prog->error_cmd("PRVM_FreeString %s: attempt to free a string owned by the engine", prog->name);
        PRVM_Free((char *)prog->knownstrings[num]);
        if(prog->leaktest_active)
            if(prog->knownstrings_origin[num])
                PRVM_Free((char *)prog->knownstrings_origin[num]);
        prog->knownstrings[num] = NULL;
        prog->knownstrings_flags[num] = 0;
        prog->firstfreeknownstring = min(prog->firstfreeknownstring, num);
    }
    else
        prog->error_cmd("PRVM_FreeString %s: invalid string offset %i", prog->name, num);
}

References prvm_prog_t::error_cmd, prvm_prog_t::firstfreeknownstring, prvm_prog_t::knownstrings, prvm_prog_t::knownstrings_flags, prvm_prog_t::knownstrings_origin, prvm_prog_t::leaktest_active, min, prvm_prog_t::name, NULL, PRVM_Free, and PRVM_KNOWNSTRINGBASE.

Referenced by VM_strunzone().

PRVM_FriendlyProgFromString()

prvm_prog_t * PRVM_FriendlyProgFromString

(

const char *

str

)

for console commands (prints error if name unknown and returns NULL, prints error if prog not loaded and returns NULL)

Definition at line 184 of file prvm_edict.c.

{
    prvm_prog_t *prog = PRVM_ProgFromString(str);
    if (!prog)
    {
        Con_Printf("%s: unknown program name\n", str);
        return NULL;
    }
    if (!prog->loaded)
    {
        Con_Printf("%s: program is not loaded\n", str);
        return NULL;
    }
    return prog;
}

References Con_Printf(), prvm_prog_t::loaded, NULL, and PRVM_ProgFromString().

Referenced by PRVM_Breakpoint_f(), PRVM_CallProfile_f(), PRVM_ChildProfile_f(), PRVM_ED_Count_f(), PRVM_ED_EdictGet_f(), PRVM_ED_EdictSet_f(), PRVM_ED_GlobalGet_f(), PRVM_ED_PrintEdict_f(), PRVM_ED_PrintEdicts_f(), PRVM_EdictWatchpoint_f(), PRVM_Fields_f(), PRVM_GameCommand(), PRVM_Global_f(), PRVM_Globals_f(), PRVM_GlobalSet_f(), PRVM_GlobalWatchpoint_f(), PRVM_PrintFunction_f(), and PRVM_Profile_f().

PRVM_GameCommand()

static void PRVM_GameCommand ( cmd_state_t * cmd, const char * whichprogs, const char * whichcmd )

static

Definition at line 1108 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    if(Cmd_Argc(cmd) < 1)
    {
        Con_Printf("%s text...\n", whichcmd);
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(whichprogs)))
        return;
 
    if(!PRVM_allfunction(GameCommand))
    {
        Con_Printf("%s program do not support GameCommand!\n", whichprogs);
    }
    else
    {
        int restorevm_tempstringsbuf_cursize;
        const char *s;
 
        s = Cmd_Args(cmd);
 
        restorevm_tempstringsbuf_cursize = prog->tempstringsbuf.cursize;
        PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(prog, s ? s : "", s ? strlen(s) : 0);
        prog->ExecuteProgram(prog, PRVM_allfunction(GameCommand), "QC function GameCommand is missing");
        prog->tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
    }
}

References cmd(), Cmd_Argc(), Cmd_Args(), Con_Printf(), sizebuf_t::cursize, prvm_prog_t::ExecuteProgram, OFS_PARM0, PRVM_allfunction, PRVM_FriendlyProgFromString(), PRVM_G_INT, PRVM_SetTempString(), strlen(), and prvm_prog_t::tempstringsbuf.

Referenced by PRVM_GameCommand_Client_f(), PRVM_GameCommand_Menu_f(), and PRVM_GameCommand_Server_f().

PRVM_GameCommand_Client_f()

static void PRVM_GameCommand_Client_f ( cmd_state_t * cmd )

static

Definition at line 1141 of file prvm_edict.c.

{
    PRVM_GameCommand(cmd, "client", "cl_cmd");
}

References cmd(), and PRVM_GameCommand().

Referenced by PRVM_Init().

PRVM_GameCommand_Menu_f()

static void PRVM_GameCommand_Menu_f ( cmd_state_t * cmd )

static

Definition at line 1145 of file prvm_edict.c.

{
    PRVM_GameCommand(cmd, "menu", "menu_cmd");
}

References cmd(), and PRVM_GameCommand().

Referenced by PRVM_Init().

PRVM_GameCommand_Server_f()

static void PRVM_GameCommand_Server_f ( cmd_state_t * cmd )

static

Definition at line 1137 of file prvm_edict.c.

{
    PRVM_GameCommand(cmd, "server", "sv_cmd");
}

References cmd(), and PRVM_GameCommand().

Referenced by PRVM_Init().

PRVM_GarbageCollection()

void PRVM_GarbageCollection

(

prvm_prog_t *

prog

)

Definition at line 3757 of file prvm_edict.c.

{
    int limit = prvm_garbagecollection_scan_limit.integer * (prog == SVVM_prog ? sv.frametime : cl.realframetime);
    prvm_prog_garbagecollection_state_t *gc = &prog->gc;
    if (!prvm_garbagecollection_enable.integer)
        return;
    // philosophy:
    // we like to limit how much scanning we do so it doesn't put a significant
    // burden on the cpu, so each of these are not complete scans, we also like
    // to have consistent cpu usage so we do a bit of work on each category of
    // leaked object every frame
    switch (gc->stage)
    {
    case PRVM_GC_START:
        gc->stage++;
        break;
    case PRVM_GC_GLOBALS_MARK:
        for (; gc->globals_mark_progress < prog->numglobaldefs && (limit--) > 0; gc->globals_mark_progress++)
        {
            mdef_t *d = &prog->globaldefs[gc->globals_mark_progress];
            switch (d->type)
            {
            case ev_string:
                {
                    prvm_int_t s = prog->globals.ip[d->ofs];
                    if (s & PRVM_KNOWNSTRINGBASE)
                    {
                        prvm_int_t num = s - PRVM_KNOWNSTRINGBASE;
                        if (!prog->knownstrings[num])
                        {
                            // invalid
                            Con_DPrintf("PRVM_GarbageCollection: Found bogus strzone reference in global %i (global name: \"%s\"), erasing reference", d->ofs, PRVM_GetString(prog, d->s_name));
                            prog->globals.ip[d->ofs] = 0;
                            continue;
                        }
                        prog->knownstrings_flags[num] = (prog->knownstrings_flags[num] | KNOWNSTRINGFLAG_GCMARK) & ~KNOWNSTRINGFLAG_GCPRUNE;
                    }
                }
                break;
            default:
                break;
            }
        }
        if (gc->globals_mark_progress >= prog->numglobaldefs)
            gc->stage++;
        break;
    case PRVM_GC_FIELDS_MARK:
        for (; gc->fields_mark_progress < prog->numfielddefs && limit > 0;)
        {
            mdef_t *d = &prog->fielddefs[gc->fields_mark_progress];
            switch (d->type)
            {
            case ev_string:
                //for (gc-> entityindex = 0; entityindex < prog->num_edicts; entityindex++)
                for (;gc->fields_mark_progress_entity < prog->num_edicts && (limit--) > 0;gc->fields_mark_progress_entity++)
                {
                    int entityindex = gc->fields_mark_progress_entity;
                    prvm_int_t s = prog->edictsfields.ip[entityindex * prog->entityfields + d->ofs];
                    if (s & PRVM_KNOWNSTRINGBASE)
                    {
                        prvm_int_t num = s - PRVM_KNOWNSTRINGBASE;
                        if (!prog->knownstrings[num])
                        {
                            // invalid
                            Con_DPrintf("PRVM_GarbageCollection: Found bogus strzone reference in edict %i field %i (field name: \"%s\"), erasing reference", entityindex, d->ofs, PRVM_GetString(prog, d->s_name));
                            prog->edictsfields.ip[entityindex * prog->entityfields + d->ofs] = 0;
                            continue;
                        }
                        prog->knownstrings_flags[num] = (prog->knownstrings_flags[num] | KNOWNSTRINGFLAG_GCMARK) & ~KNOWNSTRINGFLAG_GCPRUNE;
                    }
                }
                if (gc->fields_mark_progress_entity >= prog->num_edicts)
                {
                    gc->fields_mark_progress_entity = 0;
                    gc->fields_mark_progress++;
                }
                break;
            default:
                gc->fields_mark_progress_entity = 0;
                gc->fields_mark_progress++;
                break;
            }
        }
        if (gc->fields_mark_progress >= prog->numfielddefs)
            gc->stage++;
        break;
    case PRVM_GC_KNOWNSTRINGS_SWEEP:
        // free any strzone'd strings that are not marked
        if (!prvm_garbagecollection_strings.integer)
        {
            gc->stage++;
            break;
        }
        for (;gc->knownstrings_sweep_progress < prog->numknownstrings && (limit--) > 0;gc->knownstrings_sweep_progress++)
        {
            int num = gc->knownstrings_sweep_progress;
            if (prog->knownstrings[num] && (prog->knownstrings_flags[num] & (KNOWNSTRINGFLAG_GCMARK | KNOWNSTRINGFLAG_ENGINE)) == 0)
            {
                if (prog->knownstrings_flags[num] & KNOWNSTRINGFLAG_GCPRUNE)
                {
                    // string has been marked for pruning two passes in a row
                    if (prvm_garbagecollection_notify.integer)
                        Con_DPrintf("prvm_garbagecollection_notify: %s: freeing unreferenced string %i: \"%s\"\n", prog->name, num, prog->knownstrings[num]);
                    Mem_Free((char *)prog->knownstrings[num]);
                    prog->knownstrings[num] = NULL;
                    prog->knownstrings_flags[num] = 0;
                    prog->firstfreeknownstring = min(prog->firstfreeknownstring, num);
                }
                else
                {
                    // mark it for pruning next pass
                    prog->knownstrings_flags[num] |= KNOWNSTRINGFLAG_GCPRUNE;
                }
            }
        }
        if (gc->knownstrings_sweep_progress >= prog->numknownstrings)
            gc->stage++;
        break;
    case PRVM_GC_RESET:
    default:
        memset(gc, 0, sizeof(*gc));
//      Con_Printf("%s%s GC: reset @ %f frametime %f scan_limit per frame %i\n", prog == SVVM_prog ? "^6" : "^5", prog->name, host.realtime, prog == SVVM_prog ? sv.frametime : cl.realframetime, limit);
    }
}

References cl, Con_DPrintf(), prvm_prog_t::edictsfields, prvm_prog_t::entityfields, ev_string, prvm_prog_t::fielddefs, prvm_prog_garbagecollection_state_t::fields_mark_progress, prvm_prog_garbagecollection_state_t::fields_mark_progress_entity, prvm_prog_t::firstfreeknownstring, server_t::frametime, prvm_prog_t::gc, prvm_prog_t::globaldefs, prvm_prog_t::globals, prvm_prog_garbagecollection_state_t::globals_mark_progress, cvar_t::integer, prvm_prog_t::ip, KNOWNSTRINGFLAG_ENGINE, KNOWNSTRINGFLAG_GCMARK, KNOWNSTRINGFLAG_GCPRUNE, prvm_prog_t::knownstrings, prvm_prog_t::knownstrings_flags, prvm_prog_garbagecollection_state_t::knownstrings_sweep_progress, Mem_Free, min, prvm_prog_t::name, NULL, prvm_prog_t::num_edicts, prvm_prog_t::numfielddefs, prvm_prog_t::numglobaldefs, prvm_prog_t::numknownstrings, mdef_t::ofs, prvm_garbagecollection_enable, prvm_garbagecollection_notify, prvm_garbagecollection_scan_limit, prvm_garbagecollection_strings, PRVM_GC_FIELDS_MARK, PRVM_GC_GLOBALS_MARK, PRVM_GC_KNOWNSTRINGS_SWEEP, PRVM_GC_RESET, PRVM_GC_START, PRVM_GetString(), PRVM_KNOWNSTRINGBASE, client_state_t::realframetime, mdef_t::s_name, prvm_prog_garbagecollection_state_t::stage, sv, SVVM_prog, and mdef_t::type.

Referenced by CL_VM_DrawHud(), CL_VM_UpdateView(), MP_Draw(), and SV_Physics().

PRVM_GetString()

const char * PRVM_GetString	(	prvm_prog_t *	prog,
		int	num )

Definition at line 3283 of file prvm_edict.c.

{
    if (num < 0)
    {
        // invalid
        if (prvm_stringdebug.integer)
            VM_Warning(prog, "PRVM_GetString: Invalid string offset (%i < 0)\n", num);
        return "";
    }
    else if (num < prog->stringssize)
    {
        // constant string from progs.dat
        return prog->strings + num;
    }
    else if (num <= prog->stringssize + prog->tempstringsbuf.maxsize)
    {
        // tempstring returned by engine to QC (becomes invalid after returning to engine)
        num -= prog->stringssize;
        if (num < prog->tempstringsbuf.cursize)
            return (char *)prog->tempstringsbuf.data + num;
        else
        {
            if (prvm_stringdebug.integer)
                VM_Warning(prog, "PRVM_GetString: Invalid temp-string offset (%i >= %i prog->tempstringsbuf.cursize)\n", num, prog->tempstringsbuf.cursize);
            return "";
        }
    }
    else if (num & PRVM_KNOWNSTRINGBASE)
    {
        // allocated string
        num = num - PRVM_KNOWNSTRINGBASE;
        if (num >= 0 && num < prog->numknownstrings)
        {
            if (!prog->knownstrings[num])
            {
                if (prvm_stringdebug.integer)
                    VM_Warning(prog, "PRVM_GetString: Invalid zone-string offset (%i has been freed)\n", num);
                return "";
            }
            // refresh the garbage collection on the string - this guards
            // against a certain sort of repeated migration to earlier
            // points in the scan that could otherwise result in the string
            // being freed for being unused
            prog->knownstrings_flags[num] = (prog->knownstrings_flags[num] & ~KNOWNSTRINGFLAG_GCPRUNE) | KNOWNSTRINGFLAG_GCMARK;
            return prog->knownstrings[num];
        }
        else
        {
            if (prvm_stringdebug.integer)
                VM_Warning(prog, "PRVM_GetString: Invalid zone-string offset (%i >= %i)\n", num, prog->numknownstrings);
            return "";
        }
    }
    else
    {
        // invalid string offset
        if (prvm_stringdebug.integer)
            VM_Warning(prog, "PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize);
        return "";
    }
}

References sizebuf_t::cursize, sizebuf_t::data, cvar_t::integer, KNOWNSTRINGFLAG_GCMARK, prvm_prog_t::knownstrings, prvm_prog_t::knownstrings_flags, sizebuf_t::maxsize, prvm_prog_t::numknownstrings, PRVM_KNOWNSTRINGBASE, prvm_stringdebug, prvm_prog_t::strings, prvm_prog_t::stringssize, prvm_prog_t::tempstringsbuf, and VM_Warning().

Referenced by CLVM_ExecuteProgram(), FindViewthing(), NetConn_BuildStatusResponse(), PRVM_CallProfile(), PRVM_ED_CallSpawnFunction(), PRVM_ED_FindField(), PRVM_ED_FindFunction(), PRVM_ED_FindGlobal(), PRVM_ED_ParseEpair(), PRVM_ED_Print(), PRVM_ED_Write(), PRVM_ED_WriteGlobals(), PRVM_Fields_f(), PRVM_FunctionCoverageEvent(), PRVM_GarbageCollection(), PRVM_Globals_f(), PRVM_GlobalString(), PRVM_GlobalStringNoContents(), PRVM_IsEdictReferenced(), PRVM_IsEdictRelevant(), PRVM_MarkReferencedEdicts(), PRVM_PrintStatement(), PRVM_Profile(), PRVM_Prog_Load(), PRVM_ShortStackTrace(), PRVM_StackTrace(), PRVM_UglyValueString(), PRVM_ValueString(), PRVM_WhereAmI(), SV_CheckVelocity(), SV_Ent_Remove_All_f(), SV_Ent_Remove_f(), SV_PrepareEntityForSending(), SV_Savegame_to(), SV_SendServerinfo(), SV_SpawnServer(), SV_Status_f(), SV_UnstickEntity(), SV_UpdateToReliableMessages(), SV_WriteClientdataToMessage(), SVVM_ExecuteProgram(), VM_error(), VM_objerror(), VM_SV_droptofloor(), and while().

PRVM_Global_f()

static void PRVM_Global_f ( cmd_state_t * cmd )

static

Definition at line 2941 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    mdef_t *global;
    char valuebuf[MAX_INPUTLINE];
    if( Cmd_Argc(cmd) != 3 ) {
        Con_Printf( "prvm_global <program name> <global name>\n" );
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    global = PRVM_ED_FindGlobal( prog, Cmd_Argv(cmd, 2) );
    if( !global )
        Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(cmd, 2), Cmd_Argv(cmd, 1) );
    else
        Con_Printf( "%s: %s\n", Cmd_Argv(cmd, 2), PRVM_ValueString( prog, (etype_t)global->type, PRVM_GLOBALFIELDVALUE(global->ofs), valuebuf, sizeof(valuebuf) ) );
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), MAX_INPUTLINE, mdef_t::ofs, PRVM_ED_FindGlobal(), PRVM_FriendlyProgFromString(), PRVM_GLOBALFIELDVALUE, PRVM_ValueString(), and mdef_t::type.

Referenced by PRVM_Init().

PRVM_Globals_f()

static void PRVM_Globals_f ( cmd_state_t * cmd )

static

Definition at line 2894 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    int i;
    const char *wildcard;
    int numculled;
        numculled = 0;
    // TODO
    /*if (!sv.active)
    {
        Con_Print("no progs loaded\n");
        return;
    }*/
    if(Cmd_Argc (cmd) < 2 || Cmd_Argc(cmd) > 3)
    {
        Con_Print("prvm_globals <program name> <optional name wildcard>\n");
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    if( Cmd_Argc(cmd) == 3)
        wildcard = Cmd_Argv(cmd, 2);
    else
        wildcard = NULL;
 
    Con_Printf("%s :", prog->name);
 
    for (i = 0;i < prog->numglobaldefs;i++)
    {
        if(wildcard)
            if( !matchpattern( PRVM_GetString(prog, prog->globaldefs[i].s_name), wildcard, 1) )
            {
                numculled++;
                continue;
            }
        Con_Printf("%s\n", PRVM_GetString(prog, prog->globaldefs[i].s_name));
    }
    Con_Printf("%i global variables, %i culled, totalling %i bytes\n", prog->numglobals, numculled, prog->numglobals * 4);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), prvm_prog_t::globaldefs, i, matchpattern(), prvm_prog_t::name, NULL, prvm_prog_t::numglobaldefs, prvm_prog_t::numglobals, PRVM_FriendlyProgFromString(), PRVM_GetString(), and mdef_t::s_name.

Referenced by PRVM_Init().

PRVM_GlobalSet_f()

static void PRVM_GlobalSet_f ( cmd_state_t * cmd )

static

Definition at line 2966 of file prvm_edict.c.

{
    prvm_prog_t *prog;
    mdef_t *global;
    if( Cmd_Argc(cmd) != 4 ) {
        Con_Printf( "prvm_globalset <program name> <global name> <value>\n" );
        return;
    }
 
    if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    global = PRVM_ED_FindGlobal( prog, Cmd_Argv(cmd, 2) );
    if( !global )
        Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(cmd, 2), Cmd_Argv(cmd, 1) );
    else
        PRVM_ED_ParseEpair( prog, NULL, global, Cmd_Argv(cmd, 3), true );
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), NULL, PRVM_ED_FindGlobal(), PRVM_ED_ParseEpair(), and PRVM_FriendlyProgFromString().

Referenced by PRVM_Init().

PRVM_GlobalString()

char * PRVM_GlobalString	(	prvm_prog_t *	prog,
		int	ofs,
		char *	line,
		size_t	linelength )

Definition at line 602 of file prvm_edict.c.

{
    char    *s;
    //size_t    i;
    mdef_t  *def;
    prvm_eval_t *val;
    char valuebuf[MAX_INPUTLINE];
 
    val = (prvm_eval_t *)&prog->globals.fp[ofs];
    def = PRVM_ED_GlobalAtOfs(prog, ofs);
    if (!def)
        dpsnprintf (line, linelength, "GLOBAL%i", ofs);
    else
    {
        s = PRVM_ValueString (prog, (etype_t)def->type, val, valuebuf, sizeof(valuebuf));
        dpsnprintf (line, linelength, "%s (=%s)", PRVM_GetString(prog, def->s_name), s);
    }
 
    //i = strlen(line);
    //for ( ; i<20 ; i++)
    //  strcat (line," ");
    //strcat (line," ");
 
    return line;
}

References dpsnprintf(), prvm_prog_t::fp, prvm_prog_t::globals, MAX_INPUTLINE, ofs, PRVM_ED_GlobalAtOfs(), PRVM_GetString(), PRVM_ValueString(), mdef_t::s_name, and mdef_t::type.

Referenced by PRVM_PrintStatement().

PRVM_GlobalStringNoContents()

char * PRVM_GlobalStringNoContents	(	prvm_prog_t *	prog,
		int	ofs,
		char *	line,
		size_t	linelength )

Definition at line 628 of file prvm_edict.c.

{
    //size_t    i;
    mdef_t  *def;
 
    def = PRVM_ED_GlobalAtOfs(prog, ofs);
    if (!def)
        dpsnprintf (line, linelength, "GLOBAL%i", ofs);
    else
        dpsnprintf (line, linelength, "%s", PRVM_GetString(prog, def->s_name));
 
    //i = strlen(line);
    //for ( ; i<20 ; i++)
    //  strcat (line," ");
    //strcat (line," ");
 
    return line;
}

References dpsnprintf(), ofs, PRVM_ED_GlobalAtOfs(), PRVM_GetString(), and mdef_t::s_name.

PRVM_GlobalWatchpoint_f()

static void PRVM_GlobalWatchpoint_f ( cmd_state_t * cmd )

static

Definition at line 3134 of file prvm_edict.c.

{
    prvm_prog_t *prog;
 
    if( Cmd_Argc(cmd) == 2 ) {
        if (!(prog = PRVM_FriendlyProgFromString(Cmd_Argv(cmd, 1))))
            return;
        {
            debug_data_t *debug = &debug_data[prog - prvm_prog_list];
            debug->watch_global[0] = 0;
        }
        PRVM_UpdateBreakpoints(prog);
        return;
    }
    if( Cmd_Argc(cmd) != 3 ) {
        Con_Printf( "prvm_globalwatchpoint <program name> <global name>\n" );
        return;
    }
 
    if (!(prog = PRVM_ProgFromString(Cmd_Argv(cmd, 1))))
        return;
 
    {
        debug_data_t *debug = &debug_data[prog - prvm_prog_list];
        dp_strlcpy(debug->watch_global, Cmd_Argv(cmd, 2), sizeof(debug->watch_global));
    }
    PRVM_UpdateBreakpoints(prog);
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), debug_data, dp_strlcpy, PRVM_FriendlyProgFromString(), prvm_prog_list, PRVM_ProgFromString(), PRVM_UpdateBreakpoints(), and debug_data_t::watch_global.

Referenced by PRVM_Init().

PRVM_Init()

void PRVM_Init

(

void

)

Definition at line 3198 of file prvm_edict.c.

{
    unsigned int i;
 
    Cmd_AddCommand(CF_SHARED, "prvm_edict", PRVM_ED_PrintEdict_f, "print all data about an entity number in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_edicts", PRVM_ED_PrintEdicts_f, "prints all data about all entities in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_childprofile", PRVM_ChildProfile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu), sorted by time taken in function with child calls");
    Cmd_AddCommand(CF_SHARED, "prvm_callprofile", PRVM_CallProfile_f, "prints execution statistics about the most time consuming QuakeC calls from the engine in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_fields", PRVM_Fields_f, "prints usage statistics on properties (how many entities have non-zero values) in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_edictset", PRVM_ED_EdictSet_f, "changes value of a specified property of a specified entity in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "prvm_edictget", PRVM_ED_EdictGet_f, "retrieves the value of a specified property of a specified entity in the selected VM (server, client menu) into a cvar or to the console");
    Cmd_AddCommand(CF_SHARED, "prvm_globalget", PRVM_ED_GlobalGet_f, "retrieves the value of a specified global variable in the selected VM (server, client menu) into a cvar or to the console");
    Cmd_AddCommand(CF_SHARED, "prvm_printfunction", PRVM_PrintFunction_f, "prints a disassembly (QuakeC instructions) of the specified function in the selected VM (server, client, menu)");
    Cmd_AddCommand(CF_SHARED, "cl_cmd", PRVM_GameCommand_Client_f, "calls the client QC function GameCommand with the supplied string as argument");
    Cmd_AddCommand(CF_SHARED, "menu_cmd", PRVM_GameCommand_Menu_f, "calls the menu QC function GameCommand with the supplied string as argument");
    Cmd_AddCommand(CF_SHARED, "sv_cmd", PRVM_GameCommand_Server_f, "calls the server QC function GameCommand with the supplied string as argument");
    Cmd_AddCommand(CF_SHARED, "prvm_breakpoint", PRVM_Breakpoint_f, "marks a statement or function as breakpoint (when this is executed, a stack trace is printed); to actually halt and investigate state, combine this with a gdb breakpoint on PRVM_Breakpoint, or with prvm_breakpointdump; run with just progs name to clear breakpoint");
    Cmd_AddCommand(CF_SHARED, "prvm_globalwatchpoint", PRVM_GlobalWatchpoint_f, "marks a global as watchpoint (when this is executed, a stack trace is printed); to actually halt and investigate state, combine this with a gdb breakpoint on PRVM_Breakpoint, or with prvm_breakpointdump; run with just progs name to clear watchpoint");
    Cmd_AddCommand(CF_SHARED, "prvm_edictwatchpoint", PRVM_EdictWatchpoint_f, "marks an entity field as watchpoint (when this is executed, a stack trace is printed); to actually halt and investigate state, combine this with a gdb breakpoint on PRVM_Breakpoint, or with prvm_breakpointdump; run with just progs name to clear watchpoint");
 
    Cvar_RegisterVariable (&prvm_language);
    Cvar_RegisterVariable (&prvm_traceqc);
    Cvar_RegisterVariable (&prvm_statementprofiling);
    Cvar_RegisterVariable (&prvm_timeprofiling);
    Cvar_RegisterVariable (&prvm_coverage);
    Cvar_RegisterVariable (&prvm_backtraceforwarnings);
    Cvar_RegisterVariable (&prvm_leaktest);
    Cvar_RegisterVariable (&prvm_leaktest_follow_targetname);
    Cvar_RegisterVariable (&prvm_leaktest_ignore_classnames);
    Cvar_RegisterVariable (&prvm_errordump);
    Cvar_RegisterVariable (&prvm_breakpointdump);
    Cvar_RegisterVariable (&prvm_reuseedicts_startuptime);
    Cvar_RegisterVariable (&prvm_reuseedicts_neverinsameframe);
    Cvar_RegisterVariable (&prvm_garbagecollection_enable);
    Cvar_RegisterVariable (&prvm_garbagecollection_notify);
    Cvar_RegisterVariable (&prvm_garbagecollection_scan_limit);
    Cvar_RegisterVariable (&prvm_garbagecollection_strings);
    Cvar_RegisterVariable (&prvm_stringdebug);
    Cvar_RegisterVariable (&sv_entfields_noescapes);
    Cvar_RegisterVariable (&prvm_gameplayfix_div0is0);
 
    // COMMANDLINEOPTION: PRVM: -norunaway disables the runaway loop check (it might be impossible to exit DarkPlaces if used!)
    prvm_runawaycheck = !Sys_CheckParm("-norunaway");
 
    //VM_Cmd_Init();
 
    // LadyHavoc: report supported extensions
    Con_DPrintf("\nQuakeC extensions for server and client:");
    for (i = 0; vm_sv_extensions[i]; i++)
        Con_DPrintf(" %s", vm_sv_extensions[i]);
    Con_DPrintf("\n");
#ifdef CONFIG_MENU
    Con_DPrintf("\nQuakeC extensions for menu:");
    for (i = 0; vm_m_extensions[i]; i++)
        Con_DPrintf(" %s", vm_m_extensions[i]);
    Con_DPrintf("\n");
#endif
}

References CF_SHARED, Cmd_AddCommand(), Con_DPrintf(), Cvar_RegisterVariable(), i, prvm_backtraceforwarnings, PRVM_Breakpoint_f(), prvm_breakpointdump, PRVM_CallProfile_f(), PRVM_ChildProfile_f(), prvm_coverage, PRVM_ED_Count_f(), PRVM_ED_EdictGet_f(), PRVM_ED_EdictSet_f(), PRVM_ED_GlobalGet_f(), PRVM_ED_PrintEdict_f(), PRVM_ED_PrintEdicts_f(), PRVM_EdictWatchpoint_f(), prvm_errordump, PRVM_Fields_f(), PRVM_GameCommand_Client_f(), PRVM_GameCommand_Menu_f(), PRVM_GameCommand_Server_f(), prvm_gameplayfix_div0is0, prvm_garbagecollection_enable, prvm_garbagecollection_notify, prvm_garbagecollection_scan_limit, prvm_garbagecollection_strings, PRVM_Global_f(), PRVM_Globals_f(), PRVM_GlobalSet_f(), PRVM_GlobalWatchpoint_f(), prvm_language, prvm_leaktest, prvm_leaktest_follow_targetname, prvm_leaktest_ignore_classnames, PRVM_PrintFunction_f(), PRVM_Profile_f(), prvm_reuseedicts_neverinsameframe, prvm_reuseedicts_startuptime, prvm_runawaycheck, prvm_statementprofiling, prvm_stringdebug, prvm_timeprofiling, prvm_traceqc, sv_entfields_noescapes, Sys_CheckParm(), vm_m_extensions, and vm_sv_extensions.

Referenced by Host_Init().

PRVM_IsEdictReferenced()

static qbool PRVM_IsEdictReferenced ( prvm_prog_t * prog, prvm_edict_t * edict, int mark )

static

Definition at line 3589 of file prvm_edict.c.

{
    int i, j;
    int edictnum = PRVM_NUM_FOR_EDICT(edict);
    const char *targetname = NULL;
 
    if (prog == SVVM_prog && prvm_leaktest_follow_targetname.integer)
        targetname = PRVM_GetString(prog, PRVM_serveredictstring(edict, targetname));
 
    if(targetname)
        if(!*targetname) // ""
            targetname = NULL;
 
    for(j = 0; j < prog->num_edicts; ++j)
    {
        prvm_edict_t *ed = PRVM_EDICT_NUM(j);
        if (ed->priv.required->mark < mark)
            continue;
        if(ed == edict)
            continue;
        if(targetname)
        {
            const char *target = PRVM_GetString(prog, PRVM_serveredictstring(ed, target));
            if(target)
                if(!strcmp(target, targetname))
                    return true;
        }
        for (i=0; i<prog->numfielddefs; ++i)
        {
            mdef_t *d = &prog->fielddefs[i];
            if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
                continue;
            if(edictnum == PRVM_EDICTFIELDEDICT(ed, d->ofs))
                return true;
        }
    }
 
    return false;
}

References DEF_SAVEGLOBAL, ev_entity, prvm_prog_t::fielddefs, i, cvar_t::integer, prvm_edict_private_t::mark, NULL, prvm_prog_t::num_edicts, prvm_prog_t::numfielddefs, mdef_t::ofs, prvm_edict_t::priv, PRVM_EDICT_NUM, PRVM_EDICTFIELDEDICT, PRVM_GetString(), prvm_leaktest_follow_targetname, PRVM_NUM_FOR_EDICT, PRVM_serveredictstring, prvm_edict_t::required, SVVM_prog, target, targetname, and mdef_t::type.

Referenced by PRVM_MarkReferencedEdicts().

PRVM_IsEdictRelevant()

static qbool PRVM_IsEdictRelevant ( prvm_prog_t * prog, prvm_edict_t * edict )

static

Definition at line 3537 of file prvm_edict.c.

{
    char vabuf[1024];
    char vabuf2[1024];
    if(PRVM_NUM_FOR_EDICT(edict) <= prog->reserved_edicts)
        return true; // world or clients
    if (edict->freetime <= prog->inittime)
        return true; // created during startup
    if (prog == SVVM_prog)
    {
        if(PRVM_serveredictfloat(edict, solid)) // can block other stuff, or is a trigger?
            return true;
        if(PRVM_serveredictfloat(edict, modelindex)) // visible ent?
            return true;
        if(PRVM_serveredictfloat(edict, effects)) // particle effect?
            return true;
        if(PRVM_serveredictfunction(edict, think)) // has a think function?
            if(PRVM_serveredictfloat(edict, nextthink) > 0) // that actually will eventually run?
                return true;
        if(PRVM_serveredictfloat(edict, takedamage))
            return true;
        if(*prvm_leaktest_ignore_classnames.string)
        {
            if(strstr(va(vabuf, sizeof(vabuf), " %s ", prvm_leaktest_ignore_classnames.string), va(vabuf2, sizeof(vabuf2), " %s ", PRVM_GetString(prog, PRVM_serveredictstring(edict, classname)))))
                return true;
        }
    }
    else if (prog == CLVM_prog)
    {
        // TODO someone add more stuff here
        if(PRVM_clientedictfloat(edict, entnum)) // csqc networked
            return true;
        if(PRVM_clientedictfloat(edict, modelindex)) // visible ent?
            return true;
        if(PRVM_clientedictfloat(edict, effects)) // particle effect?
            return true;
        if(PRVM_clientedictfunction(edict, think)) // has a think function?
            if(PRVM_clientedictfloat(edict, nextthink) > 0) // that actually will eventually run?
                return true;
        if(*prvm_leaktest_ignore_classnames.string)
        {
            if(strstr(va(vabuf, sizeof(vabuf), " %s ", prvm_leaktest_ignore_classnames.string), va(vabuf2, sizeof(vabuf2), " %s ", PRVM_GetString(prog, PRVM_clientedictstring(edict, classname)))))
                return true;
        }
    }
    else
    {
        // menu prog does not have classnames
    }
    return false;
}

References classname, CLVM_prog, effects, entnum, prvm_edict_t::freetime, prvm_prog_t::inittime, modelindex, nextthink, PRVM_clientedictfloat, PRVM_clientedictfunction, PRVM_clientedictstring, PRVM_GetString(), prvm_leaktest_ignore_classnames, PRVM_NUM_FOR_EDICT, PRVM_serveredictfloat, PRVM_serveredictfunction, PRVM_serveredictstring, prvm_prog_t::reserved_edicts, solid, cvar_t::string, SVVM_prog, takedamage, and va().

Referenced by PRVM_MarkReferencedEdicts().

PRVM_IsStringReferenced()

static qbool PRVM_IsStringReferenced ( prvm_prog_t * prog, string_t string )

static

Definition at line 3506 of file prvm_edict.c.

{
    int i, j;
 
    for (i = 0;i < prog->numglobaldefs;i++)
    {
        mdef_t *d = &prog->globaldefs[i];
        if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string)
            continue;
        if(string == PRVM_GLOBALFIELDSTRING(d->ofs))
            return true;
    }
 
    for(j = 0; j < prog->num_edicts; ++j)
    {
        prvm_edict_t *ed = PRVM_EDICT_NUM(j);
        if (ed->free)
            continue;
        for (i=0; i<prog->numfielddefs; ++i)
        {
            mdef_t *d = &prog->fielddefs[i];
            if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string)
                continue;
            if(string == PRVM_EDICTFIELDSTRING(ed, d->ofs))
                return true;
        }
    }
 
    return false;
}

References DEF_SAVEGLOBAL, ev_string, prvm_prog_t::fielddefs, prvm_edict_t::free, prvm_prog_t::globaldefs, i, prvm_prog_t::num_edicts, prvm_prog_t::numfielddefs, prvm_prog_t::numglobaldefs, mdef_t::ofs, PRVM_EDICT_NUM, PRVM_EDICTFIELDSTRING, PRVM_GLOBALFIELDSTRING, and mdef_t::type.

Referenced by PRVM_LeakTest().

PRVM_LeakTest()

void PRVM_LeakTest

(

prvm_prog_t *

prog

)

Definition at line 3682 of file prvm_edict.c.

{
    int i, j;
    qbool leaked = false;
 
    if(!prog->leaktest_active)
        return;
 
    // 1. Strings
    for (i = 0; i < prog->numknownstrings; ++i)
    {
        if(prog->knownstrings[i])
        if(prog->knownstrings_flags[i])
        if(prog->knownstrings_origin[i])
        if(!PRVM_IsStringReferenced(prog, PRVM_KNOWNSTRINGBASE + i))
        {
            Con_Printf("Unreferenced string found!\n  Value: %s\n  Origin: %s\n", prog->knownstrings[i], prog->knownstrings_origin[i]);
            leaked = true;
        }
    }
 
    // 2. Edicts
    PRVM_MarkReferencedEdicts(prog);
    for(j = 0; j < prog->num_edicts; ++j)
    {
        prvm_edict_t *ed = PRVM_EDICT_NUM(j);
        if(ed->free)
            continue;
        if(!ed->priv.required->mark)
        if(ed->priv.required->allocation_origin)
        {
            Con_Printf("Unreferenced edict found!\n  Allocated at: %s\n", ed->priv.required->allocation_origin);
            PRVM_ED_Print(prog, ed, NULL);
            Con_Print("\n");
            leaked = true;
        }
 
        ed->priv.required->mark = 0; // clear marks again when done
    }
 
    for (i = 0; i < (int)Mem_ExpandableArray_IndexRange(&prog->stringbuffersarray); ++i)
    {
        prvm_stringbuffer_t *stringbuffer = (prvm_stringbuffer_t*) Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);
        if(stringbuffer)
        if(stringbuffer->origin)
        {
            Con_Printf("Open string buffer handle found!\n  Allocated at: %s\n", stringbuffer->origin);
            leaked = true;
        }
    }
 
    for(i = 0; i < PRVM_MAX_OPENFILES; ++i)
    {
        if(prog->openfiles[i])
        if(prog->openfiles_origin[i])
        {
            Con_Printf("Open file handle found!\n  Allocated at: %s\n", prog->openfiles_origin[i]);
            leaked = true;
        }
    }
 
    for(i = 0; i < PRVM_MAX_OPENSEARCHES; ++i)
    {
        if(prog->opensearches[i])
        if(prog->opensearches_origin[i])
        {
            Con_Printf("Open search handle found!\n  Allocated at: %s\n", prog->opensearches_origin[i]);
            leaked = true;
        }
    }
 
    if(!leaked)
        Con_Printf("Congratulations. No leaks found.\n");
}

References prvm_edict_private_t::allocation_origin, Con_Print(), Con_Printf(), prvm_edict_t::free, i, int(), prvm_prog_t::knownstrings, prvm_prog_t::knownstrings_flags, prvm_prog_t::knownstrings_origin, prvm_prog_t::leaktest_active, prvm_edict_private_t::mark, Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), NULL, prvm_prog_t::num_edicts, prvm_prog_t::numknownstrings, prvm_prog_t::openfiles, prvm_prog_t::openfiles_origin, prvm_prog_t::opensearches, prvm_prog_t::opensearches_origin, prvm_stringbuffer_t::origin, prvm_edict_t::priv, PRVM_ED_Print(), PRVM_EDICT_NUM, PRVM_IsStringReferenced(), PRVM_KNOWNSTRINGBASE, PRVM_MarkReferencedEdicts(), PRVM_MAX_OPENFILES, PRVM_MAX_OPENSEARCHES, prvm_edict_t::required, and prvm_prog_t::stringbuffersarray.

Referenced by PRVM_Prog_Reset().

PRVM_LoadLNO()

static void PRVM_LoadLNO ( prvm_prog_t * prog, const char * progname )

static

Definition at line 1968 of file prvm_edict.c.

                                                                    {
    fs_offset_t filesize;
    unsigned char *lno;
    unsigned int *header;
    char filename[512];
 
    FS_StripExtension( progname, filename, sizeof( filename ) );
    dp_strlcat( filename, ".lno", sizeof( filename ) );
 
    lno = FS_LoadFile( filename, tempmempool, false, &filesize );
    if( !lno ) {
        return;
    }
 
/*
<Spike>    SafeWrite (h, &lnotype, sizeof(int));
<Spike>    SafeWrite (h, &version, sizeof(int));
<Spike>    SafeWrite (h, &numglobaldefs, sizeof(int));
<Spike>    SafeWrite (h, &numpr_globals, sizeof(int));
<Spike>    SafeWrite (h, &numfielddefs, sizeof(int));
<Spike>    SafeWrite (h, &numstatements, sizeof(int));
<Spike>    SafeWrite (h, statement_linenums, numstatements*sizeof(int));
*/
    if ((unsigned int)filesize < (6 + prog->progs_numstatements) * sizeof(int))
    {
        Mem_Free(lno);
        return;
    }
 
    header = (unsigned int *) lno;
    if (memcmp(lno, "LNOF", 4) == 0
    && LittleLong( header[ 1 ] ) == 1
    && (unsigned int)LittleLong( header[ 2 ] ) == (unsigned int)prog->progs_numglobaldefs
    && (unsigned int)LittleLong( header[ 3 ] ) == (unsigned int)prog->progs_numglobals
    && (unsigned int)LittleLong( header[ 4 ] ) == (unsigned int)prog->progs_numfielddefs
    && (unsigned int)LittleLong( header[ 5 ] ) == (unsigned int)prog->progs_numstatements)
    {
        prog->statement_linenums = (int *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof( int ) );
        memcpy( prog->statement_linenums, header + 6, prog->progs_numstatements * sizeof( int ) );
 
        /* gmqcc suports columnums */
        if ((unsigned int)filesize > ((6 + 2 * prog->progs_numstatements) * sizeof( int )))
        {
            prog->statement_columnnums = (int *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof( int ) );
            memcpy( prog->statement_columnnums, header + 6 + prog->progs_numstatements, prog->progs_numstatements * sizeof( int ) );
        }
    }
    Mem_Free( lno );
}

References dp_strlcat, FS_LoadFile(), FS_StripExtension(), LittleLong, Mem_Alloc, Mem_Free, prvm_prog_t::progs_mempool, prvm_prog_t::progs_numfielddefs, prvm_prog_t::progs_numglobaldefs, prvm_prog_t::progs_numglobals, prvm_prog_t::progs_numstatements, prvm_prog_t::statement_columnnums, prvm_prog_t::statement_linenums, and tempmempool.

Referenced by PRVM_Prog_Load().

PRVM_MarkReferencedEdicts()

static void PRVM_MarkReferencedEdicts ( prvm_prog_t * prog )

static

Definition at line 3629 of file prvm_edict.c.

{
    int i, j;
    qbool found_new;
    int stage;
 
    // Stage 1: world, all entities that are relevant, and all entities that are referenced by globals.
    stage = 1;
    for(j = 0; j < prog->num_edicts; ++j)
    {
        prvm_edict_t *ed = PRVM_EDICT_NUM(j);
        if(ed->free)
            continue;
        ed->priv.required->mark = PRVM_IsEdictRelevant(prog, ed) ? stage : 0;
    }
    for (i = 0;i < prog->numglobaldefs;i++)
    {
        mdef_t *d = &prog->globaldefs[i];
        prvm_edict_t *ed;
        if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
            continue;
        j = PRVM_GLOBALFIELDEDICT(d->ofs);
        if (i < 0 || j >= prog->max_edicts) {
            Con_Printf("Invalid entity reference from global %s.\n", PRVM_GetString(prog, d->s_name));
            continue;
        }
        ed = PRVM_EDICT_NUM(j);;
        ed->priv.required->mark = stage;
    }
 
    // Future stages: all entities that are referenced by an entity of the previous stage.
    do
    {
        found_new = false;
        for(j = 0; j < prog->num_edicts; ++j)
        {
            prvm_edict_t *ed = PRVM_EDICT_NUM(j);
            if(ed->free)
                continue;
            if(ed->priv.required->mark)
                continue;
            if(PRVM_IsEdictReferenced(prog, ed, stage))
            {
                ed->priv.required->mark = stage + 1;
                found_new = true;
            }
        }
        ++stage;
    }
    while(found_new);
    Con_DPrintf("leak check used %d stages to find all references\n", stage);
}

References Con_DPrintf(), Con_Printf(), DEF_SAVEGLOBAL, ev_entity, prvm_edict_t::free, prvm_prog_t::globaldefs, i, prvm_edict_private_t::mark, prvm_prog_t::max_edicts, prvm_prog_t::num_edicts, prvm_prog_t::numglobaldefs, mdef_t::ofs, prvm_edict_t::priv, PRVM_EDICT_NUM, PRVM_GetString(), PRVM_GLOBALFIELDEDICT, PRVM_IsEdictReferenced(), PRVM_IsEdictRelevant(), prvm_edict_t::required, mdef_t::s_name, and mdef_t::type.

Referenced by PRVM_LeakTest().

PRVM_MEM_Alloc()

static void PRVM_MEM_Alloc ( prvm_prog_t * prog )

static

Definition at line 70 of file prvm_edict.c.

{
    int i;
 
    // reserve space for the null entity aka world
    // check bound of max_edicts
    prog->max_edicts = bound(1 + prog->reserved_edicts, prog->max_edicts, prog->limit_edicts);
    prog->num_edicts = bound(1 + prog->reserved_edicts, prog->num_edicts, prog->max_edicts);
 
    // edictprivate_size has to be min as big prvm_edict_private_t
    prog->edictprivate_size = max(prog->edictprivate_size,(int)sizeof(prvm_edict_private_t));
 
    // alloc edicts
    prog->edicts = (prvm_edict_t *)Mem_Alloc(prog->progs_mempool,prog->limit_edicts * sizeof(prvm_edict_t));
 
    // alloc edict private space
    prog->edictprivate = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edictprivate_size);
 
    // alloc edict fields
    prog->entityfieldsarea = prog->entityfields * prog->max_edicts;
    prog->edictsfields.fp = (prvm_vec_t *)Mem_Alloc(prog->progs_mempool, prog->entityfieldsarea * sizeof(prvm_vec_t));
 
    // set edict pointers
    for(i = 0; i < prog->max_edicts; i++)
    {
        prog->edicts[i].priv.required = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
        prog->edicts[i].fields.fp = prog->edictsfields.fp + i * prog->entityfields;
    }
}

References bound, prvm_prog_t::edictprivate, prvm_prog_t::edictprivate_size, prvm_prog_t::edicts, prvm_prog_t::edictsfields, prvm_prog_t::entityfields, prvm_prog_t::entityfieldsarea, prvm_edict_t::fields, prvm_edict_t::fp, prvm_prog_t::fp, i, prvm_prog_t::limit_edicts, max, prvm_prog_t::max_edicts, Mem_Alloc, prvm_prog_t::num_edicts, prvm_edict_t::priv, prvm_prog_t::progs_mempool, prvm_edict_t::required, and prvm_prog_t::reserved_edicts.

Referenced by PRVM_Prog_Load().

PRVM_MEM_IncreaseEdicts()

void PRVM_MEM_IncreaseEdicts

(

prvm_prog_t *

prog

)

Definition at line 105 of file prvm_edict.c.

{
    int     i;
 
    if(prog->max_edicts >= prog->limit_edicts)
        return;
 
    prog->begin_increase_edicts(prog);
 
    // increase edicts
    prog->max_edicts = min(prog->max_edicts + 256, prog->limit_edicts);
 
    prog->entityfieldsarea = prog->entityfields * prog->max_edicts;
    prog->edictsfields.fp = (prvm_vec_t*)Mem_Realloc(prog->progs_mempool, (void *)prog->edictsfields.fp, prog->entityfieldsarea * sizeof(prvm_vec_t));
    prog->edictprivate = (void *)Mem_Realloc(prog->progs_mempool, (void *)prog->edictprivate, prog->max_edicts * prog->edictprivate_size);
 
    //set e and v pointers
    for(i = 0; i < prog->max_edicts; i++)
    {
        prog->edicts[i].priv.required  = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
        prog->edicts[i].fields.fp = prog->edictsfields.fp + i * prog->entityfields;
    }
 
    prog->end_increase_edicts(prog);
}

References prvm_prog_t::begin_increase_edicts, prvm_prog_t::edictprivate, prvm_prog_t::edictprivate_size, prvm_prog_t::edicts, prvm_prog_t::edictsfields, prvm_prog_t::end_increase_edicts, prvm_prog_t::entityfields, prvm_prog_t::entityfieldsarea, prvm_edict_t::fields, prvm_edict_t::fp, prvm_prog_t::fp, i, prvm_prog_t::limit_edicts, prvm_prog_t::max_edicts, Mem_Realloc, min, prvm_edict_t::priv, prvm_prog_t::progs_mempool, and prvm_edict_t::required.

Referenced by PRVM_ED_Alloc(), PRVM_ED_ParseEpair(), and SV_Loadgame_f().

PRVM_NewKnownString()

static void PRVM_NewKnownString ( prvm_prog_t * prog, int i, int flags, const char * s )

static

Definition at line 3358 of file prvm_edict.c.

{
    if (i >= prog->numknownstrings)
    {
        if (i >= prog->maxknownstrings)
        {
            const char **oldstrings = prog->knownstrings;
            const unsigned char *oldstrings_flags = prog->knownstrings_flags;
            const char **oldstrings_origin = prog->knownstrings_origin;
            prog->maxknownstrings += 128;
            prog->knownstrings = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
            prog->knownstrings_flags = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char));
            if (prog->leaktest_active)
                prog->knownstrings_origin = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
            if (prog->numknownstrings)
            {
                memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
                memcpy((char **)prog->knownstrings_flags, oldstrings_flags, prog->numknownstrings * sizeof(unsigned char));
                if (prog->leaktest_active)
                    memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *));
            }
        }
        prog->numknownstrings++;
    }
    prog->firstfreeknownstring = i + 1;
    prog->knownstrings[i] = s;
    // it's in use right now, spare it until the next gc pass - that said, it is not freeable so this is probably moot
    prog->knownstrings_flags[i] = flags;
    if (prog->leaktest_active)
        prog->knownstrings_origin[i] = NULL;
}

References prvm_prog_t::firstfreeknownstring, flags, i, prvm_prog_t::knownstrings, prvm_prog_t::knownstrings_flags, prvm_prog_t::knownstrings_origin, prvm_prog_t::leaktest_active, prvm_prog_t::maxknownstrings, NULL, prvm_prog_t::numknownstrings, and PRVM_Alloc.

Referenced by PRVM_AllocString(), and PRVM_SetEngineString().

PRVM_PO_Destroy()

static void PRVM_PO_Destroy ( po_t * po )

static

Definition at line 1925 of file prvm_edict.c.

{
    int i;
    for(i = 0; i < PO_HASHSIZE; ++i)
    {
        po_string_t *p = po->hashtable[i];
        while(p)
        {
            po_string_t *q = p;
            p = p->nextonhashchain;
            Mem_Free(q->key);
            Mem_Free(q->value);
            Mem_Free(q);
        }
    }
    Mem_Free(po);
}

References po_t::hashtable, i, po_string_t::key, Mem_Free, po_string_t::nextonhashchain, PO_HASHSIZE, and po_string_t::value.

Referenced by PRVM_Prog_Reset().

PRVM_PO_Load()

static po_t * PRVM_PO_Load ( const char * filename, const char * filename2, mempool_t * pool )

static

Definition at line 1800 of file prvm_edict.c.

{
    po_t *po = NULL;
    const char *p, *q;
    int mode;
    char inbuf[MAX_INPUTLINE];
    char decodedbuf[MAX_INPUTLINE];
    size_t decodedpos;
    int hashindex;
    po_string_t thisstr;
    int i;
 
    for (i = 0; i < 2; ++i)
    {
        const char *buf = (const char *)
            FS_LoadFile((i > 0 ? filename : filename2), pool, true, NULL);
        // first read filename2, then read filename
        // so that progs.dat.de.po wins over common.de.po
        // and within file, last item wins
 
        if(!buf)
            continue;
 
        if (!po)
        {
            po = (po_t *)Mem_Alloc(pool, sizeof(*po));
            memset(po, 0, sizeof(*po));
        }
 
        memset(&thisstr, 0, sizeof(thisstr)); // hush compiler warning
 
        p = buf;
        while(*p)
        {
            if(*p == '#')
            {
                // skip to newline
                p = strchr(p, '\n');
                if(!p)
                    break;
                ++p;
                continue;
            }
            if(*p == '\r' || *p == '\n')
            {
                ++p;
                continue;
            }
            if(!strncmp(p, "msgid \"", 7))
            {
                mode = 0;
                p += 6;
            }
            else if(!strncmp(p, "msgstr \"", 8))
            {
                mode = 1;
                p += 7;
            }
            else
            {
                p = strchr(p, '\n');
                if(!p)
                    break;
                ++p;
                continue;
            }
            decodedpos = 0;
            while(*p == '"')
            {
                ++p;
                q = strchr(p, '\n');
                if(!q)
                    break;
                if(*(q-1) == '\r')
                    --q;
                if(*(q-1) != '"')
                    break;
                if((size_t)(q - p) >= (size_t) sizeof(inbuf))
                    break;
                memcpy(inbuf, p, q - p - 1);
                inbuf[q - p - 1] = '\0';
                PRVM_PO_ParseString(decodedbuf + decodedpos, inbuf, sizeof(decodedbuf) - decodedpos);
                decodedpos += strlen(decodedbuf + decodedpos);
                if(*q == '\r')
                    ++q;
                if(*q == '\n')
                    ++q;
                p = q;
            }
            if(mode == 0)
            {
                if(thisstr.key)
                    Mem_Free(thisstr.key);
                thisstr.key = (char *)Mem_Alloc(pool, decodedpos + 1);
                memcpy(thisstr.key, decodedbuf, decodedpos + 1);
            }
            else if(decodedpos > 0 && thisstr.key) // skip empty translation results
            {
                thisstr.value = (char *)Mem_Alloc(pool, decodedpos + 1);
                memcpy(thisstr.value, decodedbuf, decodedpos + 1);
                hashindex = CRC_Block((const unsigned char *) thisstr.key, strlen(thisstr.key)) % PO_HASHSIZE;
                thisstr.nextonhashchain = po->hashtable[hashindex];
                po->hashtable[hashindex] = (po_string_t *)Mem_Alloc(pool, sizeof(thisstr));
                memcpy(po->hashtable[hashindex], &thisstr, sizeof(thisstr));
                memset(&thisstr, 0, sizeof(thisstr));
            }
        }
 
        Mem_Free((char *) buf);
    }
 
    return po;
}

References buf, CRC_Block(), FS_LoadFile(), po_t::hashtable, i, po_string_t::key, MAX_INPUTLINE, Mem_Alloc, Mem_Free, mode, po_string_t::nextonhashchain, NULL, PO_HASHSIZE, PRVM_PO_ParseString(), strlen(), and po_string_t::value.

Referenced by PRVM_Prog_Load().

PRVM_PO_Lookup()

static const char * PRVM_PO_Lookup ( po_t * po, const char * str )

static

Definition at line 1913 of file prvm_edict.c.

{
    int hashindex = CRC_Block((const unsigned char *) str, strlen(str)) % PO_HASHSIZE;
    po_string_t *p = po->hashtable[hashindex];
    while(p)
    {
        if(!strcmp(str, p->key))
            return p->value;
        p = p->nextonhashchain;
    }
    return NULL;
}

References CRC_Block(), po_t::hashtable, po_string_t::key, po_string_t::nextonhashchain, NULL, PO_HASHSIZE, strlen(), and po_string_t::value.

Referenced by PRVM_Prog_Load().

PRVM_PO_ParseString()

static void PRVM_PO_ParseString ( char * out, const char * in, size_t outsize )

static

Definition at line 1741 of file prvm_edict.c.

{
    for(;;)
    {
        switch(*in)
        {
            case 0:
                *out++ = 0;
                return;
            case '\\':
                ++in;
                switch(*in)
                {
                    case 'a': if(outsize > 0) { *out++ = '\a'; --outsize; } break;
                    case 'b': if(outsize > 0) { *out++ = '\b'; --outsize; } break;
                    case 't': if(outsize > 0) { *out++ = '\t'; --outsize; } break;
                    case 'r': if(outsize > 0) { *out++ = '\r'; --outsize; } break;
                    case 'n': if(outsize > 0) { *out++ = '\n'; --outsize; } break;
                    case '\\': if(outsize > 0) { *out++ = '\\'; --outsize; } break;
                    case '"': if(outsize > 0) { *out++ = '"'; --outsize; } break;
                    case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
                        if(outsize > 0)
                            *out = *in - '0';
                        ++in;
                        if(*in >= '0' && *in <= '7')
                        {
                            if(outsize > 0)
                                *out = (*out << 3) | (*in - '0');
                            ++in;
                        }
                        if(*in >= '0' && *in <= '7')
                        {
                            if(outsize > 0)
                                *out = (*out << 3) | (*in - '0');
                            ++in;
                        }
                        --in;
                        if(outsize > 0)
                        {
                            ++out;
                            --outsize;
                        }
                        break;
                    default:
                        if(outsize > 0) { *out++ = *in; --outsize; }
                        break;
                }
                break;
            default:
                if(outsize > 0)
                {
                    *out++ = *in;
                    --outsize;
                }
                break;
        }
        ++in;
    }
}

Referenced by PRVM_PO_Load().

PRVM_PO_UnparseString()

static void PRVM_PO_UnparseString ( char * out, const char * in, size_t outsize )

static

Definition at line 1700 of file prvm_edict.c.

{
    for(;;)
    {
        switch(*in)
        {
            case 0:
                *out++ = 0;
                return;
            case '\a': if(outsize >= 2) { *out++ = '\\'; *out++ = 'a'; outsize -= 2; } break;
            case '\b': if(outsize >= 2) { *out++ = '\\'; *out++ = 'b'; outsize -= 2; } break;
            case '\t': if(outsize >= 2) { *out++ = '\\'; *out++ = 't'; outsize -= 2; } break;
            case '\r': if(outsize >= 2) { *out++ = '\\'; *out++ = 'r'; outsize -= 2; } break;
            case '\n': if(outsize >= 2) { *out++ = '\\'; *out++ = 'n'; outsize -= 2; } break;
            case '\\': if(outsize >= 2) { *out++ = '\\'; *out++ = '\\'; outsize -= 2; } break;
            case '"': if(outsize >= 2) { *out++ = '\\'; *out++ = '"'; outsize -= 2; } break;
            default:
                if(*in >= 0 && *in <= 0x1F)
                {
                    if(outsize >= 4)
                    {
                        *out++ = '\\';
                        *out++ = '0' + ((*in & 0700) >> 6);
                        *out++ = '0' + ((*in & 0070) >> 3);
                        *out++ = '0' +  (*in & 0007)      ;
                        outsize -= 4;
                    }
                }
                else
                {
                    if(outsize >= 1)
                    {
                        *out++ = *in;
                        outsize -= 1;
                    }
                }
                break;
        }
        ++in;
    }
}

Referenced by PRVM_Prog_Load().

PRVM_Prog_Init()

void PRVM_Prog_Init	(	prvm_prog_t *	prog,
		cmd_state_t *	cmd )

Definition at line 3267 of file prvm_edict.c.

{
    PRVM_Prog_Reset(prog);
    prog->leaktest_active = prvm_leaktest.integer != 0;
    prog->console_cmd = cmd;
}

References cmd(), prvm_prog_t::console_cmd, cvar_t::integer, prvm_prog_t::leaktest_active, prvm_leaktest, and PRVM_Prog_Reset().

PRVM_Prog_Load()

void PRVM_Prog_Load	(	prvm_prog_t *	prog,
		const char *	filename,
		unsigned char *	data,
		fs_offset_t	size,
		void	CheckRequiredFuncsprvm_prog_t *prog, const char *filename,
		int	numrequiredfields,
		prvm_required_field_t *	required_field,
		int	numrequiredglobals,
		prvm_required_field_t *	required_global )

Definition at line 2024 of file prvm_edict.c.

{
    int i;
    dprograms_t *dprograms;
 
    dstatement16_t *instatements16;
    dstatement32_t *instatements32;
    ddef16_t *infielddefs16;
    ddef32_t *infielddefs32;
    ddef16_t *inglobaldefs16;
    ddef32_t *inglobaldefs32;
 
    int *inglobals;
    dfunction_t *infunctions;
    char *instrings;
    fs_offset_t filesize;
    int requiredglobalspace;
    opcode_t op;
    int a;
    int b;
    int c;
    union
    {
        unsigned int i;
        float f;
    }
    u;
    unsigned int d;
    char vabuf[1024];
    char vabuf2[1024];
    cvar_t *cvar;
    int structtype = 0;
    int max_safe_edicts;
 
    if (prog->loaded)
        prog->error_cmd("%s: there is already a %s program loaded!", __func__, prog->name);
 
    Host_LockSession(); // all progs can use the session cvar
    Crypto_LoadKeys(); // all progs might use the keys at init time
 
    if (data)
    {
        dprograms = (dprograms_t *) data;
        filesize = size;
    }
    else
        dprograms = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false, &filesize);
    if (dprograms == NULL || filesize < (fs_offset_t)sizeof(dprograms_t))
        prog->error_cmd("%s: couldn't load \"%s\" for %s", __func__, filename, prog->name);
    // TODO bounds check header fields (e.g. numstatements), they must never go behind end of file
 
    prog->profiletime = Sys_DirtyTime();
    prog->starttime = host.realtime;
 
    requiredglobalspace = 0;
    for (i = 0;i < numrequiredglobals;i++)
        requiredglobalspace += required_global[i].type == ev_vector ? 3 : 1;
 
    prog->filecrc = CRC_Block((unsigned char *)dprograms, filesize);
 
// byte swap the header
    prog->progs_version = LittleLong(dprograms->version);
    prog->progs_crc = LittleLong(dprograms->crc);
    if (prog->progs_version == 7)
    {
        dprograms_v7_t *v7 = (dprograms_v7_t*)dprograms;
        structtype = LittleLong(v7->secondaryversion);
        if (structtype == PROG_SECONDARYVERSION16 ||
            structtype == PROG_SECONDARYVERSION32) // barely supported
            Con_Printf(CON_WARN "WARNING: %s: %s targets FTEQW, for which support is incomplete. Proceed at your own risk.\n", prog->name, filename);
        else
            prog->error_cmd("%s: %s targets unknown engine", prog->name, filename);
 
        if (v7->numbodylessfuncs != 0 || v7->numtypes != 0 || v7->blockscompressed != 0)
            prog->error_cmd("%s: %s uses unsupported features.", prog->name, filename);
    }
    else if (prog->progs_version != PROG_VERSION)
        prog->error_cmd("%s: %s has wrong version number (%i should be %i)", prog->name, filename, prog->progs_version, PROG_VERSION);
    instatements16 = (dstatement16_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_statements));
    instatements32 = (dstatement32_t *)instatements16;
    prog->progs_numstatements = LittleLong(dprograms->numstatements);
    inglobaldefs16 = (ddef16_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_globaldefs));
    inglobaldefs32 = (ddef32_t *)inglobaldefs16;
    prog->progs_numglobaldefs = LittleLong(dprograms->numglobaldefs);
    infielddefs16 = (ddef16_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_fielddefs));
    infielddefs32 = (ddef32_t *)infielddefs16;
    prog->progs_numfielddefs = LittleLong(dprograms->numfielddefs);
    infunctions = (dfunction_t *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_functions));
    prog->progs_numfunctions = LittleLong(dprograms->numfunctions);
    instrings = (char *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_strings));
    prog->progs_numstrings = LittleLong(dprograms->numstrings);
    inglobals = (int *)((unsigned char *)dprograms + LittleLong(dprograms->ofs_globals));
    prog->progs_numglobals = LittleLong(dprograms->numglobals);
    prog->progs_entityfields = LittleLong(dprograms->entityfields);
 
    prog->numstatements = prog->progs_numstatements;
    prog->numglobaldefs = prog->progs_numglobaldefs;
    prog->numfielddefs = prog->progs_numfielddefs;
    prog->numfunctions = prog->progs_numfunctions;
    prog->numstrings = prog->progs_numstrings;
    prog->numglobals = prog->progs_numglobals;
    prog->entityfields = prog->progs_entityfields;
 
    if (LittleLong(dprograms->ofs_strings) + prog->progs_numstrings > (int)filesize)
        prog->error_cmd("%s: %s strings go past end of file", prog->name, filename);
    prog->strings = (char *)Mem_Alloc(prog->progs_mempool, prog->progs_numstrings);
    memcpy(prog->strings, instrings, prog->progs_numstrings);
    prog->stringssize = prog->progs_numstrings;
 
    prog->numknownstrings = 0;
    prog->maxknownstrings = 0;
    prog->knownstrings = NULL;
    prog->knownstrings_flags = NULL;
 
    Mem_ExpandableArray_NewArray(&prog->stringbuffersarray, prog->progs_mempool, sizeof(prvm_stringbuffer_t), 64);
 
    // we need to expand the globaldefs and fielddefs to include engine defs
    prog->globaldefs = (mdef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs_numglobaldefs + numrequiredglobals) * sizeof(mdef_t));
    prog->globals.fp = (prvm_vec_t *)Mem_Alloc(prog->progs_mempool, (prog->progs_numglobals + requiredglobalspace + 2) * sizeof(prvm_vec_t));
        // + 2 is because of an otherwise occurring overrun in RETURN instruction
        // when trying to return the last or second-last global
        // (RETURN always returns a vector, there is no RETURN_F instruction)
    prog->fielddefs = (mdef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs_numfielddefs + numrequiredfields) * sizeof(mdef_t));
    // we need to convert the statements to our memory format
    prog->statements = (mstatement_t *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof(mstatement_t));
    // allocate space for profiling statement usage
    prog->statement_profile = (double *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof(*prog->statement_profile));
    prog->explicit_profile = (double *)Mem_Alloc(prog->progs_mempool, prog->progs_numstatements * sizeof(*prog->statement_profile));
    // functions need to be converted to the memory format
    prog->functions = (mfunction_t *)Mem_Alloc(prog->progs_mempool, sizeof(mfunction_t) * prog->progs_numfunctions);
 
    for (i = 0;i < prog->progs_numfunctions;i++)
    {
        prog->functions[i].first_statement = LittleLong(infunctions[i].first_statement);
        prog->functions[i].parm_start = LittleLong(infunctions[i].parm_start);
        prog->functions[i].s_name = LittleLong(infunctions[i].s_name);
        prog->functions[i].s_file = LittleLong(infunctions[i].s_file);
        prog->functions[i].numparms = LittleLong(infunctions[i].numparms);
        prog->functions[i].locals = LittleLong(infunctions[i].locals);
        memcpy(prog->functions[i].parm_size, infunctions[i].parm_size, sizeof(infunctions[i].parm_size));
        if(prog->functions[i].first_statement >= prog->numstatements)
            prog->error_cmd("%s: out of bounds function statement (function %d) in %s", __func__, i, prog->name);
        // TODO bounds check parm_start, s_name, s_file, numparms, locals, parm_size
    }
 
    // copy the globaldefs to the new globaldefs list
    switch(structtype)
    {
    case PROG_SECONDARYVERSION32:
        for (i=0 ; i<prog->numglobaldefs ; i++)
        {
            prog->globaldefs[i].type = LittleLong(inglobaldefs32[i].type);
            prog->globaldefs[i].ofs = LittleLong(inglobaldefs32[i].ofs);
            prog->globaldefs[i].s_name = LittleLong(inglobaldefs32[i].s_name);
            // TODO bounds check ofs, s_name
        }
        break;
    default:
        for (i=0 ; i<prog->numglobaldefs ; i++)
        {
            prog->globaldefs[i].type = (unsigned short)LittleShort(inglobaldefs16[i].type);
            prog->globaldefs[i].ofs = (unsigned short)LittleShort(inglobaldefs16[i].ofs);
            prog->globaldefs[i].s_name = LittleLong(inglobaldefs16[i].s_name);
            // TODO bounds check ofs, s_name
        }
        break;
    }
 
    // append the required globals
    for (i = 0;i < numrequiredglobals;i++)
    {
        prog->globaldefs[prog->numglobaldefs].type = required_global[i].type;
        prog->globaldefs[prog->numglobaldefs].ofs = prog->numglobals;
        prog->globaldefs[prog->numglobaldefs].s_name = PRVM_SetEngineString(prog, required_global[i].name);
        if (prog->globaldefs[prog->numglobaldefs].type == ev_vector)
            prog->numglobals += 3;
        else
            prog->numglobals++;
        prog->numglobaldefs++;
    }
 
    // copy the progs fields to the new fields list
    switch(structtype)
    {
    case PROG_SECONDARYVERSION32:
        for (i = 0;i < prog->numfielddefs;i++)
        {
            prog->fielddefs[i].type = LittleLong(infielddefs32[i].type);
            if (prog->fielddefs[i].type & DEF_SAVEGLOBAL)
                prog->error_cmd("%s: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", __func__, prog->name);
            prog->fielddefs[i].ofs = LittleLong(infielddefs32[i].ofs);
            prog->fielddefs[i].s_name = LittleLong(infielddefs32[i].s_name);
            // TODO bounds check ofs, s_name
        }
        break;
    default:
        for (i = 0;i < prog->numfielddefs;i++)
        {
            prog->fielddefs[i].type = (unsigned short)LittleShort(infielddefs16[i].type);
            if (prog->fielddefs[i].type & DEF_SAVEGLOBAL)
                prog->error_cmd("%s: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", __func__, prog->name);
            prog->fielddefs[i].ofs = (unsigned short)LittleShort(infielddefs16[i].ofs);
            prog->fielddefs[i].s_name = LittleLong(infielddefs16[i].s_name);
            // TODO bounds check ofs, s_name
        }
        break;
    }
 
    // append the required fields
    for (i = 0;i < numrequiredfields;i++)
    {
        prog->fielddefs[prog->numfielddefs].type = required_field[i].type;
        prog->fielddefs[prog->numfielddefs].ofs = prog->entityfields;
        prog->fielddefs[prog->numfielddefs].s_name = PRVM_SetEngineString(prog, required_field[i].name);
        if (prog->fielddefs[prog->numfielddefs].type == ev_vector)
            prog->entityfields += 3;
        else
            prog->entityfields++;
        prog->numfielddefs++;
    }
 
    // LadyHavoc: TODO: reorder globals to match engine struct
    // LadyHavoc: TODO: reorder fields to match engine struct
#define remapglobal(index) (index)
#define remapfield(index) (index)
 
    // copy globals
    // FIXME: LadyHavoc: this uses a crude way to identify integer constants, rather than checking for matching globaldefs and checking their type
    for (i = 0;i < prog->progs_numglobals;i++)
    {
        u.i = LittleLong(inglobals[i]);
        // most globals are 0, we only need to deal with the ones that are not
        if (u.i)
        {
            d = u.i & 0xFF800000;
            if ((d == 0xFF800000) || (d == 0))
            {
                // Looks like an integer (expand to int64)
                prog->globals.ip[remapglobal(i)] = u.i;
            }
            else
            {
                // Looks like a float (expand to double)
                prog->globals.fp[remapglobal(i)] = u.f;
            }
        }
    }
 
    // copy, remap globals in statements, bounds check
    for (i = 0;i < prog->progs_numstatements;i++)
    {
        switch(structtype)
        {
        case PROG_SECONDARYVERSION32:
            op = (opcode_t)LittleLong(instatements32[i].op);
            a = (unsigned int)LittleLong(instatements32[i].a);
            b = (unsigned int)LittleLong(instatements32[i].b);
            c = (unsigned int)LittleLong(instatements32[i].c);
            break;
        default:
            op = (opcode_t)LittleShort(instatements16[i].op);
            a = (unsigned short)LittleShort(instatements16[i].a);
            b = (unsigned short)LittleShort(instatements16[i].b);
            c = (unsigned short)LittleShort(instatements16[i].c);
            break;
        }
        switch (op)
        {
        case OP_IF:
        case OP_IFNOT:
            b = (short)b;
            if (a >= prog->progs_numglobals || b + i < 0 || b + i >= prog->progs_numstatements)
                prog->error_cmd("%s: out of bounds IF/IFNOT (statement %d) in %s", __func__, i, prog->name);
            if (c)
                Con_DPrintf("%s: unexpected offset on binary opcode in %s\n", __func__, prog->name);
            prog->statements[i].op = op;
            prog->statements[i].operand[0] = remapglobal(a);
            prog->statements[i].operand[1] = b;
            prog->statements[i].operand[2] = -1;
            break;
        case OP_GOTO:
            a = (short)a;
            if (a + i < 0 || a + i >= prog->progs_numstatements)
                prog->error_cmd("%s: out of bounds GOTO (statement %d) in %s", __func__, i, prog->name);
            if (b || c)
                Con_DPrintf("%s: unexpected offset on unary opcode in %s\n", __func__, prog->name);
            prog->statements[i].op = op;
            prog->statements[i].operand[0] = a;
            prog->statements[i].operand[1] = -1;
            prog->statements[i].operand[2] = -1;
            break;
        default:
            Con_DPrintf("%s: unknown opcode %d at statement %d in %s\n", __func__, (int)op, i, prog->name);
 
            //make sure its something well defined.
            prog->statements[i].op = OP_BOUNDCHECK;
            prog->statements[i].operand[0] = 0;
            prog->statements[i].operand[1] =
            prog->statements[i].operand[2] = op;
            break;
        // global global global
        case OP_ADD_I:
        case OP_ADD_FI:
        case OP_ADD_IF:
        case OP_SUB_I:
        case OP_SUB_FI:
        case OP_SUB_IF:
        case OP_CONV_ITOF:
        case OP_CONV_FTOI:
        case OP_LOAD_I:
        case OP_BITAND_I:
        case OP_BITOR_I:
        case OP_MUL_I:
        case OP_DIV_I:
        case OP_EQ_I:
        case OP_NE_I:
        case OP_NOT_I:
        case OP_DIV_VF:
        case OP_LE_I:
        case OP_GE_I:
        case OP_LT_I:
        case OP_GT_I:
        case OP_LE_IF:
        case OP_GE_IF:
        case OP_LT_IF:
        case OP_GT_IF:
        case OP_LE_FI:
        case OP_GE_FI:
        case OP_LT_FI:
        case OP_GT_FI:
        case OP_EQ_IF:
        case OP_EQ_FI:
        case OP_MUL_IF:
        case OP_MUL_FI:
        case OP_MUL_VI:
        case OP_DIV_IF:
        case OP_DIV_FI:
        case OP_BITAND_IF:
        case OP_BITOR_IF:
        case OP_BITAND_FI:
        case OP_BITOR_FI:
        case OP_AND_I:
        case OP_OR_I:
        case OP_AND_IF:
        case OP_OR_IF:
        case OP_AND_FI:
        case OP_OR_FI:
        case OP_NE_IF:
        case OP_NE_FI:
        case OP_GSTOREP_I:
        case OP_GSTOREP_F:
        case OP_GSTOREP_ENT:
        case OP_GSTOREP_FLD:
        case OP_GSTOREP_S:
        case OP_GSTOREP_FNC:
        case OP_GSTOREP_V:
//      case OP_GADDRESS:
        case OP_GLOAD_I:
        case OP_GLOAD_F:
        case OP_GLOAD_FLD:
        case OP_GLOAD_ENT:
        case OP_GLOAD_S:
        case OP_GLOAD_FNC:
        case OP_BOUNDCHECK:
        case OP_GLOAD_V:
        case OP_ADD_F:
        case OP_ADD_V:
        case OP_SUB_F:
        case OP_SUB_V:
        case OP_MUL_F:
        case OP_MUL_V:
        case OP_MUL_FV:
        case OP_MUL_VF:
        case OP_DIV_F:
        case OP_BITAND_F:
        case OP_BITOR_F:
        case OP_GE_F:
        case OP_LE_F:
        case OP_GT_F:
        case OP_LT_F:
        case OP_AND_F:
        case OP_OR_F:
        case OP_EQ_F:
        case OP_EQ_V:
        case OP_EQ_S:
        case OP_EQ_E:
        case OP_EQ_FNC:
        case OP_NE_F:
        case OP_NE_V:
        case OP_NE_S:
        case OP_NE_E:
        case OP_NE_FNC:
        case OP_ADDRESS:
        case OP_LOAD_F:
        case OP_LOAD_FLD:
        case OP_LOAD_ENT:
        case OP_LOAD_S:
        case OP_LOAD_FNC:
        case OP_LOAD_V:
        case OP_LOAD_P:
        case OP_ADD_PIW:
        case OP_GLOBALADDRESS:
        case OP_LOADA_F:
        case OP_LOADA_V:
        case OP_LOADA_S:
        case OP_LOADA_ENT:
        case OP_LOADA_FLD:
        case OP_LOADA_FNC:
        case OP_LOADA_I:
        case OP_LOADP_F:
        case OP_LOADP_V:
        case OP_LOADP_S:
        case OP_LOADP_ENT:
        case OP_LOADP_FLD:
        case OP_LOADP_FNC:
        case OP_LOADP_I:
        case OP_STOREP_F:
        case OP_STOREP_ENT:
        case OP_STOREP_FLD:
        case OP_STOREP_S:
        case OP_STOREP_FNC:
        case OP_STOREP_V:
        case OP_STOREP_I:
        case OP_RSHIFT_I:
        case OP_LSHIFT_I:
        case OP_LE_U:
        case OP_LT_U:
        case OP_DIV_U:
        case OP_RSHIFT_U:
            if (a >= prog->progs_numglobals || b >= prog->progs_numglobals || c >= prog->progs_numglobals)
                prog->error_cmd("%s: out of bounds global index (statement %d)", __func__, i);
            prog->statements[i].op = op;
            prog->statements[i].operand[0] = remapglobal(a);
            prog->statements[i].operand[1] = remapglobal(b);
            prog->statements[i].operand[2] = remapglobal(c);
            break;
        // global none global
        case OP_NOT_F:
        case OP_NOT_V:
        case OP_NOT_S:
        case OP_NOT_FNC:
        case OP_NOT_ENT:
            if (a >= prog->progs_numglobals || c >= prog->progs_numglobals)
                prog->error_cmd("%s: out of bounds global index (statement %d) in %s", __func__, i, prog->name);
            if (b)
                Con_DPrintf("%s: unexpected offset on binary opcode in %s\n", __func__, prog->name);
            prog->statements[i].op = op;
            prog->statements[i].operand[0] = remapglobal(a);
            prog->statements[i].operand[1] = -1;
            prog->statements[i].operand[2] = remapglobal(c);
            break;
        // global global none
        case OP_STORE_F:
        case OP_STORE_ENT:
        case OP_STORE_FLD:
        case OP_STORE_S:
        case OP_STORE_FNC:
        case OP_STORE_V:
        case OP_STORE_I:
        case OP_STORE_P:
        case OP_STATE:
            if (a >= prog->progs_numglobals || b >= prog->progs_numglobals)
                prog->error_cmd("%s: out of bounds global index (statement %d) in %s", __func__, i, prog->name);
            if (c)
                Con_DPrintf("%s: unexpected offset on binary opcode in %s\n", __func__, prog->name);
            prog->statements[i].op = op;
            prog->statements[i].operand[0] = remapglobal(a);
            prog->statements[i].operand[1] = remapglobal(b);
            prog->statements[i].operand[2] = -1;
            break;
        // 1 global
        case OP_CALL0:
            if ( a < prog->progs_numglobals)
                if ( prog->globals.ip[remapglobal(a)] >= 0 )
                    if ( prog->globals.ip[remapglobal(a)] < prog->progs_numfunctions )
                        if ( prog->functions[prog->globals.ip[remapglobal(a)]].first_statement == -642 )
                            ++prog->numexplicitcoveragestatements;
        case OP_CALL1:
        case OP_CALL2:
        case OP_CALL3:
        case OP_CALL4:
        case OP_CALL5:
        case OP_CALL6:
        case OP_CALL7:
        case OP_CALL8:
        case OP_DONE:
        case OP_RETURN:
            if ( a >= prog->progs_numglobals)
                prog->error_cmd("%s: out of bounds global index (statement %d) in %s", __func__, i, prog->name);
            if (b || c) //Spike -- added this check just as a diagnostic...
                Con_DPrintf("%s: unexpected offset on call opcode in %s. Hexen2 format is not supported\n", __func__, prog->name);
            prog->statements[i].op = op;
            prog->statements[i].operand[0] = remapglobal(a);
            prog->statements[i].operand[1] = -1;
            prog->statements[i].operand[2] = -1;
            break;
        }
    }
    if(prog->numstatements < 1)
    {
        prog->error_cmd("%s: empty program in %s", __func__, prog->name);
    }
    else switch(prog->statements[prog->numstatements - 1].op)
    {
        case OP_RETURN:
        case OP_GOTO:
        case OP_DONE:
            break;
        default:
            prog->error_cmd("%s: program may fall off the edge (does not end with RETURN, GOTO or DONE) in %s", __func__, prog->name);
            break;
    }
 
    // we're done with the file now
    if(!data)
        Mem_Free(dprograms);
    dprograms = NULL;
 
    prog->flag = 0;
    // expected to not return (call prog->error_cmd) if checks fail
    CheckRequiredFuncs(prog, filename);
 
    PRVM_LoadLNO(prog, filename);
 
    PRVM_Init_Exec(prog);
 
    if(*prvm_language.string)
    // in CSQC we really shouldn't be able to change how stuff works... sorry for now
    // later idea: include a list of authorized .po file checksums with the csprogs
    {
        qbool deftrans = prog == CLVM_prog;
        const char *realfilename = (prog != CLVM_prog ? filename : csqc_progname.string);
        if(deftrans) // once we have dotranslate_ strings, ALWAYS use the opt-in method!
        {
            for (i=0 ; i<prog->numglobaldefs ; i++)
            {
                const char *name;
                name = PRVM_GetString(prog, prog->globaldefs[i].s_name);
                if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
                if(name && !strncmp(name, "dotranslate_", 12))
                {
                    deftrans = false;
                    break;
                }
            }
        }
        if(!strcmp(prvm_language.string, "dump"))
        {
            qfile_t *f = FS_OpenRealFile(va(vabuf, sizeof(vabuf), "%s.pot", realfilename), "w", false);
            Con_Printf("Dumping to %s.pot\n", realfilename);
            if(f)
            {
                for (i=0 ; i<prog->numglobaldefs ; i++)
                {
                    const char *name;
                    name = PRVM_GetString(prog, prog->globaldefs[i].s_name);
                    if(deftrans ? (!name || strncmp(name, "notranslate_", 12)) : (name && !strncmp(name, "dotranslate_", 12)))
                    if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
                    {
                        prvm_eval_t *val = PRVM_GLOBALFIELDVALUE(prog->globaldefs[i].ofs);
                        const char *value = PRVM_GetString(prog, val->string);
                        if(*value)
                        {
                            char buf[MAX_INPUTLINE];
                            PRVM_PO_UnparseString(buf, value, sizeof(buf));
                            FS_Printf(f, "msgid \"%s\"\nmsgstr \"\"\n\n", buf);
                        }
                    }
                }
                FS_Close(f);
            }
        }
        else
        {
            po_t *po = PRVM_PO_Load(
                    va(vabuf, sizeof(vabuf), "%s.%s.po", realfilename, prvm_language.string),
                    va(vabuf2, sizeof(vabuf2), "common.%s.po", prvm_language.string),
                    prog->progs_mempool);
            if(po)
            {
                for (i=0 ; i<prog->numglobaldefs ; i++)
                {
                    const char *name;
                    name = PRVM_GetString(prog, prog->globaldefs[i].s_name);
                    if(deftrans ? (!name || strncmp(name, "notranslate_", 12)) : (name && !strncmp(name, "dotranslate_", 12)))
                    if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
                    {
                        prvm_eval_t *val = PRVM_GLOBALFIELDVALUE(prog->globaldefs[i].ofs);
                        const char *value = PRVM_GetString(prog, val->string);
                        if(*value)
                        {
                            value = PRVM_PO_Lookup(po, value);
                            if(value)
                                val->string = PRVM_SetEngineString(prog, value);
                        }
                    }
                }
            }
        }
    }
 
    for (cvar = prog->console_cmd->cvars->vars; cvar; cvar = cvar->next)
        cvar->globaldefindex[prog - prvm_prog_list] = -1;
 
    for (i=0 ; i<prog->numglobaldefs ; i++)
    {
        const char *name;
        name = PRVM_GetString(prog, prog->globaldefs[i].s_name);
        //Con_Printf("found var %s\n", name);
        if(name
            && !strncmp(name, "autocvar_", 9)
            && !(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z'))
        )
        {
            prvm_eval_t *val = PRVM_GLOBALFIELDVALUE(prog->globaldefs[i].ofs);
            cvar = Cvar_FindVar(prog->console_cmd->cvars, name + 9, prog->console_cmd->cvars_flagsmask);
            //Con_Printf("%s: autocvar global %s in %s, processing...\n", __func__, name, prog->name);
            if(!cvar)
            {
                const char *value;
                char buf[128];
                int prec[3];
                float f;
                Con_DPrintf("%s: no cvar for autocvar global %s in %s, creating...\n", __func__, name, prog->name);
                switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL)
                {
                    case ev_float:
                        if((float)((int)(val->_float)) == val->_float)
                            dpsnprintf(buf, sizeof(buf), "%i", (int)(val->_float));
                        else
                        {
                            // ftos_slow
                            f = val->_float;
                            for (int precision = 7; precision <= 9; ++precision) {
                                dpsnprintf(buf, sizeof(buf), "%.*g", precision, f);
                                if ((float)atof(buf) == f) {
                                    break;
                                }
                            }
                        }
                        value = buf;
                        break;
                    case ev_vector:
                        for (i = 0; i < 3; ++i)
                        {
                            prec[i] = 9;
                            f = val->vector[i];
                            for (int precision = 7; precision <= 9; ++precision) {
                                dpsnprintf(buf, sizeof(buf), "%.*g", precision, f);
                                if ((float)atof(buf) == f) {
                                    prec[i] = precision;
                                    break;
                                }
                            }
                        }
                        dpsnprintf(buf, sizeof(buf), "%.*g %.*g %.*g", prec[0], val->vector[0], prec[1], val->vector[1], prec[2], val->vector[2]);
                        value = buf;
                        break;
                    case ev_string:
                        value = PRVM_GetString(prog, val->string);
                        break;
                    default:
                        Con_Printf("%s: invalid type of autocvar global %s in %s\n", __func__, name, prog->name);
                        goto fail;
                }
                cvar = Cvar_Get(prog->console_cmd->cvars, name + 9, value, prog->console_cmd->cvars_flagsmask, NULL);
                if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
                {
                    val->string = PRVM_SetEngineString(prog, cvar->string);
                    cvar->globaldefindex_stringno[prog - prvm_prog_list] = val->string;
                }
                if(!cvar)
                    prog->error_cmd("%s: could not create cvar for autocvar global %s in %s", __func__, name, prog->name);
                cvar->globaldefindex[prog - prvm_prog_list] = i;
            }
            else if((cvar->flags & CF_PRIVATE) == 0)
            {
                // MUST BE SYNCED WITH cvar.c Cvar_Set
                int j;
                const char *s;
                switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL)
                {
                    case ev_float:
                        val->_float = cvar->value;
                        break;
                    case ev_vector:
                        s = cvar->string;
                        VectorClear(val->vector);
                        for (j = 0;j < 3;j++)
                        {
                            while (*s && ISWHITESPACE(*s))
                                s++;
                            if (!*s)
                                break;
                            val->vector[j] = atof(s);
                            while (!ISWHITESPACE(*s))
                                s++;
                            if (!*s)
                                break;
                        }
                        break;
                    case ev_string:
                        val->string = PRVM_SetEngineString(prog, cvar->string);
                        cvar->globaldefindex_stringno[prog - prvm_prog_list] = val->string;
                        break;
                    default:
                        Con_Printf("%s: invalid type of autocvar global %s in %s\n", __func__, name, prog->name);
                        goto fail;
                }
                cvar->globaldefindex[prog - prvm_prog_list] = i;
            }
            else
                Con_Printf("%s: private cvar for autocvar global %s in %s\n", __func__, name, prog->name);
        }
fail:
        ;
    }
 
    prog->loaded = true;
 
    PRVM_UpdateBreakpoints(prog);
 
    // set flags & mdef_ts in prog
 
    PRVM_FindOffsets(prog);
 
    // Do not allow more than 2^31 total entityfields. Achieve this by limiting maximum edict count.
    // TODO: For PRVM_64, this can be relaxes. May require changing some types away from int.
    max_safe_edicts = ((1 << 31) - prog->numglobals) / prog->entityfields;
    if (prog->limit_edicts > max_safe_edicts)
    {
        Con_Printf("%s: reducing maximum entity count to %d to avoid address overflow in %s\n", __func__, max_safe_edicts, prog->name);
        prog->limit_edicts = max_safe_edicts;
    }
 
    prog->init_cmd(prog);
 
    // init mempools
    PRVM_MEM_Alloc(prog);
 
    Con_Printf("%s: program loaded (crc %i, size %iK)%s\n", prog->name, prog->filecrc, (int)(filesize/1024),
        prog == CLVM_prog ? (prog->flag & PRVM_CSQC_SIMPLE ? " CSQC_SIMPLE" : " EXT_CSQC") : "");
 
    // Inittime is at least the time when this function finished. However,
    // later events may bump it.
    prog->inittime = host.realtime;
}

References prvm_eval_t::_float, a, b, dprograms_v7_t::blockscompressed, buf, CF_PRIVATE, CLVM_prog, Con_DPrintf(), Con_Printf(), CON_WARN, prvm_prog_t::console_cmd, dprograms_t::crc, CRC_Block(), Crypto_LoadKeys(), csqc_progname, cvar(), Cvar_FindVar(), Cvar_Get(), data, DEF_SAVEGLOBAL, dpsnprintf(), dprograms_t::entityfields, prvm_prog_t::entityfields, prvm_prog_t::error_cmd, ev_float, ev_string, ev_vector, prvm_prog_t::explicit_profile, f, prvm_prog_t::fielddefs, prvm_prog_t::filecrc, mfunction_t::first_statement, prvm_prog_t::flag, prvm_prog_t::fp, FS_Close(), FS_LoadFile(), FS_OpenRealFile(), FS_Printf(), prvm_prog_t::functions, prvm_prog_t::globaldefs, prvm_prog_t::globals, host, Host_LockSession(), i, prvm_prog_t::init_cmd, prvm_prog_t::inittime, int(), prvm_prog_t::ip, ISWHITESPACE, prvm_prog_t::knownstrings, prvm_prog_t::knownstrings_flags, prvm_prog_t::limit_edicts, LittleLong, LittleShort, prvm_prog_t::loaded, mfunction_t::locals, MAX_INPUTLINE, prvm_prog_t::maxknownstrings, Mem_Alloc, Mem_ExpandableArray_NewArray(), Mem_Free, name, prvm_prog_t::name, NULL, dprograms_v7_t::numbodylessfuncs, prvm_prog_t::numexplicitcoveragestatements, dprograms_t::numfielddefs, prvm_prog_t::numfielddefs, dprograms_t::numfunctions, prvm_prog_t::numfunctions, dprograms_t::numglobaldefs, prvm_prog_t::numglobaldefs, dprograms_t::numglobals, prvm_prog_t::numglobals, prvm_prog_t::numknownstrings, mfunction_t::numparms, dprograms_t::numstatements, prvm_prog_t::numstatements, dprograms_t::numstrings, prvm_prog_t::numstrings, dprograms_v7_t::numtypes, mdef_t::ofs, ofs, dprograms_t::ofs_fielddefs, dprograms_t::ofs_functions, dprograms_t::ofs_globaldefs, dprograms_t::ofs_globals, dprograms_t::ofs_statements, dprograms_t::ofs_strings, mstatement_t::op, OP_ADD_F, OP_ADD_FI, OP_ADD_I, OP_ADD_IF, OP_ADD_PIW, OP_ADD_V, OP_ADDRESS, OP_AND_F, OP_AND_FI, OP_AND_I, OP_AND_IF, OP_BITAND_F, OP_BITAND_FI, OP_BITAND_I, OP_BITAND_IF, OP_BITOR_F, OP_BITOR_FI, OP_BITOR_I, OP_BITOR_IF, OP_BOUNDCHECK, OP_CALL0, OP_CALL1, OP_CALL2, OP_CALL3, OP_CALL4, OP_CALL5, OP_CALL6, OP_CALL7, OP_CALL8, OP_CONV_FTOI, OP_CONV_ITOF, OP_DIV_F, OP_DIV_FI, OP_DIV_I, OP_DIV_IF, OP_DIV_U, OP_DIV_VF, OP_DONE, OP_EQ_E, OP_EQ_F, OP_EQ_FI, OP_EQ_FNC, OP_EQ_I, OP_EQ_IF, OP_EQ_S, OP_EQ_V, OP_GE_F, OP_GE_FI, OP_GE_I, OP_GE_IF, OP_GLOAD_ENT, OP_GLOAD_F, OP_GLOAD_FLD, OP_GLOAD_FNC, OP_GLOAD_I, OP_GLOAD_S, OP_GLOAD_V, OP_GLOBALADDRESS, OP_GOTO, OP_GSTOREP_ENT, OP_GSTOREP_F, OP_GSTOREP_FLD, OP_GSTOREP_FNC, OP_GSTOREP_I, OP_GSTOREP_S, OP_GSTOREP_V, OP_GT_F, OP_GT_FI, OP_GT_I, OP_GT_IF, OP_IF, OP_IFNOT, OP_LE_F, OP_LE_FI, OP_LE_I, OP_LE_IF, OP_LE_U, OP_LOAD_ENT, OP_LOAD_F, OP_LOAD_FLD, OP_LOAD_FNC, OP_LOAD_I, OP_LOAD_P, OP_LOAD_S, OP_LOAD_V, OP_LOADA_ENT, OP_LOADA_F, OP_LOADA_FLD, OP_LOADA_FNC, OP_LOADA_I, OP_LOADA_S, OP_LOADA_V, OP_LOADP_ENT, OP_LOADP_F, OP_LOADP_FLD, OP_LOADP_FNC, OP_LOADP_I, OP_LOADP_S, OP_LOADP_V, OP_LSHIFT_I, OP_LT_F, OP_LT_FI, OP_LT_I, OP_LT_IF, OP_LT_U, OP_MUL_F, OP_MUL_FI, OP_MUL_FV, OP_MUL_I, OP_MUL_IF, OP_MUL_V, OP_MUL_VF, OP_MUL_VI, OP_NE_E, OP_NE_F, OP_NE_FI, OP_NE_FNC, OP_NE_I, OP_NE_IF, OP_NE_S, OP_NE_V, OP_NOT_ENT, OP_NOT_F, OP_NOT_FNC, OP_NOT_I, OP_NOT_S, OP_NOT_V, OP_OR_F, OP_OR_FI, OP_OR_I, OP_OR_IF, OP_RETURN, OP_RSHIFT_I, OP_RSHIFT_U, OP_STATE, OP_STORE_ENT, OP_STORE_F, OP_STORE_FLD, OP_STORE_FNC, OP_STORE_I, OP_STORE_P, OP_STORE_S, OP_STORE_V, OP_STOREP_ENT, OP_STOREP_F, OP_STOREP_FLD, OP_STOREP_FNC, OP_STOREP_I, OP_STOREP_S, OP_STOREP_V, OP_SUB_F, OP_SUB_FI, OP_SUB_I, OP_SUB_IF, OP_SUB_V, mstatement_t::operand, dfunction_t::parm_size, mfunction_t::parm_size, mfunction_t::parm_start, prvm_prog_t::profiletime, PROG_SECONDARYVERSION16, PROG_SECONDARYVERSION32, PROG_VERSION, prvm_prog_t::progs_crc, prvm_prog_t::progs_entityfields, prvm_prog_t::progs_mempool, prvm_prog_t::progs_numfielddefs, prvm_prog_t::progs_numfunctions, prvm_prog_t::progs_numglobaldefs, prvm_prog_t::progs_numglobals, prvm_prog_t::progs_numstatements, prvm_prog_t::progs_numstrings, prvm_prog_t::progs_version, PRVM_CSQC_SIMPLE, PRVM_FindOffsets(), PRVM_GetString(), PRVM_GLOBALFIELDVALUE, PRVM_Init_Exec(), prvm_language, PRVM_LoadLNO(), PRVM_MEM_Alloc(), PRVM_PO_Load(), PRVM_PO_Lookup(), PRVM_PO_UnparseString(), prvm_prog_list, PRVM_SetEngineString(), PRVM_UpdateBreakpoints(), host_static_t::realtime, remapglobal, mfunction_t::s_file, mdef_t::s_name, mfunction_t::s_name, dprograms_v7_t::secondaryversion, size, prvm_prog_t::starttime, prvm_prog_t::statement_profile, prvm_prog_t::statements, cvar_t::string, prvm_eval_t::string, prvm_prog_t::stringbuffersarray, prvm_prog_t::strings, prvm_prog_t::stringssize, strlen(), Sys_DirtyTime(), mdef_t::type, prvm_required_field_t::type, type, va(), value, prvm_eval_t::vector, VectorClear, and dprograms_t::version.

Referenced by CL_VM_Init(), MP_Init(), and SV_VM_Setup().

PRVM_Prog_Reset()

void PRVM_Prog_Reset

(

prvm_prog_t *

prog

)

Definition at line 1944 of file prvm_edict.c.

{
    if (prog->loaded)
    {
        if(prog->tempstringsbuf.cursize)
            Mem_Free(prog->tempstringsbuf.data);
        prog->tempstringsbuf.cursize = 0;
        PRVM_LeakTest(prog);
        prog->reset_cmd(prog);
        Mem_FreePool(&prog->progs_mempool);
        if(prog->po)
            PRVM_PO_Destroy((po_t *) prog->po);
    }
    memset(prog,0,sizeof(prvm_prog_t));
    prog->break_statement = -1;
    prog->watch_global_type = ev_void;
    prog->watch_field_type = ev_void;
}

References prvm_prog_t::break_statement, sizebuf_t::cursize, sizebuf_t::data, ev_void, prvm_prog_t::loaded, Mem_Free, Mem_FreePool, prvm_prog_t::po, prvm_prog_t::progs_mempool, PRVM_LeakTest(), PRVM_PO_Destroy(), prvm_prog_t::reset_cmd, prvm_prog_t::tempstringsbuf, prvm_prog_t::watch_field_type, and prvm_prog_t::watch_global_type.

Referenced by CL_VM_ShutDown(), MP_Shutdown(), PRVM_Crash(), PRVM_Prog_Init(), and SV_VM_Shutdown().

PRVM_ProgFromString()

prvm_prog_t * PRVM_ProgFromString

(

const char *

str

)

Definition at line 166 of file prvm_edict.c.

{
    if (!strcmp(str, "server"))
        return SVVM_prog;
    if (!strcmp(str, "client"))
        return CLVM_prog;
#ifdef CONFIG_MENU
    if (!strcmp(str, "menu"))
        return MVM_prog;
#endif
    return NULL;
}

References CLVM_prog, NULL, and SVVM_prog.

Referenced by PRVM_Breakpoint_f(), PRVM_EdictWatchpoint_f(), PRVM_FriendlyProgFromString(), and PRVM_GlobalWatchpoint_f().

PRVM_SetEngineString()

int PRVM_SetEngineString	(	prvm_prog_t *	prog,
		const char *	s )

Definition at line 3390 of file prvm_edict.c.

{
    int i;
    if (!s)
        return 0;
    if (s >= prog->strings && s <= prog->strings + prog->stringssize)
        prog->error_cmd("PRVM_SetEngineString: s in prog->strings area");
    // if it's in the tempstrings area, use a reserved range
    // (otherwise we'd get millions of useless string offsets cluttering the database)
    if (s >= (char *)prog->tempstringsbuf.data && s < (char *)prog->tempstringsbuf.data + prog->tempstringsbuf.maxsize)
        return prog->stringssize + (s - (char *)prog->tempstringsbuf.data);
    // see if it's a known string address
    for (i = 0;i < prog->numknownstrings;i++)
        if (prog->knownstrings[i] == s)
            return PRVM_KNOWNSTRINGBASE + i;
    // new unknown engine string
    if (developer_insane.integer)
        Con_DPrintf("new engine string %p = \"%s\"\n", (void *)s, s);
    for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
        if (!prog->knownstrings[i])
            break;
    PRVM_NewKnownString(prog, i, KNOWNSTRINGFLAG_GCMARK | KNOWNSTRINGFLAG_ENGINE, s);
    return PRVM_KNOWNSTRINGBASE + i;
}

References Con_DPrintf(), sizebuf_t::data, developer_insane, prvm_prog_t::error_cmd, prvm_prog_t::firstfreeknownstring, i, cvar_t::integer, KNOWNSTRINGFLAG_ENGINE, KNOWNSTRINGFLAG_GCMARK, prvm_prog_t::knownstrings, sizebuf_t::maxsize, prvm_prog_t::numknownstrings, PRVM_KNOWNSTRINGBASE, PRVM_NewKnownString(), prvm_prog_t::strings, prvm_prog_t::stringssize, and prvm_prog_t::tempstringsbuf.

Referenced by CL_VM_Init(), PRVM_Prog_Load(), PRVM_SetTempString(), SV_Name(), SV_Playermodel_f(), SV_Playerskin_f(), SV_SpawnServer(), SV_UpdateToReliableMessages(), SVVM_init_edict(), VM_CL_modelnameforindex(), VM_CL_setmodel(), VM_CL_setmodelindex(), VM_SV_modelnameforindex(), VM_SV_setmodel(), and VM_SV_setmodelindex().

PRVM_SetTempString()

int PRVM_SetTempString	(	prvm_prog_t *	prog,
		const char *	s,
		size_t	slen )

Takes an strlen (not a buffer size).

Definition at line 3423 of file prvm_edict.c.

{
    size_t size;
    char *t;
 
    if (!s || slen >= VM_TEMPSTRING_MAXSIZE)
        return 0;
    size = slen + 1;
    if (developer_insane.integer)
        Con_DPrintf("PRVM_SetTempString %s: cursize %i, new tempstring size %lu\n", prog->name, prog->tempstringsbuf.cursize, (unsigned long)size);
    if ((size_t)prog->tempstringsbuf.maxsize < prog->tempstringsbuf.cursize + size)
    {
        sizebuf_t old = prog->tempstringsbuf;
        if (prog->tempstringsbuf.cursize + size >= 1<<28)
            prog->error_cmd("PRVM_SetTempString %s: ran out of tempstring memory!  (refusing to grow tempstring buffer over 256MB, cursize %i, new tempstring size %lu)\n", prog->name, prog->tempstringsbuf.cursize, (unsigned long)size);
        prog->tempstringsbuf.maxsize = max(prog->tempstringsbuf.maxsize, 65536);
        while ((size_t)prog->tempstringsbuf.maxsize < prog->tempstringsbuf.cursize + size)
            prog->tempstringsbuf.maxsize *= 2;
        if (prog->tempstringsbuf.maxsize != old.maxsize || prog->tempstringsbuf.data == NULL)
        {
            Con_DPrintf("PRVM_SetTempString %s: enlarging tempstrings buffer (%iKB -> %iKB)\n", prog->name, old.maxsize/1024, prog->tempstringsbuf.maxsize/1024);
            prog->tempstringsbuf.data = (unsigned char *) Mem_Alloc(prog->progs_mempool, prog->tempstringsbuf.maxsize);
            if (old.data)
            {
                if (old.cursize)
                    memcpy(prog->tempstringsbuf.data, old.data, old.cursize);
                Mem_Free(old.data);
            }
        }
    }
    t = (char *)prog->tempstringsbuf.data + prog->tempstringsbuf.cursize;
    memcpy(t, s, size);
    prog->tempstringsbuf.cursize += size;
    return PRVM_SetEngineString(prog, t);
}

References Con_DPrintf(), sizebuf_t::cursize, sizebuf_t::data, developer_insane, prvm_prog_t::error_cmd, cvar_t::integer, max, sizebuf_t::maxsize, Mem_Alloc, Mem_Free, prvm_prog_t::name, NULL, prvm_prog_t::progs_mempool, PRVM_SetEngineString(), size, prvm_prog_t::tempstringsbuf, and VM_TEMPSTRING_MAXSIZE.

Referenced by CL_VM_Event_Sound(), CL_VM_Parse_CenterPrint(), CL_VM_Parse_Print(), CL_VM_Parse_StuffCmd(), PRVM_ConsoleCommand(), PRVM_GameCommand(), SV_ReadClientMessage(), uri_to_string_callback(), VM_altstr_get(), VM_altstr_ins(), VM_altstr_prepare(), VM_altstr_set(), VM_buf_implode(), VM_bufstr_get(), VM_chr(), VM_chr2str(), VM_CL_getextresponse(), VM_CL_getplayerkey(), VM_CL_getstats(), VM_CL_gettaginfo(), VM_CL_ReadPicture(), VM_CL_ReadString(), VM_CL_serverkey(), VM_CL_skel_get_bonename(), VM_cvar_defstring(), VM_cvar_description(), VM_cvar_string(), VM_digest_hex(), VM_entityfieldname(), VM_etos(), VM_fgets(), VM_findkeysforcommand(), VM_ftos(), VM_getentityfieldstring(), VM_getkeybind(), VM_getsurfacetexture(), VM_infoadd(), VM_infoget(), VM_keynumtostring(), VM_M_crypto_getencryptlevel(), VM_M_crypto_getidfp(), VM_M_crypto_getkeyfp(), VM_M_crypto_getmyidfp(), VM_M_crypto_getmykeyfp(), VM_M_getgamedirinfo(), VM_M_getserverliststring(), VM_netaddress_resolve(), VM_search_getfilename(), VM_SetTraceGlobals(), VM_sprintf(), VM_strcat(), VM_strconv(), VM_strdecolorize(), VM_strftime(), VM_strireplace(), VM_strpad(), VM_strreplace(), VM_strtolower(), VM_strtoupper(), VM_substring(), VM_SV_getextresponse(), VM_SV_gettaginfo(), VM_SV_serverkey(), VM_SV_skel_get_bonename(), VM_tokenize(), VM_tokenize_console(), VM_tokenizebyseparator(), VM_uncolorstring(), VM_uri_escape(), VM_uri_unescape(), VM_vtos(), and VM_whichpack().

PRVM_UglyValueString()

char * PRVM_UglyValueString	(	prvm_prog_t *	prog,
		etype_t	type,
		prvm_eval_t *	val,
		char *	line,
		size_t	linelength )

Definition at line 513 of file prvm_edict.c.

{
    int i;
    const char *s;
    mdef_t *def;
    mfunction_t *f;
 
    type = (etype_t)((int)type & ~DEF_SAVEGLOBAL);
 
    switch (type)
    {
    case ev_string:
        // Parse the string a bit to turn special characters
        // (like newline, specifically) into escape codes,
        // this fixes saving games from various mods
        s = PRVM_GetString (prog, val->string);
        for (i = 0;i < (int)linelength - 2 && *s;)
        {
            if (*s == '\n')
            {
                line[i++] = '\\';
                line[i++] = 'n';
            }
            else if (*s == '\r')
            {
                line[i++] = '\\';
                line[i++] = 'r';
            }
            else if (*s == '\\')
            {
                line[i++] = '\\';
                line[i++] = '\\';
            }
            else if (*s == '"')
            {
                line[i++] = '\\';
                line[i++] = '"';
            }
            else
                line[i++] = *s;
            s++;
        }
        line[i] = '\0';
        break;
    case ev_entity:
        i = val->edict;
        dpsnprintf (line, linelength, "%i", i);
        break;
    case ev_function:
        if ((unsigned int)val->function < (unsigned int)prog->progs_numfunctions)
        {
            f = prog->functions + val->function;
            dp_strlcpy (line, PRVM_GetString (prog, f->s_name), linelength);
        }
        else
            dpsnprintf (line, linelength, "bad function %" PRVM_PRIi " (invalid!)", val->function);
        break;
    case ev_field:
        def = PRVM_ED_FieldAtOfs ( prog, val->_int );
        if (def != NULL)
            dpsnprintf (line, linelength, ".%s", PRVM_GetString(prog, def->s_name));
        else
            dpsnprintf (line, linelength, "field %" PRVM_PRIi "(invalid!)", val->_int );
        break;
    case ev_void:
        dpsnprintf (line, linelength, "void");
        break;
    case ev_float:
        dpsnprintf (line, linelength, PRVM_FLOAT_LOSSLESS_FORMAT, val->_float);
        break;
    case ev_vector:
        dpsnprintf (line, linelength, PRVM_VECTOR_LOSSLESS_FORMAT, val->vector[0], val->vector[1], val->vector[2]);
        break;
    default:
        dpsnprintf (line, linelength, "bad type %i", type);
        break;
    }
 
    return line;
}

References prvm_eval_t::_float, prvm_eval_t::_int, DEF_SAVEGLOBAL, dp_strlcpy, dpsnprintf(), prvm_eval_t::edict, ev_entity, ev_field, ev_float, ev_function, ev_string, ev_vector, ev_void, f, prvm_eval_t::function, prvm_prog_t::functions, i, int(), NULL, prvm_prog_t::progs_numfunctions, PRVM_ED_FieldAtOfs(), PRVM_FLOAT_LOSSLESS_FORMAT, PRVM_GetString(), PRVM_PRIi, PRVM_VECTOR_LOSSLESS_FORMAT, mdef_t::s_name, prvm_eval_t::string, type, and prvm_eval_t::vector.

Referenced by PRVM_ED_EdictGet_f(), PRVM_ED_GlobalGet_f(), PRVM_ED_Write(), PRVM_ED_WriteGlobals(), PRVM_Watchpoint(), and VM_getentityfieldstring().

PRVM_UpdateBreakpoints()

static void PRVM_UpdateBreakpoints ( prvm_prog_t * prog )

static

Definition at line 3025 of file prvm_edict.c.

{
    debug_data_t *debug = &debug_data[prog - prvm_prog_list];
    if (!prog->loaded)
        return;
    if (debug->break_statement[0])
    {
        if (debug->break_statement[0] >= '0' && debug->break_statement[0] <= '9')
        {
            prog->break_statement = atoi(debug->break_statement);
            prog->break_stack_index = 0;
        }
        else
        {
            mfunction_t *func;
            func = PRVM_ED_FindFunction (prog, debug->break_statement);
            if (!func)
            {
                Con_Printf("%s progs: no function or statement named %s to break on!\n", prog->name, debug->break_statement);
                prog->break_statement = -1;
            }
            else
            {
                prog->break_statement = func->first_statement;
                prog->break_stack_index = 1;
            }
        }
        if (prog->break_statement >= -1)
            Con_Printf("%s progs: breakpoint is at statement %d\n", prog->name, prog->break_statement);
    }
    else
        prog->break_statement = -1;
 
    if (debug->watch_global[0])
    {
        mdef_t *global = PRVM_ED_FindGlobal( prog, debug->watch_global );
        if( !global )
        {
            Con_Printf( "%s progs: no global named '%s' to watch!\n", prog->name, debug->watch_global );
            prog->watch_global_type = ev_void;
        }
        else
        {
            size_t sz = sizeof(prvm_vec_t) * ((global->type  & ~DEF_SAVEGLOBAL) == ev_vector ? 3 : 1);
            prog->watch_global = global->ofs;
            prog->watch_global_type = (etype_t)global->type;
            memcpy(&prog->watch_global_value, PRVM_GLOBALFIELDVALUE(prog->watch_global), sz);
        }
        if (prog->watch_global_type != ev_void)
            Con_Printf("%s progs: global watchpoint is at global index %d\n", prog->name, prog->watch_global);
    }
    else
        prog->watch_global_type = ev_void;
 
    if (debug->watch_field[0])
    {
        mdef_t *field = PRVM_ED_FindField( prog, debug->watch_field );
        if( !field )
        {
            Con_Printf( "%s progs: no field named '%s' to watch!\n", prog->name, debug->watch_field );
            prog->watch_field_type = ev_void;
        }
        else
        {
            size_t sz = sizeof(prvm_vec_t) * ((field->type & ~DEF_SAVEGLOBAL) == ev_vector ? 3 : 1);
            prog->watch_edict = debug->watch_edict;
            prog->watch_field = field->ofs;
            prog->watch_field_type = (etype_t)field->type;
            if (prog->watch_edict < prog->num_edicts)
                memcpy(&prog->watch_edictfield_value, PRVM_EDICTFIELDVALUE(PRVM_EDICT_NUM(prog->watch_edict), prog->watch_field), sz);
            else
                memset(&prog->watch_edictfield_value, 0, sz);
        }
        if (prog->watch_edict != ev_void)
            Con_Printf("%s progs: edict field watchpoint is at edict %d field index %d\n", prog->name, prog->watch_edict, prog->watch_field);
    }
    else
        prog->watch_field_type = ev_void;
}

References prvm_prog_t::break_stack_index, debug_data_t::break_statement, prvm_prog_t::break_statement, Con_Printf(), debug_data, DEF_SAVEGLOBAL, ev_vector, ev_void, mfunction_t::first_statement, prvm_prog_t::loaded, prvm_prog_t::name, prvm_prog_t::num_edicts, mdef_t::ofs, PRVM_ED_FindField(), PRVM_ED_FindFunction(), PRVM_ED_FindGlobal(), PRVM_EDICT_NUM, PRVM_EDICTFIELDVALUE, PRVM_GLOBALFIELDVALUE, prvm_prog_list, mdef_t::type, debug_data_t::watch_edict, prvm_prog_t::watch_edict, prvm_prog_t::watch_edictfield_value, debug_data_t::watch_field, prvm_prog_t::watch_field, prvm_prog_t::watch_field_type, debug_data_t::watch_global, prvm_prog_t::watch_global, prvm_prog_t::watch_global_type, and prvm_prog_t::watch_global_value.

Referenced by PRVM_Breakpoint_f(), PRVM_EdictWatchpoint_f(), PRVM_GlobalWatchpoint_f(), and PRVM_Prog_Load().

PRVM_ValueString()

static char * PRVM_ValueString ( prvm_prog_t * prog, etype_t type, prvm_eval_t * val, char * line, size_t linelength )

static

Definition at line 447 of file prvm_edict.c.

{
    mdef_t *def;
    mfunction_t *f;
    int n;
 
    type = (etype_t)((int) type & ~DEF_SAVEGLOBAL);
 
    switch (type)
    {
    case ev_string:
        dp_strlcpy (line, PRVM_GetString (prog, val->string), linelength);
        break;
    case ev_entity:
        n = val->edict;
        if (n < 0 || n >= prog->max_edicts)
            dpsnprintf (line, linelength, "entity %i (invalid!)", n);
        else
            dpsnprintf (line, linelength, "entity %i", n);
        break;
    case ev_function:
        if ((unsigned int)val->function < (unsigned int)prog->progs_numfunctions)
        {
            f = prog->functions + val->function;
            dpsnprintf (line, linelength, "%s()", PRVM_GetString(prog, f->s_name));
        }
        else
            dpsnprintf (line, linelength, "function %" PRVM_PRIi "() (invalid!)", val->function);
        break;
    case ev_field:
        def = PRVM_ED_FieldAtOfs ( prog, val->_int );
        if (def != NULL)
            dpsnprintf (line, linelength, ".%s", PRVM_GetString(prog, def->s_name));
        else
            dpsnprintf (line, linelength, "field %" PRVM_PRIi " (invalid!)", val->_int );
        break;
    case ev_void:
        dpsnprintf (line, linelength, "void");
        break;
    case ev_float:
        // LadyHavoc: changed from %5.1f to %10.4f
        dpsnprintf (line, linelength, PRVM_FLOAT_LOSSLESS_FORMAT, val->_float);
        break;
    case ev_vector:
        // LadyHavoc: changed from %5.1f to %10.4f
        dpsnprintf (line, linelength, "'" PRVM_VECTOR_LOSSLESS_FORMAT "'", val->vector[0], val->vector[1], val->vector[2]);
        break;
    case ev_pointer:
        dpsnprintf (line, linelength, "pointer");
        break;
    default:
        dpsnprintf (line, linelength, "bad type %i", (int) type);
        break;
    }
 
    return line;
}

References prvm_eval_t::_float, prvm_eval_t::_int, DEF_SAVEGLOBAL, dp_strlcpy, dpsnprintf(), prvm_eval_t::edict, ev_entity, ev_field, ev_float, ev_function, ev_pointer, ev_string, ev_vector, ev_void, f, prvm_eval_t::function, prvm_prog_t::functions, prvm_prog_t::max_edicts, n, NULL, prvm_prog_t::progs_numfunctions, PRVM_ED_FieldAtOfs(), PRVM_FLOAT_LOSSLESS_FORMAT, PRVM_GetString(), PRVM_PRIi, PRVM_VECTOR_LOSSLESS_FORMAT, mdef_t::s_name, prvm_eval_t::string, type, and prvm_eval_t::vector.

Referenced by PRVM_ED_Print(), PRVM_Global_f(), and PRVM_GlobalString().

PRVM_Watchpoint()

void PRVM_Watchpoint	(	prvm_prog_t *	prog,
		int	stack_index,
		const char *	text,
		etype_t	type,
		prvm_eval_t *	o,
		prvm_eval_t *	n )

Definition at line 3009 of file prvm_edict.c.

{
    size_t sz = sizeof(prvm_vec_t) * ((type & ~DEF_SAVEGLOBAL) == ev_vector ? 3 : 1);
    if (memcmp(o, n, sz))
    {
        char buf[1024];
        char valuebuf_o[128];
        char valuebuf_n[128];
        PRVM_UglyValueString(prog, type, o, valuebuf_o, sizeof(valuebuf_o));
        PRVM_UglyValueString(prog, type, n, valuebuf_n, sizeof(valuebuf_n));
        dpsnprintf(buf, sizeof(buf), "%s: %s -> %s", text, valuebuf_o, valuebuf_n);
        PRVM_Breakpoint(prog, stack_index, buf);
        memcpy(o, n, sz);
    }
}

References buf, DEF_SAVEGLOBAL, dpsnprintf(), ev_vector, n, PRVM_Breakpoint(), PRVM_UglyValueString(), and type.

Referenced by while().

Variable Documentation

debug_data

debug_data_t debug_data[PRVM_PROG_MAX]

static

Definition at line 2998 of file prvm_edict.c.

Referenced by PRVM_Breakpoint_f(), PRVM_EdictWatchpoint_f(), PRVM_GlobalWatchpoint_f(), and PRVM_UpdateBreakpoints().

prvm_backtraceforwarnings

cvar_t prvm_backtraceforwarnings = {CF_CLIENT | CF_SERVER, "prvm_backtraceforwarnings", "0", "print a backtrace for warnings too"}

Definition at line 40 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_backtraceforwarnings", "0", "print a backtrace for warnings too"};

Referenced by PRVM_Init(), and VM_Warning().

prvm_badvalue

prvm_eval_t prvm_badvalue

Definition at line 31 of file prvm_edict.c.

prvm_breakpointdump

cvar_t prvm_breakpointdump = {CF_CLIENT | CF_SERVER, "prvm_breakpointdump", "0", "write a savegame on breakpoint to breakpoint-server.dmp"}

Definition at line 45 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_breakpointdump", "0", "write a savegame on breakpoint to breakpoint-server.dmp"};

Referenced by PRVM_Breakpoint(), and PRVM_Init().

prvm_coverage

cvar_t prvm_coverage = {CF_CLIENT | CF_SERVER, "prvm_coverage", "0", "report and count coverage events (1: per-function, 2: coverage() builtin, 4: per-statement)"}

Definition at line 39 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_coverage", "0", "report and count coverage events (1: per-function, 2: coverage() builtin, 4: per-statement)"};

Referenced by CLVM_ExecuteProgram(), PRVM_ChildProfile_f(), PRVM_Init(), PRVM_PrintFunctionStatements(), PRVM_Profile_f(), SVVM_ExecuteProgram(), VM_coverage(), and while().

prvm_errordump

cvar_t prvm_errordump = {CF_CLIENT | CF_SERVER, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"}

Definition at line 44 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"};

Referenced by PRVM_Crash(), and PRVM_Init().

prvm_gameplayfix_div0is0

cvar_t prvm_gameplayfix_div0is0 = {CF_SERVER, "prvm_gameplayfix_div0is0", "0", "When set to 1, floating point division by 0 will return zero instead of returning the IEEE standardized result (likely nan or inf). Other ways of getting non-finite values are not affected, and the warning will still print."}

Definition at line 57 of file prvm_edict.c.

{CF_SERVER, "prvm_gameplayfix_div0is0", "0", "When set to 1, floating point division by 0 will return zero instead of returning the IEEE standardized result (likely nan or inf). Other ways of getting non-finite values are not affected, and the warning will still print."};

Referenced by PRVM_Init(), and while().

prvm_garbagecollection_enable

cvar_t prvm_garbagecollection_enable = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_enable", "1", "automatically scan for and free resources that are not referenced by the code being executed in the VM"}

Definition at line 48 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_garbagecollection_enable", "1", "automatically scan for and free resources that are not referenced by the code being executed in the VM"};

Referenced by PRVM_GarbageCollection(), PRVM_Init(), and while().

prvm_garbagecollection_notify

cvar_t prvm_garbagecollection_notify = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_notify", "0", "print out a notification for each resource freed by garbage collection (set developer >= 1 to see these)"}

Definition at line 49 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_garbagecollection_notify", "0", "print out a notification for each resource freed by garbage collection (set developer >= 1 to see these)"};

Referenced by PRVM_GarbageCollection(), and PRVM_Init().

prvm_garbagecollection_scan_limit

cvar_t prvm_garbagecollection_scan_limit = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_scan_limit", "50000", "scan this many fields or resources per second to free up unreferenced resources"}

At 50k in Xonotic with 8 bots scans take about: 24s server, 25s menu, 9s client.

At 50k in Quake 1.5: 2.2s server, 0.14s client. At 50k impact on high FPS benchmarks is negligible, at 100k impact is low but measurable.

Definition at line 53 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_garbagecollection_scan_limit", "50000", "scan this many fields or resources per second to free up unreferenced resources"};

Referenced by PRVM_GarbageCollection(), and PRVM_Init().

prvm_garbagecollection_strings

cvar_t prvm_garbagecollection_strings = {CF_CLIENT | CF_SERVER, "prvm_garbagecollection_strings", "1", "automatically call strunzone() on strings that are not referenced"}

Definition at line 54 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_garbagecollection_strings", "1", "automatically call strunzone() on strings that are not referenced"};

Referenced by PRVM_GarbageCollection(), and PRVM_Init().

prvm_language

cvar_t prvm_language = {CF_CLIENT | CF_SERVER | CF_ARCHIVE, "prvm_language", "", "when set, loads PROGSFILE.LANGUAGENAME.po and common.LANGUAGENAME.po for string translations; when set to dump, PROGSFILE.pot is written from the strings in the progs"}

Definition at line 33 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER | CF_ARCHIVE, "prvm_language", "", "when set, loads PROGSFILE.LANGUAGENAME.po and common.LANGUAGENAME.po for string translations; when set to dump, PROGSFILE.pot is written from the strings in the progs"};

Referenced by PRVM_Init(), and PRVM_Prog_Load().

prvm_leaktest

cvar_t prvm_leaktest = {CF_CLIENT | CF_SERVER, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"}

Definition at line 41 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"};

Referenced by PRVM_Init(), and PRVM_Prog_Init().

prvm_leaktest_follow_targetname

cvar_t prvm_leaktest_follow_targetname = {CF_CLIENT | CF_SERVER, "prvm_leaktest_follow_targetname", "0", "if set, target/targetname links are considered when leak testing; this should normally not be required, as entities created during startup - e.g. info_notnull - are never considered leaky"}

Definition at line 42 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_leaktest_follow_targetname", "0", "if set, target/targetname links are considered when leak testing; this should normally not be required, as entities created during startup - e.g. info_notnull - are never considered leaky"};

Referenced by PRVM_Init(), and PRVM_IsEdictReferenced().

prvm_leaktest_ignore_classnames

cvar_t prvm_leaktest_ignore_classnames = {CF_CLIENT | CF_SERVER, "prvm_leaktest_ignore_classnames", "", "classnames of entities to NOT leak check because they are found by find(world, classname, ...) but are actually spawned by QC code (NOT map entities)"}

Definition at line 43 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_leaktest_ignore_classnames", "", "classnames of entities to NOT leak check because they are found by find(world, classname, ...) but are actually spawned by QC code (NOT map entities)"};

Referenced by PRVM_Init(), and PRVM_IsEdictRelevant().

prvm_prog_list

prvm_prog_t prvm_prog_list[PRVM_PROG_MAX]

Definition at line 27 of file prvm_edict.c.

Referenced by Cvar_IsAutoCvar(), Cvar_UpdateAutoCvar(), PRVM_Breakpoint_f(), PRVM_EdictWatchpoint_f(), PRVM_GlobalWatchpoint_f(), PRVM_Prog_Load(), and PRVM_UpdateBreakpoints().

prvm_reuseedicts_always_allow

double prvm_reuseedicts_always_allow = 0

static

Definition at line 59 of file prvm_edict.c.

Referenced by PRVM_ED_CanAlloc(), and PRVM_ED_LoadFromFile().

prvm_reuseedicts_neverinsameframe

cvar_t prvm_reuseedicts_neverinsameframe = {CF_CLIENT | CF_SERVER, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"}

Definition at line 47 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"};

Referenced by PRVM_ED_CanAlloc(), and PRVM_Init().

prvm_reuseedicts_startuptime

cvar_t prvm_reuseedicts_startuptime = {CF_CLIENT | CF_SERVER, "prvm_reuseedicts_startuptime", "2", "allows immediate re-use of freed entity slots during start of new level (value in seconds)"}

Definition at line 46 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_reuseedicts_startuptime", "2", "allows immediate re-use of freed entity slots during start of new level (value in seconds)"};

Referenced by PRVM_ED_CanAlloc(), and PRVM_Init().

prvm_runawaycheck

qbool prvm_runawaycheck = true

Definition at line 60 of file prvm_edict.c.

Referenced by Cbuf_Execute(), PRVM_Init(), and while().

prvm_statementprofiling

cvar_t prvm_statementprofiling = {CF_CLIENT | CF_SERVER, "prvm_statementprofiling", "0", "counts how many times each QuakeC statement has been executed, these counts are displayed in prvm_printfunction output (if enabled)"}

Definition at line 37 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_statementprofiling", "0", "counts how many times each QuakeC statement has been executed, these counts are displayed in prvm_printfunction output (if enabled)"};

Referenced by PRVM_Init(), and PRVM_PrintStatement().

prvm_stringdebug

cvar_t prvm_stringdebug = {CF_CLIENT | CF_SERVER, "prvm_stringdebug", "0", "Print debug and warning messages related to strings"}

Definition at line 55 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_stringdebug", "0", "Print debug and warning messages related to strings"};

Referenced by PRVM_GetString(), and PRVM_Init().

prvm_timeprofiling

cvar_t prvm_timeprofiling = {CF_CLIENT | CF_SERVER, "prvm_timeprofiling", "0", "counts how long each function has been executed, these counts are displayed in prvm_profile output (if enabled)"}

Definition at line 38 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_timeprofiling", "0", "counts how long each function has been executed, these counts are displayed in prvm_profile output (if enabled)"};

Referenced by CLVM_ExecuteProgram(), PRVM_Init(), PRVM_Profile(), and SVVM_ExecuteProgram().

prvm_traceqc

cvar_t prvm_traceqc = {CF_CLIENT | CF_SERVER, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"}

Definition at line 35 of file prvm_edict.c.

{CF_CLIENT | CF_SERVER, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"};

Referenced by CLVM_ExecuteProgram(), PRVM_Init(), and SVVM_ExecuteProgram().

prvm_type_size

int prvm_type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4}

for consistency : I think a goal of this sub-project is to make the new vm mostly independent from the old one, thus if it's necessary, I copy everything

Definition at line 29 of file prvm_edict.c.

{1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4};

Referenced by PRVM_ED_Print(), PRVM_ED_Write(), PRVM_Fields_f(), and VM_getentityfieldstring().

sv_entfields_noescapes

cvar_t sv_entfields_noescapes = {CF_SERVER, "sv_entfields_noescapes", "wad", "Space-separated list of fields in which backslashes won't be parsed as escapes when loading entities from .bsp or .ent files. This is a workaround for buggy maps with unescaped backslashes used as path separators (only forward slashes are allowed in Quake VFS paths)."}

Definition at line 56 of file prvm_edict.c.

{CF_SERVER, "sv_entfields_noescapes", "wad", "Space-separated list of fields in which backslashes won't be parsed as escapes when loading entities from .bsp or .ent files. This is a workaround for buggy maps with unescaped backslashes used as path separators (only forward slashes are allowed in Quake VFS paths)."};

Referenced by PRVM_ED_ParseEdict(), and PRVM_Init().