#include "quakedef.h"
dprograms_t *progs;
-mfunction_t *pr_functions;
+mfunction_t *prog->functions;
char *pr_strings;
+int pr_stringssize;
ddef_t *pr_fielddefs;
ddef_t *pr_globaldefs;
dstatement_t *pr_statements;
globalvars_t *pr_global_struct;
float *pr_globals; // same as pr_global_struct
-int pr_edict_size; // in bytes
+int prog->edict_size; // in bytes
int pr_edictareasize; // LordHavoc: in bytes
+int pr_maxknownstrings;
+int pr_numknownstrings;
+const char **pr_knownstrings;
+
unsigned short pr_crc;
-mempool_t *progs_mempool;
-mempool_t *edictstring_mempool;
+mempool_t *serverprogs_mempool;
int type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4};
ddef_t *ED_FieldAtOfs(int ofs);
-qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s);
+qboolean ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s);
cvar_t pr_checkextension = {CVAR_READONLY, "pr_checkextension", "1"};
cvar_t nomonsters = {0, "nomonsters", "0"};
// LordHavoc: prints every opcode as it executes - warning: this is significant spew
cvar_t pr_traceqc = {0, "pr_traceqc", "0"};
-#define MAX_FIELD_LEN 64
-#define GEFV_CACHESIZE 2
-
-typedef struct {
- ddef_t *pcache;
- char field[MAX_FIELD_LEN];
-} gefv_cache;
-
-static gefv_cache gefvCache[GEFV_CACHESIZE] = {{NULL, ""}, {NULL, ""}};
-
ddef_t *ED_FindField (const char *name);
-mfunction_t *ED_FindFunction (const char *name);
+mfunction_t *PRVM_ED_FindFunction (const char *name);
// LordHavoc: in an effort to eliminate time wasted on GetEdictFieldValue... these are defined as externs in progs.h
int eval_gravity;
int eval_button6;
int eval_button7;
int eval_button8;
+int eval_buttonuse;
+int eval_buttonchat;
int eval_glow_size;
int eval_glow_trail;
int eval_glow_color;
int eval_color;
int eval_style;
int eval_pflags;
+int eval_cursor_active;
+int eval_cursor_screen;
+int eval_cursor_trace_start;
+int eval_cursor_trace_endpos;
+int eval_cursor_trace_ent;
+int eval_colormod;
+int eval_playermodel;
+int eval_playerskin;
mfunction_t *SV_PlayerPhysicsQC;
mfunction_t *EndFrameQC;
eval_button6 = FindFieldOffset("button6");
eval_button7 = FindFieldOffset("button7");
eval_button8 = FindFieldOffset("button8");
+ eval_buttonuse = FindFieldOffset("buttonuse");
+ eval_buttonchat = FindFieldOffset("buttonchat");
eval_glow_size = FindFieldOffset("glow_size");
eval_glow_trail = FindFieldOffset("glow_trail");
eval_glow_color = FindFieldOffset("glow_color");
eval_color = FindFieldOffset("color");
eval_style = FindFieldOffset("style");
eval_pflags = FindFieldOffset("pflags");
+ eval_cursor_active = FindFieldOffset("cursor_active");
+ eval_cursor_screen = FindFieldOffset("cursor_screen");
+ eval_cursor_trace_start = FindFieldOffset("cursor_trace_start");
+ eval_cursor_trace_endpos = FindFieldOffset("cursor_trace_endpos");
+ eval_cursor_trace_ent = FindFieldOffset("cursor_trace_ent");
+ eval_colormod = FindFieldOffset("colormod");
+ eval_playermodel = FindFieldOffset("playermodel");
+ eval_playerskin = FindFieldOffset("playerskin");
// LordHavoc: allowing QuakeC to override the player movement code
- SV_PlayerPhysicsQC = ED_FindFunction ("SV_PlayerPhysics");
+ SV_PlayerPhysicsQC = PRVM_ED_FindFunction ("SV_PlayerPhysics");
// LordHavoc: support for endframe
- EndFrameQC = ED_FindFunction ("EndFrame");
+ EndFrameQC = PRVM_ED_FindFunction ("EndFrame");
//KrimZon - SERVER COMMANDS IN QUAKEC
- SV_ParseClientCommandQC = ED_FindFunction ("SV_ParseClientCommand");
+ SV_ParseClientCommandQC = PRVM_ED_FindFunction ("SV_ParseClientCommand");
}
/*
Sets everything to NULL
=================
*/
-void ED_ClearEdict (edict_t *e)
+void ED_ClearEdict (prvm_edict_t *e)
{
int num;
memset (e->v, 0, progs->entityfields * 4);
- e->e->free = false;
+ e->priv.server->free = false;
// LordHavoc: for consistency set these here
- num = NUM_FOR_EDICT(e) - 1;
+ num = PRVM_NUM_FOR_EDICT(e) - 1;
if (num >= 0 && num < svs.maxclients)
{
- e->v->colormap = num + 1;
- e->v->team = (svs.clients[num].colors & 15) + 1;
- e->v->netname = PR_SetString(svs.clients[num].name);
+ prvm_eval_t *val;
+ // set colormap and team on newly created player entity
+ e->fields.server->colormap = num + 1;
+ e->fields.server->team = (svs.clients[num].colors & 15) + 1;
+ // set netname/clientcolors back to client values so that
+ // DP_SV_CLIENTNAME and DPV_SV_CLIENTCOLORS will not immediately
+ // reset them
+ e->fields.server->netname = PRVM_SetEngineString(svs.clients[num].name);
+ if ((val = PRVM_GETEDICTFIELDVALUE(e, eval_clientcolors)))
+ val->_float = svs.clients[num].colors;
+ // NEXUIZ_PLAYERMODEL and NEXUIZ_PLAYERSKIN
+ if( eval_playermodel )
+ PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PRVM_SetEngineString(svs.clients[num].playermodel);
+ if( eval_playerskin )
+ PRVM_GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PRVM_SetEngineString(svs.clients[num].playerskin);
}
}
angles and bad trails.
=================
*/
-edict_t *ED_Alloc (void)
+prvm_edict_t *ED_Alloc (void)
{
int i;
- edict_t *e;
+ prvm_edict_t *e;
- for (i = svs.maxclients + 1;i < sv.num_edicts;i++)
+ for (i = svs.maxclients + 1;i < prog->num_edicts;i++)
{
- e = EDICT_NUM(i);
+ e = PRVM_EDICT_NUM(i);
// the first couple seconds of server time can involve a lot of
// freeing and allocating, so relax the replacement policy
- if (e->e->free && ( e->e->freetime < 2 || sv.time - e->e->freetime > 0.5 ) )
+ if (e->priv.server->free && ( e->priv.server->freetime < 2 || sv.time - e->priv.server->freetime > 0.5 ) )
{
ED_ClearEdict (e);
return e;
if (i == MAX_EDICTS)
Host_Error ("ED_Alloc: no free edicts");
- sv.num_edicts++;
- if (sv.num_edicts >= sv.max_edicts)
+ prog->num_edicts++;
+ if (prog->num_edicts >= prog->max_edicts)
SV_IncreaseEdicts();
- e = EDICT_NUM(i);
+ e = PRVM_EDICT_NUM(i);
ED_ClearEdict (e);
return e;
FIXME: walk all entities and NULL out references to this entity
=================
*/
-void ED_Free (edict_t *ed)
+void ED_Free (prvm_edict_t *ed)
{
SV_UnlinkEdict (ed); // unlink from world bsp
- ed->e->free = true;
- ed->v->model = 0;
- ed->v->takedamage = 0;
- ed->v->modelindex = 0;
- ed->v->colormap = 0;
- ed->v->skin = 0;
- ed->v->frame = 0;
- VectorClear(ed->v->origin);
- VectorClear(ed->v->angles);
- ed->v->nextthink = -1;
- ed->v->solid = 0;
-
- ed->e->freetime = sv.time;
+ ed->priv.server->free = true;
+ ed->fields.server->model = 0;
+ ed->fields.server->takedamage = 0;
+ ed->fields.server->modelindex = 0;
+ ed->fields.server->colormap = 0;
+ ed->fields.server->skin = 0;
+ ed->fields.server->frame = 0;
+ VectorClear(ed->fields.server->origin);
+ VectorClear(ed->fields.server->angles);
+ ed->fields.server->nextthink = -1;
+ ed->fields.server->solid = 0;
+
+ ed->priv.server->freetime = sv.time;
}
//===========================================================================
for (i=0 ; i<progs->numfielddefs ; i++)
{
def = &pr_fielddefs[i];
- if (!strcmp(PR_GetString(def->s_name), name))
+ if (!strcmp(PRVM_GetString(def->s_name), name))
return def;
}
return NULL;
for (i=0 ; i<progs->numglobaldefs ; i++)
{
def = &pr_globaldefs[i];
- if (!strcmp(PR_GetString(def->s_name), name))
+ if (!strcmp(PRVM_GetString(def->s_name), name))
return def;
}
return NULL;
/*
============
-ED_FindFunction
+PRVM_ED_FindFunction
============
*/
-mfunction_t *ED_FindFunction (const char *name)
+mfunction_t *PRVM_ED_FindFunction (const char *name)
{
mfunction_t *func;
int i;
for (i=0 ; i<progs->numfunctions ; i++)
{
- func = &pr_functions[i];
- if (!strcmp(PR_GetString(func->s_name), name))
+ func = &prog->functions[i];
+ if (!strcmp(PRVM_GetString(func->s_name), name))
return func;
}
return NULL;
Returns a string describing *data in a type specific manner
=============
*/
-//int NoCrash_NUM_FOR_EDICT(edict_t *e);
-char *PR_ValueString (etype_t type, eval_t *val)
+//int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e);
+char *PR_ValueString (etype_t type, prvm_eval_t *val)
{
static char line[1024]; // LordHavoc: enlarged a bit (was 256)
ddef_t *def;
switch (type)
{
case ev_string:
- strlcpy (line, PR_GetString (val->string), sizeof (line));
+ strlcpy (line, PRVM_GetString (val->string), sizeof (line));
break;
case ev_entity:
- //n = NoCrash_NUM_FOR_EDICT(PROG_TO_EDICT(val->edict));
+ //n = NoCrash_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict));
n = val->edict;
if (n < 0 || n >= MAX_EDICTS)
- snprintf (line, sizeof (line), "entity %i (invalid!)", n);
+ dpsnprintf (line, sizeof (line), "entity %i (invalid!)", n);
else
- snprintf (line, sizeof (line), "entity %i", n);
+ dpsnprintf (line, sizeof (line), "entity %i", n);
break;
case ev_function:
- f = pr_functions + val->function;
- snprintf (line, sizeof (line), "%s()", PR_GetString(f->s_name));
+ f = prog->functions + val->function;
+ dpsnprintf (line, sizeof (line), "%s()", PRVM_GetString(f->s_name));
break;
case ev_field:
def = ED_FieldAtOfs ( val->_int );
- snprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name));
+ dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name));
break;
case ev_void:
- snprintf (line, sizeof (line), "void");
+ dpsnprintf (line, sizeof (line), "void");
break;
case ev_float:
// LordHavoc: changed from %5.1f to %10.4f
- snprintf (line, sizeof (line), "%10.4f", val->_float);
+ dpsnprintf (line, sizeof (line), "%10.4f", val->_float);
break;
case ev_vector:
// LordHavoc: changed from %5.1f to %10.4f
- snprintf (line, sizeof (line), "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]);
+ dpsnprintf (line, sizeof (line), "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]);
break;
case ev_pointer:
- snprintf (line, sizeof (line), "pointer");
+ dpsnprintf (line, sizeof (line), "pointer");
break;
default:
- snprintf (line, sizeof (line), "bad type %i", type);
+ dpsnprintf (line, sizeof (line), "bad type %i", type);
break;
}
Easier to parse than PR_ValueString
=============
*/
-char *PR_UglyValueString (etype_t type, eval_t *val)
+char *PR_UglyValueString (etype_t type, prvm_eval_t *val)
{
static char line[4096];
int i;
- char *s;
+ const char *s;
ddef_t *def;
mfunction_t *f;
// Parse the string a bit to turn special characters
// (like newline, specifically) into escape codes,
// this fixes saving games from various mods
- s = PR_GetString (val->string);
+ s = PRVM_GetString (val->string);
for (i = 0;i < (int)sizeof(line) - 2 && *s;)
{
if (*s == '\n')
line[i] = '\0';
break;
case ev_entity:
- snprintf (line, sizeof (line), "%i", NUM_FOR_EDICT(PROG_TO_EDICT(val->edict)));
+ dpsnprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict)));
break;
case ev_function:
- f = pr_functions + val->function;
- strlcpy (line, PR_GetString (f->s_name), sizeof (line));
+ f = prog->functions + val->function;
+ strlcpy (line, PRVM_GetString (f->s_name), sizeof (line));
break;
case ev_field:
def = ED_FieldAtOfs ( val->_int );
- snprintf (line, sizeof (line), ".%s", PR_GetString(def->s_name));
+ dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name));
break;
case ev_void:
- snprintf (line, sizeof (line), "void");
+ dpsnprintf (line, sizeof (line), "void");
break;
case ev_float:
- snprintf (line, sizeof (line), "%f", val->_float);
+ dpsnprintf (line, sizeof (line), "%f", val->_float);
break;
case ev_vector:
- snprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
+ dpsnprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
break;
default:
- snprintf (line, sizeof (line), "bad type %i", type);
+ dpsnprintf (line, sizeof (line), "bad type %i", type);
break;
}
val = (void *)&pr_globals[ofs];
def = ED_GlobalAtOfs(ofs);
if (!def)
- snprintf (line, sizeof (line), "%i(?)", ofs);
+ dpsnprintf (line, sizeof (line), "%i(?)", ofs);
else
{
s = PR_ValueString (def->type, val);
- snprintf (line, sizeof (line), "%i(%s)%s", ofs, PR_GetString(def->s_name), s);
+ dpsnprintf (line, sizeof (line), "%i(%s)%s", ofs, PRVM_GetString(def->s_name), s);
}
i = strlen(line);
def = ED_GlobalAtOfs(ofs);
if (!def)
- snprintf (line, sizeof (line), "%i(?)", ofs);
+ dpsnprintf (line, sizeof (line), "%i(?)", ofs);
else
- snprintf (line, sizeof (line), "%i(%s)", ofs, PR_GetString(def->s_name));
+ dpsnprintf (line, sizeof (line), "%i(%s)", ofs, PRVM_GetString(def->s_name));
i = strlen(line);
for ( ; i<20 ; i++)
*/
// LordHavoc: optimized this to print out much more quickly (tempstring)
// LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print)
-void ED_Print(edict_t *ed)
+void ED_Print(prvm_edict_t *ed)
{
int l;
ddef_t *d;
int *v;
int i, j;
- char *name;
+ const char *name;
int type;
char tempstring[8192], tempstring2[260]; // temporary string buffers
- if (ed->e->free)
+ if (ed->priv.server->free)
{
Con_Print("FREE\n");
return;
}
tempstring[0] = 0;
- snprintf (tempstring, sizeof (tempstring), "\nEDICT %i:\n", NUM_FOR_EDICT(ed));
+ dpsnprintf (tempstring, sizeof (tempstring), "\nEDICT %i:\n", PRVM_NUM_FOR_EDICT(ed));
for (i=1 ; i<progs->numfielddefs ; i++)
{
d = &pr_fielddefs[i];
- name = PR_GetString(d->s_name);
+ name = PRVM_GetString(d->s_name);
if (name[strlen(name)-2] == '_')
continue; // skip _x, _y, _z vars
strcat(tempstring, " ");
strcat(tempstring, " ");
- name = PR_ValueString(d->type, (eval_t *)v);
+ name = PR_ValueString(d->type, (prvm_eval_t *)v);
if (strlen(name) > 256)
{
memcpy(tempstring2, name, 256);
For savegames
=============
*/
-void ED_Write (qfile_t *f, edict_t *ed)
+void ED_Write (qfile_t *f, prvm_edict_t *ed)
{
ddef_t *d;
int *v;
int i, j;
- char *name;
+ const char *name;
int type;
FS_Print(f, "{\n");
- if (ed->e->free)
+ if (ed->priv.server->free)
{
FS_Print(f, "}\n");
return;
for (i=1 ; i<progs->numfielddefs ; i++)
{
d = &pr_fielddefs[i];
- name = PR_GetString(d->s_name);
+ name = PRVM_GetString(d->s_name);
if (name[strlen(name)-2] == '_')
continue; // skip _x, _y, _z vars
continue;
FS_Printf(f,"\"%s\" ",name);
- FS_Printf(f,"\"%s\"\n", PR_UglyValueString(d->type, (eval_t *)v));
+ FS_Printf(f,"\"%s\"\n", PR_UglyValueString(d->type, (prvm_eval_t *)v));
}
FS_Print(f, "}\n");
void ED_PrintNum (int ent)
{
- ED_Print(EDICT_NUM(ent));
+ ED_Print(PRVM_EDICT_NUM(ent));
}
/*
{
int i;
- Con_Printf("%i entities\n", sv.num_edicts);
- for (i=0 ; i<sv.num_edicts ; i++)
+ Con_Printf("%i entities\n", prog->num_edicts);
+ for (i=0 ; i<prog->num_edicts ; i++)
ED_PrintNum (i);
}
int i;
i = atoi (Cmd_Argv(1));
- if (i < 0 || i >= sv.num_edicts)
+ if (i < 0 || i >= prog->num_edicts)
{
Con_Print("Bad edict number\n");
return;
void ED_Count (void)
{
int i;
- edict_t *ent;
+ prvm_edict_t *ent;
int active, models, solid, step;
active = models = solid = step = 0;
- for (i=0 ; i<sv.num_edicts ; i++)
+ for (i=0 ; i<prog->num_edicts ; i++)
{
- ent = EDICT_NUM(i);
- if (ent->e->free)
+ ent = PRVM_EDICT_NUM(i);
+ if (ent->priv.server->free)
continue;
active++;
- if (ent->v->solid)
+ if (ent->fields.server->solid)
solid++;
- if (ent->v->model)
+ if (ent->fields.server->model)
models++;
- if (ent->v->movetype == MOVETYPE_STEP)
+ if (ent->fields.server->movetype == MOVETYPE_STEP)
step++;
}
- Con_Printf("num_edicts:%3i\n", sv.num_edicts);
+ Con_Printf("num_edicts:%3i\n", prog->num_edicts);
Con_Printf("active :%3i\n", active);
Con_Printf("view :%3i\n", models);
Con_Printf("touch :%3i\n", solid);
{
ddef_t *def;
int i;
- char *name;
+ const char *name;
int type;
FS_Print(f,"{\n");
if (type != ev_string && type != ev_float && type != ev_entity)
continue;
- name = PR_GetString(def->s_name);
+ name = PRVM_GetString(def->s_name);
FS_Printf(f,"\"%s\" ", name);
- FS_Printf(f,"\"%s\"\n", PR_UglyValueString(type, (eval_t *)&pr_globals[def->ofs]));
+ FS_Printf(f,"\"%s\"\n", PR_UglyValueString(type, (prvm_eval_t *)&pr_globals[def->ofs]));
}
FS_Print(f,"}\n");
}
*/
void ED_EdictSet_f(void)
{
- edict_t *ed;
+ prvm_edict_t *ed;
ddef_t *key;
if(Cmd_Argc() != 4)
Con_Print("edictset <edict number> <field> <value>\n");
return;
}
- ed = EDICT_NUM(atoi(Cmd_Argv(1)));
+ ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(1)));
if((key = ED_FindField(Cmd_Argv(2))) == 0)
{
//============================================================================
-/*
-=============
-ED_NewString
-=============
-*/
-char *ED_NewString (const char *string)
-{
- char *new, *new_p;
- int i,l;
-
- l = strlen(string) + 1;
- new = Mem_Alloc(edictstring_mempool, l);
- new_p = new;
-
- for (i=0 ; i< l ; i++)
- {
- if (string[i] == '\\' && i < l-1)
- {
- i++;
- if (string[i] == 'n')
- *new_p++ = '\n';
- else
- *new_p++ = '\\';
- }
- else
- *new_p++ = string[i];
- }
-
- return new;
-}
-
-
/*
=============
ED_ParseEval
returns false if error
=============
*/
-qboolean ED_ParseEpair(edict_t *ent, ddef_t *key, const char *s)
+qboolean ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
{
- int i;
+ int i, l;
+ char *new_p;
ddef_t *def;
- eval_t *val;
+ prvm_eval_t *val;
mfunction_t *func;
if (ent)
- val = (eval_t *)((int *)ent->v + key->ofs);
+ val = (prvm_eval_t *)((int *)ent->v + key->ofs);
else
- val = (eval_t *)((int *)pr_globals + key->ofs);
+ val = (prvm_eval_t *)((int *)pr_globals + key->ofs);
switch (key->type & ~DEF_SAVEGLOBAL)
{
case ev_string:
- val->string = PR_SetString(ED_NewString(s));
+ l = strlen(s) + 1;
+ new_p = PR_AllocString(l);
+ val->string = PR_SetQCString(new_p);
+ for (i = 0;i < l;i++)
+ {
+ if (s[i] == '\\' && i < l-1)
+ {
+ 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:
i = atoi(s);
if (i < 0 || i >= MAX_EDICTS)
Con_Printf("ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i)\n", i, MAX_EDICTS);
- while (i >= sv.max_edicts)
+ while (i >= prog->max_edicts)
SV_IncreaseEdicts();
// if SV_IncreaseEdicts was called the base pointer needs to be updated
if (ent)
- val = (eval_t *)((int *)ent->v + key->ofs);
- val->edict = EDICT_TO_PROG(EDICT_NUM(i));
+ val = (prvm_eval_t *)((int *)ent->v + key->ofs);
+ val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM(i));
break;
case ev_field:
Con_DPrintf("ED_ParseEpair: Can't find field %s\n", s);
return false;
}
- val->_int = G_INT(def->ofs);
+ //val->_int = PRVM_G_INT(def->ofs); // AK Please check this - seems to be an org. quake bug
+ val->_int = def->ofs;
break;
case ev_function:
- func = ED_FindFunction(s);
+ func = PRVM_ED_FindFunction(s);
if (!func)
{
Con_Printf("ED_ParseEpair: Can't find function %s\n", s);
return false;
}
- val->function = func - pr_functions;
+ val->function = func - prog->functions;
break;
default:
- Con_Printf("ED_ParseEpair: Unknown key->type %i for key \"%s\"\n", key->type, PR_GetString(key->s_name));
+ Con_Printf("ED_ParseEpair: Unknown key->type %i for key \"%s\"\n", key->type, PRVM_GetString(key->s_name));
return false;
}
return true;
Used for initial level load and for savegames.
====================
*/
-const char *ED_ParseEdict (const char *data, edict_t *ent)
+const char *ED_ParseEdict (const char *data, prvm_edict_t *ent)
{
ddef_t *key;
qboolean anglehack;
init = false;
// clear it
- if (ent != sv.edicts) // hack
+ if (ent != prog->edicts) // hack
memset (ent->v, 0, progs->entityfields * 4);
// go through all the dictionary pairs
{
char temp[32];
strlcpy (temp, com_token, sizeof (temp));
- snprintf (com_token, sizeof (com_token), "0 %s 0", temp);
+ dpsnprintf (com_token, sizeof (com_token), "0 %s 0", temp);
}
if (!ED_ParseEpair(ent, key, com_token))
}
if (!init)
- ent->e->free = true;
+ ent->priv.server->free = true;
return data;
}
*/
void ED_LoadFromFile (const char *data)
{
- edict_t *ent;
+ prvm_edict_t *ent;
int parsed, inhibited, spawned, died;
mfunction_t *func;
inhibited = 0;
spawned = 0;
died = 0;
- pr_global_struct->time = sv.time;
+ prog->globals.server->time = sv.time;
// parse ents
while (1)
Host_Error ("ED_LoadFromFile: found %s when expecting {",com_token);
if (!ent)
- ent = EDICT_NUM(0);
+ ent = PRVM_EDICT_NUM(0);
else
ent = ED_Alloc ();
data = ED_ParseEdict (data, ent);
parsed++;
// remove things from different skill levels or deathmatch
- if (deathmatch.integer)
+ if (gamemode != GAME_TRANSFUSION) //Transfusion does this in QC
{
- if (((int)ent->v->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
+ if (deathmatch.integer)
+ {
+ if (((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_DEATHMATCH))
+ {
+ ED_Free (ent);
+ inhibited++;
+ continue;
+ }
+ }
+ else if ((current_skill <= 0 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_EASY ))
+ || (current_skill == 1 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_MEDIUM))
+ || (current_skill >= 2 && ((int)ent->fields.server->spawnflags & SPAWNFLAG_NOT_HARD )))
{
ED_Free (ent);
inhibited++;
continue;
}
}
- else if ((current_skill == 0 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_EASY ))
- || (current_skill == 1 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_MEDIUM))
- || (current_skill >= 2 && ((int)ent->v->spawnflags & SPAWNFLAG_NOT_HARD )))
- {
- ED_Free (ent);
- inhibited++;
- continue;
- }
-
//
// immediately call spawn function
//
- if (!ent->v->classname)
+ if (!ent->fields.server->classname)
{
Con_Print("No classname for:\n");
ED_Print(ent);
}
// look for the spawn function
- func = ED_FindFunction (PR_GetString(ent->v->classname));
+ func = PRVM_ED_FindFunction (PRVM_GetString(ent->fields.server->classname));
if (!func)
{
continue;
}
- pr_global_struct->self = EDICT_TO_PROG(ent);
- PR_ExecuteProgram (func - pr_functions, "QC function spawn is missing");
+ prog->globals.server->self = PRVM_EDICT_TO_PROG(ent);
+ PRVM_ExecuteProgram (func - prog->functions, "QC function spawn is missing");
spawned++;
- if (ent->e->free)
+ if (ent->priv.server->free)
died++;
}
dpfield_t dpfields[] =
{
- {ev_float, "gravity"},
+ {ev_entity, "cursor_trace_ent"},
+ {ev_entity, "drawonlytoclient"},
+ {ev_entity, "exteriormodeltoclient"},
+ {ev_entity, "nodrawtoclient"},
+ {ev_entity, "tag_entity"},
+ {ev_entity, "viewmodelforclient"},
+ {ev_float, "alpha"},
+ {ev_float, "ammo_cells1"},
+ {ev_float, "ammo_lava_nails"},
+ {ev_float, "ammo_multi_rockets"},
+ {ev_float, "ammo_nails1"},
+ {ev_float, "ammo_plasma"},
+ {ev_float, "ammo_rockets1"},
+ {ev_float, "ammo_shells1"},
{ev_float, "button3"},
{ev_float, "button4"},
{ev_float, "button5"},
{ev_float, "button6"},
{ev_float, "button7"},
{ev_float, "button8"},
+ {ev_float, "buttonchat"},
+ {ev_float, "buttonuse"},
+ {ev_float, "clientcolors"},
+ {ev_float, "cursor_active"},
+ {ev_float, "fullbright"},
+ {ev_float, "glow_color"},
{ev_float, "glow_size"},
{ev_float, "glow_trail"},
- {ev_float, "glow_color"},
- {ev_float, "items2"},
- {ev_float, "scale"},
- {ev_float, "alpha"},
- {ev_float, "renderamt"},
- {ev_float, "rendermode"},
- {ev_float, "fullbright"},
- {ev_float, "ammo_shells1"},
- {ev_float, "ammo_nails1"},
- {ev_float, "ammo_lava_nails"},
- {ev_float, "ammo_rockets1"},
- {ev_float, "ammo_multi_rockets"},
- {ev_float, "ammo_cells1"},
- {ev_float, "ammo_plasma"},
+ {ev_float, "gravity"},
{ev_float, "idealpitch"},
- {ev_float, "pitch_speed"},
- {ev_entity, "viewmodelforclient"},
- {ev_entity, "nodrawtoclient"},
- {ev_entity, "exteriormodeltoclient"},
- {ev_entity, "drawonlytoclient"},
+ {ev_float, "items2"},
+ {ev_float, "light_lev"},
+ {ev_float, "pflags"},
{ev_float, "ping"},
- {ev_vector, "movement"},
+ {ev_float, "pitch_speed"},
{ev_float, "pmodel"},
- {ev_vector, "punchvector"},
- {ev_float, "clientcolors"},
- {ev_entity, "tag_entity"},
+ {ev_float, "renderamt"}, // HalfLife support
+ {ev_float, "rendermode"}, // HalfLife support
+ {ev_float, "scale"},
+ {ev_float, "style"},
{ev_float, "tag_index"},
- {ev_float, "light_lev"},
+ {ev_float, "viewzoom"},
{ev_vector, "color"},
- {ev_float, "style"},
- {ev_float, "pflags"}
+ {ev_vector, "colormod"},
+ {ev_vector, "cursor_screen"},
+ {ev_vector, "cursor_trace_endpos"},
+ {ev_vector, "cursor_trace_start"},
+ {ev_vector, "movement"},
+ {ev_vector, "punchvector"},
+ {ev_string, "playermodel"},
+ {ev_string, "playerskin"}
};
/*
===============
*/
extern void PR_Cmd_Reset (void);
-void PR_LoadProgs (void)
+void PR_LoadProgs (const char *progsname)
{
int i;
+ fs_offset_t filesize;
dstatement_t *st;
ddef_t *infielddefs;
dfunction_t *dfunctions;
-// flush the non-C variable lookup cache
- for (i=0 ; i<GEFV_CACHESIZE ; i++)
- gefvCache[i].field[0] = 0;
+ if (!progsname || !*progsname)
+ Host_Error("PR_LoadProgs: passed empty progsname");
- Mem_EmptyPool(progs_mempool);
- Mem_EmptyPool(edictstring_mempool);
+ PR_FreeAll();
- progs = (dprograms_t *)FS_LoadFile ("progs.dat", progs_mempool, false);
+ progs = (dprograms_t *)FS_LoadFile (progsname, serverprogs_mempool, false, &filesize);
if (!progs)
- Host_Error ("PR_LoadProgs: couldn't load progs.dat");
+ Host_Error ("PR_LoadProgs: couldn't load %s", progsname);
- Con_DPrintf("Programs occupy %iK.\n", fs_filesize/1024);
+ Con_DPrintf("Programs occupy %iK.\n", filesize/1024);
- pr_crc = CRC_Block((qbyte *)progs, fs_filesize);
+ pr_crc = CRC_Block((unsigned char *)progs, filesize);
// byte swap the header
for (i = 0;i < (int) sizeof(*progs) / 4;i++)
if (progs->crc != PROGHEADER_CRC && progs->crc != 32401) // tenebrae crc also allowed
Host_Error ("progs.dat system vars have been modified, progdefs.h is out of date");
- //pr_functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
- dfunctions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
+ //prog->functions = (dfunction_t *)((unsigned char *)progs + progs->ofs_functions);
+ dfunctions = (dfunction_t *)((unsigned char *)progs + progs->ofs_functions);
+
pr_strings = (char *)progs + progs->ofs_strings;
- pr_globaldefs = (ddef_t *)((qbyte *)progs + progs->ofs_globaldefs);
+ pr_stringssize = 0;
+ for (i = 0;i < progs->numstrings;i++)
+ {
+ if (progs->ofs_strings + pr_stringssize >= filesize)
+ Host_Error ("progs.dat strings go past end of file");
+ pr_stringssize += strlen (pr_strings + pr_stringssize) + 1;
+ }
+ pr_numknownstrings = 0;
+ pr_maxknownstrings = 0;
+ pr_knownstrings = NULL;
+
+ pr_globaldefs = (ddef_t *)((unsigned char *)progs + progs->ofs_globaldefs);
// we need to expand the fielddefs list to include all the engine fields,
// so allocate a new place for it
- infielddefs = (ddef_t *)((qbyte *)progs + progs->ofs_fielddefs);
- pr_fielddefs = Mem_Alloc(progs_mempool, (progs->numfielddefs + DPFIELDS) * sizeof(ddef_t));
+ infielddefs = (ddef_t *)((unsigned char *)progs + progs->ofs_fielddefs);
+ pr_fielddefs = PR_Alloc((progs->numfielddefs + DPFIELDS) * sizeof(ddef_t));
+ prog->functions = PR_Alloc(sizeof(mfunction_t) * progs->numfunctions);
- pr_statements = (dstatement_t *)((qbyte *)progs + progs->ofs_statements);
+ pr_statements = (dstatement_t *)((unsigned char *)progs + progs->ofs_statements);
// moved edict_size calculation down below field adding code
- pr_global_struct = (globalvars_t *)((qbyte *)progs + progs->ofs_globals);
+ pr_global_struct = (globalvars_t *)((unsigned char *)progs + progs->ofs_globals);
pr_globals = (float *)pr_global_struct;
// byte swap the lumps
pr_statements[i].c = LittleShort(pr_statements[i].c);
}
- pr_functions = Mem_Alloc(progs_mempool, sizeof(mfunction_t) * progs->numfunctions);
for (i = 0;i < progs->numfunctions;i++)
{
- pr_functions[i].first_statement = LittleLong (dfunctions[i].first_statement);
- pr_functions[i].parm_start = LittleLong (dfunctions[i].parm_start);
- pr_functions[i].s_name = LittleLong (dfunctions[i].s_name);
- pr_functions[i].s_file = LittleLong (dfunctions[i].s_file);
- pr_functions[i].numparms = LittleLong (dfunctions[i].numparms);
- pr_functions[i].locals = LittleLong (dfunctions[i].locals);
- memcpy(pr_functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size));
+ prog->functions[i].first_statement = LittleLong (dfunctions[i].first_statement);
+ prog->functions[i].parm_start = LittleLong (dfunctions[i].parm_start);
+ prog->functions[i].s_name = LittleLong (dfunctions[i].s_name);
+ prog->functions[i].s_file = LittleLong (dfunctions[i].s_file);
+ prog->functions[i].numparms = LittleLong (dfunctions[i].numparms);
+ prog->functions[i].locals = LittleLong (dfunctions[i].locals);
+ memcpy(prog->functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size));
}
for (i=0 ; i<progs->numglobaldefs ; i++)
{
pr_fielddefs[progs->numfielddefs].type = dpfields[i].type;
pr_fielddefs[progs->numfielddefs].ofs = progs->entityfields;
- pr_fielddefs[progs->numfielddefs].s_name = PR_SetString(dpfields[i].string);
+ pr_fielddefs[progs->numfielddefs].s_name = PRVM_SetEngineString(dpfields[i].string);
if (pr_fielddefs[progs->numfielddefs].type == ev_vector)
progs->entityfields += 3;
else
((int *)pr_globals)[i] = LittleLong (((int *)pr_globals)[i]);
// moved edict_size calculation down here, below field adding code
- // LordHavoc: this no longer includes the edict_t header
- pr_edict_size = progs->entityfields * 4;
- pr_edictareasize = pr_edict_size * MAX_EDICTS;
+ // LordHavoc: this no longer includes the prvm_edict_t header
+ prog->edict_size = progs->entityfields * 4;
+ pr_edictareasize = prog->edict_size * MAX_EDICTS;
// LordHavoc: bounds check anything static
for (i = 0,st = pr_statements;i < progs->numstatements;i++,st++)
case OP_IF:
case OP_IFNOT:
if ((unsigned short) st->a >= progs->numglobals || st->b + i < 0 || st->b + i >= progs->numstatements)
- Host_Error("PR_LoadProgs: out of bounds IF/IFNOT (statement %d)\n", i);
+ Host_Error("PR_LoadProgs: out of bounds IF/IFNOT (statement %d)", i);
break;
case OP_GOTO:
if (st->a + i < 0 || st->a + i >= progs->numstatements)
- Host_Error("PR_LoadProgs: out of bounds GOTO (statement %d)\n", i);
+ Host_Error("PR_LoadProgs: out of bounds GOTO (statement %d)", i);
break;
// global global global
case OP_ADD_F:
case OP_LOAD_FNC:
case OP_LOAD_V:
if ((unsigned short) st->a >= progs->numglobals || (unsigned short) st->b >= progs->numglobals || (unsigned short) st->c >= progs->numglobals)
- Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
+ Host_Error("PR_LoadProgs: out of bounds global index (statement %d)", i);
break;
// global none global
case OP_NOT_F:
case OP_NOT_FNC:
case OP_NOT_ENT:
if ((unsigned short) st->a >= progs->numglobals || (unsigned short) st->c >= progs->numglobals)
- Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
+ Host_Error("PR_LoadProgs: out of bounds global index (statement %d)", i);
break;
// 2 globals
case OP_STOREP_F:
case OP_STOREP_V:
case OP_STORE_V:
if ((unsigned short) st->a >= progs->numglobals || (unsigned short) st->b >= progs->numglobals)
- Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
+ Host_Error("PR_LoadProgs: out of bounds global index (statement %d)", i);
break;
// 1 global
case OP_CALL0:
case OP_DONE:
case OP_RETURN:
if ((unsigned short) st->a >= progs->numglobals)
- Host_Error("PR_LoadProgs: out of bounds global index (statement %d)\n", i);
+ Host_Error("PR_LoadProgs: out of bounds global index (statement %d)", i);
break;
default:
- Host_Error("PR_LoadProgs: unknown opcode %d at statement %d\n", st->op, i);
+ Host_Error("PR_LoadProgs: unknown opcode %d at statement %d", st->op, i);
break;
}
}
{
int i, j, ednum, used, usedamount;
int *counts;
- char tempstring[5000], tempstring2[260], *name;
- edict_t *ed;
+ const char *name;
+ char tempstring[5000], tempstring2[260];
+ prvm_edict_t *ed;
ddef_t *d;
int *v;
if (!sv.active)
return;
}
counts = Mem_Alloc(tempmempool, progs->numfielddefs * sizeof(int));
- for (ednum = 0;ednum < sv.max_edicts;ednum++)
+ for (ednum = 0;ednum < prog->max_edicts;ednum++)
{
- ed = EDICT_NUM(ednum);
- if (ed->e->free)
+ ed = PRVM_EDICT_NUM(ednum);
+ if (ed->priv.server->free)
continue;
for (i = 1;i < progs->numfielddefs;i++)
{
d = &pr_fielddefs[i];
- name = PR_GetString(d->s_name);
+ name = PRVM_GetString(d->s_name);
if (name[strlen(name)-2] == '_')
continue; // skip _x, _y, _z vars
v = (int *)((char *)ed->v + d->ofs*4);
for (i = 0;i < progs->numfielddefs;i++)
{
d = &pr_fielddefs[i];
- name = PR_GetString(d->s_name);
+ name = PRVM_GetString(d->s_name);
if (name[strlen(name)-2] == '_')
continue; // skip _x, _y, _z vars
switch(d->type & ~DEF_SAVEGLOBAL)
strlcat (tempstring, "pointer ", sizeof (tempstring));
break;
default:
- snprintf (tempstring2, sizeof (tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
+ dpsnprintf (tempstring2, sizeof (tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
strlcat (tempstring, tempstring2, sizeof (tempstring));
break;
}
strcat (tempstring, name);
for (j = strlen(name);j < 25;j++)
strcat(tempstring, " ");
- snprintf (tempstring2, sizeof (tempstring2), "%5d", counts[i]);
+ dpsnprintf (tempstring2, sizeof (tempstring2), "%5d", counts[i]);
strlcat (tempstring, tempstring2, sizeof (tempstring));
strlcat (tempstring, "\n", sizeof (tempstring));
if (strlen(tempstring) >= 4096)
}
}
Mem_Free(counts);
- Con_Printf("%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", progs->entityfields, used, progs->entityfields * 4, usedamount * 4, sv.max_edicts, progs->entityfields * 4 * sv.max_edicts, usedamount * 4 * sv.max_edicts);
+ Con_Printf("%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", progs->entityfields, used, progs->entityfields * 4, usedamount * 4, prog->max_edicts, progs->entityfields * 4 * prog->max_edicts, usedamount * 4 * prog->max_edicts);
}
void PR_Globals_f (void)
return;
}
for (i = 0;i < progs->numglobaldefs;i++)
- Con_Printf("%s\n", PR_GetString(pr_globaldefs[i].s_name));
+ Con_Printf("%s\n", PRVM_GetString(pr_globaldefs[i].s_name));
Con_Printf("%i global variables, totalling %i bytes\n", progs->numglobals, progs->numglobals * 4);
}
Cvar_RegisterVariable (&pr_boundscheck);
Cvar_RegisterVariable (&pr_traceqc);
- progs_mempool = Mem_AllocPool("progs.dat", 0, NULL);
- edictstring_mempool = Mem_AllocPool("edict strings", 0, NULL);
+ serverprogs_mempool = Mem_AllocPool("server progs", 0, NULL);
PR_Cmd_Init();
}
-// LordHavoc: turned EDICT_NUM into a #define for speed reasons
-edict_t *EDICT_NUM_ERROR(int n, char *filename, int fileline)
+/*
+===============
+PR_Shutdown
+===============
+*/
+extern void PR_Cmd_Shutdown(void);
+void PR_Shutdown (void)
+{
+ PR_Cmd_Shutdown();
+
+ Mem_FreePool(&serverprogs_mempool);
+}
+
+void *_PR_Alloc(size_t buffersize, const char *filename, int fileline)
+{
+ return _Mem_Alloc(serverprogs_mempool, buffersize, filename, fileline);
+}
+
+void _PR_Free(void *buffer, const char *filename, int fileline)
{
- Host_Error ("EDICT_NUM: bad number %i (called at %s:%i)", n, filename, fileline);
+ _Mem_Free(buffer, filename, fileline);
+}
+
+void _PR_FreeAll(const char *filename, int fileline)
+{
+ progs = NULL;
+ pr_fielddefs = NULL;
+ prog->functions = NULL;
+ _Mem_EmptyPool(serverprogs_mempool, filename, fileline);
+}
+
+// LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons
+prvm_edict_t *EDICT_NUM_ERROR(int n, char *filename, int fileline)
+{
+ Host_Error ("PRVM_EDICT_NUM: bad number %i (called at %s:%i)", n, filename, fileline);
return NULL;
}
/*
-int NUM_FOR_EDICT_ERROR(edict_t *e)
+int NUM_FOR_EDICT_ERROR(prvm_edict_t *e)
{
- Host_Error ("NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, sv.edicts, e - sv.edicts);
+ Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, prog->edicts, e - prog->edicts);
return 0;
}
-int NUM_FOR_EDICT(edict_t *e)
+int PRVM_NUM_FOR_EDICT(prvm_edict_t *e)
{
int n;
- n = e - sv.edicts;
+ n = e - prog->edicts;
if ((unsigned int)n >= MAX_EDICTS)
- Host_Error ("NUM_FOR_EDICT: bad pointer");
+ Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer");
return n;
}
-//int NoCrash_NUM_FOR_EDICT(edict_t *e)
+//int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e)
//{
-// return e - sv.edicts;
+// return e - prog->edicts;
//}
-//#define EDICT_TO_PROG(e) ((qbyte *)(((edict_t *)e)->v) - (qbyte *)(sv.edictsfields))
-//#define PROG_TO_EDICT(e) (sv.edicts + ((e) / (progs->entityfields * 4)))
-int EDICT_TO_PROG(edict_t *e)
+//#define PRVM_EDICT_TO_PROG(e) ((unsigned char *)(((prvm_edict_t *)e)->v) - (unsigned char *)(prog->edictsfields))
+//#define PRVM_PROG_TO_EDICT(e) (prog->edicts + ((e) / (progs->entityfields * 4)))
+int PRVM_EDICT_TO_PROG(prvm_edict_t *e)
{
int n;
- n = e - sv.edicts;
- if ((unsigned int)n >= (unsigned int)sv.max_edicts)
- Host_Error("EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, sv.edicts);
+ n = e - prog->edicts;
+ if ((unsigned int)n >= (unsigned int)prog->max_edicts)
+ Host_Error("PRVM_EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)", e, n, prog->edicts);
return n;// EXPERIMENTAL
- //return (qbyte *)e->v - (qbyte *)sv.edictsfields;
+ //return (unsigned char *)e->v - (unsigned char *)prog->edictsfields;
}
-edict_t *PROG_TO_EDICT(int n)
+prvm_edict_t *PRVM_PROG_TO_EDICT(int n)
{
- if ((unsigned int)n >= (unsigned int)sv.max_edicts)
- Host_Error("PROG_TO_EDICT: invalid edict number %i\n", n);
- return sv.edicts + n; // EXPERIMENTAL
- //return sv.edicts + ((n) / (progs->entityfields * 4));
+ if ((unsigned int)n >= (unsigned int)prog->max_edicts)
+ Host_Error("PRVM_PROG_TO_EDICT: invalid edict number %i", n);
+ return prog->edicts + n; // EXPERIMENTAL
+ //return prog->edicts + ((n) / (progs->entityfields * 4));
}
*/
+const char *PRVM_GetString(int num)
+{
+ if (num >= 0 && num < pr_stringssize)
+ return pr_strings + num;
+ else if (num < 0 && num >= -pr_numknownstrings)
+ {
+ num = -1 - num;
+ if (!pr_knownstrings[num])
+ Host_Error("PRVM_GetString: attempt to get string that is already freed");
+ return pr_knownstrings[num];
+ }
+ else
+ {
+ Host_Error("PRVM_GetString: invalid string offset %i", num);
+ return "";
+ }
+}
+
+int PR_SetQCString(const char *s)
+{
+ int i;
+ if (!s)
+ return 0;
+ if (s >= pr_strings && s <= pr_strings + pr_stringssize)
+ return s - pr_strings;
+ for (i = 0;i < pr_numknownstrings;i++)
+ if (pr_knownstrings[i] == s)
+ return -1 - i;
+ Host_Error("PR_SetQCString: unknown string");
+ return -1 - i;
+}
+
+int PRVM_SetEngineString(const char *s)
+{
+ int i;
+ if (!s)
+ return 0;
+ if (s >= pr_strings && s <= pr_strings + pr_stringssize)
+ Host_Error("PRVM_SetEngineString: s in pr_strings area");
+ for (i = 0;i < pr_numknownstrings;i++)
+ if (pr_knownstrings[i] == s)
+ return -1 - i;
+ // new unknown engine string
+ if (developer.integer >= 3)
+ Con_Printf("new engine string %p\n", s);
+ for (i = 0;i < pr_numknownstrings;i++)
+ if (!pr_knownstrings[i])
+ break;
+ if (i >= pr_numknownstrings)
+ {
+ if (i >= pr_maxknownstrings)
+ {
+ const char **oldstrings = pr_knownstrings;
+ pr_maxknownstrings += 128;
+ pr_knownstrings = PR_Alloc(pr_maxknownstrings * sizeof(char *));
+ if (pr_numknownstrings)
+ memcpy((char **)pr_knownstrings, oldstrings, pr_numknownstrings * sizeof(char *));
+ }
+ pr_numknownstrings++;
+ }
+ pr_knownstrings[i] = s;
+ return -1 - i;
+}
+
+char *PR_AllocString(int bufferlength)
+{
+ int i;
+ if (!bufferlength)
+ return 0;
+ for (i = 0;i < pr_numknownstrings;i++)
+ if (!pr_knownstrings[i])
+ break;
+ if (i >= pr_numknownstrings)
+ {
+ if (i >= pr_maxknownstrings)
+ {
+ const char **oldstrings = pr_knownstrings;
+ pr_maxknownstrings += 128;
+ pr_knownstrings = PR_Alloc(pr_maxknownstrings * sizeof(char *));
+ if (pr_numknownstrings)
+ memcpy((char **)pr_knownstrings, oldstrings, pr_numknownstrings * sizeof(char *));
+ }
+ pr_numknownstrings++;
+ }
+ return (char *)(pr_knownstrings[i] = PR_Alloc(bufferlength));
+}
+
+void PR_FreeString(char *s)
+{
+ int i;
+ if (!s)
+ Host_Error("PR_FreeString: attempt to free a NULL string");
+ if (s >= pr_strings && s <= pr_strings + pr_stringssize)
+ Host_Error("PR_FreeString: attempt to free a constant string");
+ for (i = 0;i < pr_numknownstrings;i++)
+ if (pr_knownstrings[i] == s)
+ break;
+ if (i == pr_numknownstrings)
+ Host_Error("PR_FreeString: attempt to free a non-existent or already freed string");
+ PR_Free((char *)pr_knownstrings[i]);
+ pr_knownstrings[i] = NULL;
+}
+
projects / xonotic / darkplaces.git / blobdiff