mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2025-03-21 09:51:41 +00:00
clean up some redundant progs functions (may be broken for a while)
This is an imperfect revision of history.
This commit is contained in:
Bill Currie
Jeff Teunissen
parent
b46cff08aa
commit
f5bc90a53a
12 changed files with 245 additions and 252 deletions
|
|
@ -48,15 +48,8 @@ typedef struct edict_s {
|
|||
} edict_t;
|
||||
#define EDICT_FROM_AREA(l) STRUCT_FROM_LINK(l,edict_t,area)
|
||||
|
||||
#ifndef PROGS_T
|
||||
typedef struct progs_s progs_t;
|
||||
#define PROGS_T
|
||||
#endif
|
||||
|
||||
#ifndef PR_RESOURCE_T
|
||||
typedef struct pr_resource_s pr_resource_t;
|
||||
#define PR_RESOURCE_T
|
||||
#endif
|
||||
|
||||
//============================================================================
|
||||
|
||||
|
|
@ -91,21 +84,12 @@ void ED_ParseGlobals (progs_t *pr, const char *data);
|
|||
|
||||
void ED_LoadFromFile (progs_t *pr, const char *data);
|
||||
|
||||
ddef_t *ED_FieldAtOfs (progs_t *pr, int ofs);
|
||||
ddef_t *ED_FindField (progs_t *pr, const char *name);
|
||||
int ED_GetFieldIndex (progs_t *pr, const char *name);
|
||||
dfunction_t *ED_FindFunction (progs_t *pr, const char *name);
|
||||
ddef_t *PR_FieldAtOfs (progs_t *pr, int ofs);
|
||||
ddef_t *PR_GlobalAtOfs (progs_t *pr, int ofs);
|
||||
|
||||
int PR_AccessField (progs_t *pr, const char *name, etype_t type,
|
||||
const char *file, int line);
|
||||
|
||||
//define EDICT_NUM(p,n) ((edict_t *)(*(p)->edicts+ (n)*(p)->pr_edict_size))
|
||||
//define NUM_FOR_EDICT(p,e) (((byte *)(e) - *(p)->edicts)/(p)->pr_edict_size)
|
||||
|
||||
edict_t *EDICT_NUM(progs_t *pr, int n);
|
||||
int NUM_FOR_EDICT(progs_t *pr, edict_t *e);
|
||||
int NUM_FOR_BAD_EDICT(progs_t *pr, edict_t *e);
|
||||
qboolean PR_EdictValid (progs_t *pr, int e);
|
||||
ddef_t *PR_FindField (progs_t *pr, const char *name);
|
||||
ddef_t *PR_FindGlobal (progs_t *pr, const char *name);
|
||||
dfunction_t *PR_FindFunction (progs_t *pr, const char *name);
|
||||
|
||||
#define NEXT_EDICT(p,e) ((edict_t *)( (byte *)e + (p)->pr_edict_size))
|
||||
|
||||
|
|
@ -207,8 +191,6 @@ typedef struct {
|
|||
builtin_proc func;
|
||||
} bfunction_t;
|
||||
|
||||
ddef_t *PR_FindGlobal (progs_t *pr, const char *name);
|
||||
ddef_t *ED_GlobalAtOfs (progs_t *pr, int ofs);
|
||||
|
||||
pr_type_t *PR_GetGlobalPointer (progs_t *pr, const char *name);
|
||||
func_t PR_GetFunctionIndex (progs_t *pr, const char *name);
|
||||
|
|
@ -443,7 +425,7 @@ PR_GetPointer (progs_t *pr, int o)
|
|||
}
|
||||
|
||||
static inline pointer_t
|
||||
POINTER_TO_PROG (progs_t *pr, void *p)
|
||||
PR_SetPointer (progs_t *pr, void *p)
|
||||
{
|
||||
return p ? (pr_type_t *) p - pr->pr_globals : 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -93,15 +93,15 @@ menu_resolve_globals (progs_t *pr)
|
|||
const char *sym;
|
||||
dfunction_t *f;
|
||||
|
||||
if (!(f = ED_FindFunction (pr, sym = "menu_init")))
|
||||
if (!(f = PR_FindFunction (pr, sym = "menu_init")))
|
||||
goto error;
|
||||
menu_init = (func_t)(f - menu_pr_state.pr_functions);
|
||||
if (!(f = ED_FindFunction (pr, sym = "menu_draw_hud")))
|
||||
if (!(f = PR_FindFunction (pr, sym = "menu_draw_hud")))
|
||||
goto error;
|
||||
menu_draw_hud = (func_t)(f - pr->pr_functions);
|
||||
return 1;
|
||||
error:
|
||||
Con_Printf ("%s: undefined function %s\n", pr->progs_name, sym);
|
||||
Con_Printf ("%s: undefined symbol %s\n", pr->progs_name, sym);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -266,7 +266,7 @@ PF_Find (progs_t *pr)
|
|||
|
||||
e = P_EDICTNUM (pr, 0);
|
||||
f = P_INT (pr, 1);
|
||||
field_def = ED_FieldAtOfs (pr, f);
|
||||
field_def = PR_FieldAtOfs (pr, f);
|
||||
if (!field_def)
|
||||
PR_RunError (pr, "PF_Find: bad search field: %d", f);
|
||||
type = field_def->type & ~DEF_SAVEGLOBAL;
|
||||
|
|
|
|||
|
|
@ -486,7 +486,7 @@ value_string (progs_t *pr, etype_t type, pr_type_t *val)
|
|||
}
|
||||
break;
|
||||
case ev_field:
|
||||
def = ED_FieldAtOfs (pr, val->integer_var);
|
||||
def = PR_FieldAtOfs (pr, val->integer_var);
|
||||
if (def)
|
||||
dsprintf (line, ".%s", PR_GetString (pr, def->s_name));
|
||||
else
|
||||
|
|
@ -508,7 +508,7 @@ value_string (progs_t *pr, etype_t type, pr_type_t *val)
|
|||
if (pr_debug->int_val && pr->debug)
|
||||
def = PR_Get_Local_Def (pr, ofs);
|
||||
if (!def)
|
||||
def = ED_GlobalAtOfs (pr, ofs);
|
||||
def = PR_GlobalAtOfs (pr, ofs);
|
||||
if (def && def->s_name)
|
||||
dsprintf (line, "&%s", PR_GetString (pr, def->s_name));
|
||||
else
|
||||
|
|
@ -545,7 +545,7 @@ def_string (progs_t *pr, int ofs, dstring_t *dstr)
|
|||
if (pr_debug->int_val && pr->debug)
|
||||
def = PR_Get_Local_Def (pr, ofs);
|
||||
if (!def)
|
||||
def = ED_GlobalAtOfs (pr, ofs);
|
||||
def = PR_GlobalAtOfs (pr, ofs);
|
||||
if (!def || !*(name = PR_GetString (pr, def->s_name)))
|
||||
dsprintf (dstr, "[$%x]", ofs);
|
||||
else
|
||||
|
|
|
|||
|
|
@ -160,7 +160,7 @@ ED_PrintEdicts (progs_t *pr, const char *fieldval)
|
|||
int count;
|
||||
ddef_t *def;
|
||||
|
||||
def = ED_FindField(pr, "classname");
|
||||
def = PR_FindField(pr, "classname");
|
||||
|
||||
if (fieldval && fieldval[0] && def) {
|
||||
count = 0;
|
||||
|
|
@ -192,8 +192,8 @@ ED_Count (progs_t *pr)
|
|||
ddef_t *model_def;
|
||||
edict_t *ent;
|
||||
|
||||
solid_def = ED_FindField (pr, "solid");
|
||||
model_def = ED_FindField (pr, "model");
|
||||
solid_def = PR_FindField (pr, "solid");
|
||||
model_def = PR_FindField (pr, "model");
|
||||
active = models = solid = step = zombie = 0;
|
||||
for (i = 0; i < *(pr)->num_edicts; i++) {
|
||||
ent = EDICT_NUM (pr, i);
|
||||
|
|
@ -217,7 +217,7 @@ ED_Count (progs_t *pr)
|
|||
}
|
||||
|
||||
edict_t *
|
||||
EDICT_NUM (progs_t *pr, int n)
|
||||
ED_EdictNum (progs_t *pr, int n)
|
||||
{
|
||||
int offs = n * pr->pr_edict_size;
|
||||
if (offs < 0 || n >= pr->pr_edictareasize)
|
||||
|
|
@ -227,20 +227,7 @@ EDICT_NUM (progs_t *pr, int n)
|
|||
}
|
||||
|
||||
int
|
||||
NUM_FOR_BAD_EDICT (progs_t *pr, edict_t *e)
|
||||
{
|
||||
int b;
|
||||
|
||||
b = (byte *) e - (byte *) * (pr)->edicts;
|
||||
|
||||
if (pr->pr_edict_size)
|
||||
b /= pr->pr_edict_size;
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
int
|
||||
NUM_FOR_EDICT (progs_t *pr, edict_t *e)
|
||||
ED_NumForEdict (progs_t *pr, edict_t *e)
|
||||
{
|
||||
int b;
|
||||
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ PR_UglyValueString (progs_t *pr, etype_t type, pr_type_t *val)
|
|||
snprintf (line, sizeof (line), "%s", PR_GetString (pr, f->s_name));
|
||||
break;
|
||||
case ev_field:
|
||||
def = ED_FieldAtOfs (pr, val->integer_var);
|
||||
def = PR_FieldAtOfs (pr, val->integer_var);
|
||||
snprintf (line, sizeof (line), "%s",
|
||||
PR_GetString (pr, def->s_name));
|
||||
break;
|
||||
|
|
@ -258,7 +258,7 @@ ED_ParseEpair (progs_t *pr, pr_type_t *base, ddef_t *key, const char *s)
|
|||
break;
|
||||
|
||||
case ev_field:
|
||||
def = ED_FindField (pr, s);
|
||||
def = PR_FindField (pr, s);
|
||||
if (!def) {
|
||||
Sys_Printf ("Can't find field %s\n", s);
|
||||
return false;
|
||||
|
|
@ -267,7 +267,7 @@ ED_ParseEpair (progs_t *pr, pr_type_t *base, ddef_t *key, const char *s)
|
|||
break;
|
||||
|
||||
case ev_func:
|
||||
func = ED_FindFunction (pr, s);
|
||||
func = PR_FindFunction (pr, s);
|
||||
if (!func) {
|
||||
Sys_Printf ("Can't find function %s\n", s);
|
||||
return false;
|
||||
|
|
@ -346,7 +346,7 @@ ED_ParseEdict (progs_t *pr, const char *data, edict_t *ent)
|
|||
if (keyname->str[0] == '_')
|
||||
continue;
|
||||
|
||||
key = ED_FindField (pr, keyname->str);
|
||||
key = PR_FindField (pr, keyname->str);
|
||||
if (!key) {
|
||||
if (!pr->parse_field
|
||||
|| !pr->parse_field (pr, keyname->str, com_token)) {
|
||||
|
|
@ -357,9 +357,9 @@ ED_ParseEdict (progs_t *pr, const char *data, edict_t *ent)
|
|||
int ret;
|
||||
|
||||
if (anglehack) {
|
||||
ret = ED_ParseEpair (pr, ent->v, key, va ("0 %s 0", com_token));
|
||||
ret = ED_ParseEpair (pr, ent->v, key, va ("0 %s 0", token));
|
||||
} else {
|
||||
ret = ED_ParseEpair (pr, ent->v, key, com_token);
|
||||
ret = ED_ParseEpair (pr, ent->v, key, token);
|
||||
}
|
||||
if (!ret)
|
||||
PR_Error (pr, "ED_ParseEdict: parse error");
|
||||
|
|
@ -374,7 +374,7 @@ ED_ParseEdict (progs_t *pr, const char *data, edict_t *ent)
|
|||
}
|
||||
|
||||
void
|
||||
ED_ParseGlobals (progs_t *pr, const char *data)
|
||||
ED_ParseGlobals (progs_t *pr, script_t *script)
|
||||
{
|
||||
dstring_t *keyname = dstring_new ();
|
||||
ddef_t *key;
|
||||
|
|
@ -454,10 +454,8 @@ ED_ParseOld (progs_t *pr, const char *data)
|
|||
continue;
|
||||
}
|
||||
|
||||
//
|
||||
// immediately call spawn function
|
||||
//
|
||||
def = ED_FindField (pr, "classname");
|
||||
def = PR_FindField (pr, "classname");
|
||||
if (!def) {
|
||||
Sys_Printf ("No classname for:\n");
|
||||
ED_Print (pr, ent);
|
||||
|
|
@ -467,7 +465,7 @@ ED_ParseOld (progs_t *pr, const char *data)
|
|||
classname = &ent->v[def->ofs];
|
||||
|
||||
// look for the spawn function
|
||||
func = ED_FindFunction (pr, PR_GetString (pr, classname->string_var));
|
||||
func = PR_FindFunction (pr, PR_GetString (pr, classname->string_var));
|
||||
if (!func) {
|
||||
Sys_Printf ("No spawn function for:\n");
|
||||
ED_Print (pr, ent);
|
||||
|
|
|
|||
|
|
@ -55,11 +55,8 @@ static __attribute__ ((unused)) const char rcsid[] =
|
|||
#include "compat.h"
|
||||
|
||||
|
||||
/*
|
||||
ED_GlobalAtOfs
|
||||
*/
|
||||
ddef_t *
|
||||
ED_GlobalAtOfs (progs_t * pr, int ofs)
|
||||
ddef_t *
|
||||
PR_GlobalAtOfs (progs_t * pr, int ofs)
|
||||
{
|
||||
ddef_t *def;
|
||||
unsigned int i;
|
||||
|
|
@ -72,11 +69,8 @@ ED_GlobalAtOfs (progs_t * pr, int ofs)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
ED_FieldAtOfs
|
||||
*/
|
||||
ddef_t *
|
||||
ED_FieldAtOfs (progs_t * pr, int ofs)
|
||||
ddef_t *
|
||||
PR_FieldAtOfs (progs_t * pr, int ofs)
|
||||
{
|
||||
ddef_t *def;
|
||||
unsigned int i;
|
||||
|
|
@ -89,76 +83,30 @@ ED_FieldAtOfs (progs_t * pr, int ofs)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
ED_FindField
|
||||
*/
|
||||
ddef_t *
|
||||
ED_FindField (progs_t * pr, const char *name)
|
||||
ddef_t *
|
||||
PR_FindField (progs_t * pr, const char *name)
|
||||
{
|
||||
return Hash_Find (pr->field_hash, name);
|
||||
}
|
||||
|
||||
int
|
||||
ED_GetFieldIndex (progs_t *pr, const char *name)
|
||||
{
|
||||
ddef_t *def;
|
||||
|
||||
def = ED_FindField (pr, name);
|
||||
if (def)
|
||||
return def->ofs;
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
PR_FindGlobal
|
||||
*/
|
||||
ddef_t *
|
||||
ddef_t *
|
||||
PR_FindGlobal (progs_t * pr, const char *name)
|
||||
{
|
||||
return Hash_Find (pr->global_hash, name);
|
||||
}
|
||||
|
||||
pr_type_t *
|
||||
PR_GetGlobalPointer (progs_t *pr, const char *name)
|
||||
{
|
||||
ddef_t *def;
|
||||
|
||||
def = PR_FindGlobal (pr, name);
|
||||
if (def)
|
||||
return &pr->pr_globals[def->ofs];
|
||||
PR_Error (pr, "undefined global %s", name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
func_t
|
||||
PR_GetFunctionIndex (progs_t *pr, const char *name)
|
||||
{
|
||||
dfunction_t *func = ED_FindFunction (pr, name);
|
||||
if (func)
|
||||
return func - pr->pr_functions;
|
||||
PR_Error (pr, "undefined function %s", name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
PR_GetFieldOffset (progs_t *pr, const char *name)
|
||||
{
|
||||
ddef_t *def = ED_FindField (pr, name);
|
||||
if (def)
|
||||
return def->ofs;
|
||||
PR_Error (pr, "undefined field %s", name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
ED_FindFunction
|
||||
*/
|
||||
dfunction_t *
|
||||
ED_FindFunction (progs_t * pr, const char *name)
|
||||
PR_FindFunction (progs_t * pr, const char *name)
|
||||
{
|
||||
return Hash_Find (pr->function_hash, name);
|
||||
}
|
||||
|
||||
void
|
||||
PR_Undefined (progs_t *pr, const char *type, const char *name)
|
||||
{
|
||||
PR_Error (pr, "undefined %s %s", type, name);
|
||||
}
|
||||
|
||||
int
|
||||
PR_ResolveGlobals (progs_t *pr)
|
||||
{
|
||||
|
|
@ -200,11 +148,14 @@ PR_ResolveGlobals (progs_t *pr)
|
|||
pr->globals.self = &G_INT (pr, def->ofs);
|
||||
}
|
||||
if (pr->fields.nextthink == -1)
|
||||
pr->fields.nextthink = ED_GetFieldIndex (pr, sym = "nextthink");
|
||||
if ((def = PR_FindField (pr, "nextthink")))
|
||||
pr->fields.nextthink = def->ofs;
|
||||
if (pr->fields.frame == -1)
|
||||
pr->fields.frame = ED_GetFieldIndex (pr, sym = "frame");
|
||||
if ((def = PR_FindField (pr, "frame")))
|
||||
pr->fields.frame = def->ofs;
|
||||
if (pr->fields.think == -1)
|
||||
pr->fields.think = ED_GetFieldIndex (pr, sym = "think");
|
||||
if ((def = PR_FindField (pr, "think")))
|
||||
pr->fields.think = def->ofs;
|
||||
return 1;
|
||||
error:
|
||||
Sys_Printf ("%s: undefined symbol: %s\n", pr->progs_name, sym);
|
||||
|
|
@ -215,7 +166,7 @@ int
|
|||
PR_AccessField (progs_t *pr, const char *name, etype_t type,
|
||||
const char *file, int line)
|
||||
{
|
||||
ddef_t *def = ED_FindField (pr, name);
|
||||
ddef_t *def = PR_FindField (pr, name);
|
||||
|
||||
if (!def)
|
||||
PR_Error (pr, "undefined field %s accessed at %s:%d", name, file, line);
|
||||
|
|
|
|||
|
|
@ -169,7 +169,7 @@ finish_class (progs_t *pr, pr_class_t *class, pointer_t object_ptr)
|
|||
PR_Error (pr, "broken class %s: super class %s not found",
|
||||
class_name, super_class);
|
||||
meta->super_class = val->class_pointer;
|
||||
class->super_class = POINTER_TO_PROG (pr, val);
|
||||
class->super_class = PR_SetPointer (pr, val);
|
||||
} else {
|
||||
pointer_t *ml = &meta->methods;
|
||||
while (*ml)
|
||||
|
|
@ -456,7 +456,7 @@ rua_obj_malloc (progs_t *pr)
|
|||
int size = P_INT (pr, 0) * sizeof (pr_type_t);
|
||||
void *mem = PR_Zone_Malloc (pr, size);
|
||||
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, mem);
|
||||
RETURN_POINTER (pr, mem);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -465,7 +465,7 @@ rua_obj_atomic_malloc (progs_t *pr)
|
|||
int size = P_INT (pr, 0) * sizeof (pr_type_t);
|
||||
void *mem = PR_Zone_Malloc (pr, size);
|
||||
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, mem);
|
||||
RETURN_POINTER (pr, mem);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -474,7 +474,7 @@ rua_obj_valloc (progs_t *pr)
|
|||
int size = P_INT (pr, 0) * sizeof (pr_type_t);
|
||||
void *mem = PR_Zone_Malloc (pr, size);
|
||||
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, mem);
|
||||
RETURN_POINTER (pr, mem);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -484,7 +484,7 @@ rua_obj_realloc (progs_t *pr)
|
|||
int size = P_INT (pr, 1) * sizeof (pr_type_t);
|
||||
|
||||
mem = PR_Zone_Realloc (pr, mem, size);
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, mem);
|
||||
RETURN_POINTER (pr, mem);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -494,7 +494,7 @@ rua_obj_calloc (progs_t *pr)
|
|||
void *mem = PR_Zone_Malloc (pr, size);
|
||||
|
||||
memset (mem, 0, size);
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, mem);
|
||||
RETURN_POINTER (pr, mem);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -561,7 +561,7 @@ rua_obj_get_class (progs_t *pr)
|
|||
class = Hash_Find (pr->classes, name);
|
||||
if (!class)
|
||||
PR_RunError (pr, "could not find class %s", name);
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, class);
|
||||
RETURN_POINTER (pr, class);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -571,7 +571,7 @@ rua_obj_lookup_class (progs_t *pr)
|
|||
pr_class_t *class;
|
||||
|
||||
class = Hash_Find (pr->classes, name);
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, class);
|
||||
RETURN_POINTER (pr, class);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -686,7 +686,7 @@ class_create_instance (progs_t *pr, pr_class_t *class)
|
|||
|
||||
id = PR_Zone_Malloc (pr, size);
|
||||
memset (id, 0, size);
|
||||
id->class_pointer = POINTER_TO_PROG (pr, class);
|
||||
id->class_pointer = PR_SetPointer (pr, class);
|
||||
return id;
|
||||
}
|
||||
|
||||
|
|
@ -696,7 +696,7 @@ rua_class_create_instance (progs_t *pr)
|
|||
pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
|
||||
pr_id_t *id = class_create_instance (pr, class);
|
||||
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, id);
|
||||
RETURN_POINTER (pr, id);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -811,7 +811,7 @@ rua_object_copy (progs_t *pr)
|
|||
|
||||
id = class_create_instance (pr, class);
|
||||
memcpy (id, object, sizeof (pr_type_t) * class->instance_size);
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, id);
|
||||
RETURN_POINTER (pr, id);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -823,7 +823,7 @@ rua_object_get_class (progs_t *pr)
|
|||
if (object) {
|
||||
class = &G_STRUCT (pr, pr_class_t, object->class_pointer);
|
||||
if (PR_CLS_ISCLASS (class)) {
|
||||
R_INT (pr) = POINTER_TO_PROG (pr, class);
|
||||
RETURN_POINTER (pr, class);
|
||||
return;
|
||||
}
|
||||
if (PR_CLS_ISMETA (class)) {
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ ED_Count_f (void)
|
|||
ED_Count (&sv_pr_state);
|
||||
}
|
||||
|
||||
void
|
||||
static void
|
||||
PR_Profile_f (void)
|
||||
{
|
||||
if (!sv_pr_state.progs) {
|
||||
|
|
@ -359,66 +359,102 @@ set_address (sv_def_t *def, void *address)
|
|||
}
|
||||
}
|
||||
|
||||
static int
|
||||
resolve_globals (progs_t *pr, sv_def_t *def, int mode)
|
||||
{
|
||||
ddef_t *ddef;
|
||||
int ret = 1;
|
||||
|
||||
if (mode == 2) {
|
||||
for (; def->name; def++)
|
||||
set_address (def, &G_FLOAT (pr, def->offset));
|
||||
return 1;
|
||||
}
|
||||
for (; def->name; def++) {
|
||||
ddef = PR_FindGlobal (pr, def->name);
|
||||
if (ddef) {
|
||||
set_address (def, &G_FLOAT(pr, ddef->ofs));
|
||||
} else if (mode) {
|
||||
PR_Undefined (pr, "global", def->name);
|
||||
ret = 0;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
resolve_functions (progs_t *pr, sv_def_t *def, int mode)
|
||||
{
|
||||
dfunction_t *dfunc;
|
||||
int ret = 1;
|
||||
|
||||
if (mode == 2) {
|
||||
for (; def->name; def++)
|
||||
*(func_t *) def->field = G_FUNCTION (pr, def->offset);
|
||||
return 1;
|
||||
}
|
||||
for (; def->name; def++) {
|
||||
dfunc = PR_FindFunction (pr, def->name);
|
||||
if (dfunc) {
|
||||
*(func_t *) def->field = dfunc - pr->pr_functions;
|
||||
} else if (mode) {
|
||||
PR_Undefined (pr, "function", def->name);
|
||||
ret = 0;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
resolve_fields (progs_t *pr, sv_def_t *def, int mode)
|
||||
{
|
||||
ddef_t *ddef;
|
||||
int ret = 1;
|
||||
|
||||
if (mode == 2) {
|
||||
for (; def->name; def++)
|
||||
*(int *) def->field = def->offset;
|
||||
return 1;
|
||||
}
|
||||
for (; def->name; def++) {
|
||||
*(int *)def->field = -1;
|
||||
ddef = PR_FindField (pr, def->name);
|
||||
if (ddef) {
|
||||
*(int *)def->field = ddef->ofs;
|
||||
} else if (mode) {
|
||||
PR_Undefined (pr, "field", def->name);
|
||||
ret = 0;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
resolve (progs_t *pr)
|
||||
{
|
||||
sv_def_t *def;
|
||||
ddef_t *ddef;
|
||||
dfunction_t *f;
|
||||
void *global;
|
||||
func_t func;
|
||||
|
||||
int ret = 1;
|
||||
if (pr->progs->crc == nq_crc) {
|
||||
global = &G_FLOAT(pr, nq_self[0].offset);
|
||||
set_address (&nq_self[0], global);
|
||||
for (def = nq_defs; def->name; def++) {
|
||||
global = &G_FLOAT(pr, def->offset);
|
||||
set_address (def, global);
|
||||
}
|
||||
for (def = nq_funcs; def->name; def++) {
|
||||
func = G_FUNCTION (pr, def->offset);
|
||||
*(func_t *)def->field = func;
|
||||
}
|
||||
for (def = nq_fields; def->name; def++) {
|
||||
*(int *)def->field = def->offset;
|
||||
}
|
||||
resolve_globals (pr, nq_self, 2);
|
||||
resolve_globals (pr, nq_defs, 2);
|
||||
resolve_functions (pr, nq_funcs, 2);
|
||||
resolve_fields (pr, nq_fields, 2);
|
||||
} else {
|
||||
for (def = nq_self; def->name; def++) {
|
||||
ddef = PR_FindGlobal (&sv_pr_state, def->name);
|
||||
if (ddef) {
|
||||
global = &G_FLOAT(pr, ddef->ofs);
|
||||
set_address (def, global);
|
||||
}
|
||||
}
|
||||
for (def = nq_defs; def->name; def++) {
|
||||
global = PR_GetGlobalPointer (pr, def->name);
|
||||
set_address (def, global);
|
||||
}
|
||||
for (def = nq_funcs; def->name; def++) {
|
||||
*(func_t *)def->field = PR_GetFunctionIndex (pr, def->name);
|
||||
}
|
||||
for (def = nq_fields; def->name; def++) {
|
||||
*(int *)def->field = PR_GetFieldOffset (pr, def->name);
|
||||
}
|
||||
}
|
||||
for (def = nq_opt_defs; def->name; def++) {
|
||||
ddef = PR_FindGlobal (&sv_pr_state, def->name);
|
||||
if (ddef) {
|
||||
global = &G_FLOAT(pr, ddef->ofs);
|
||||
set_address (def, global);
|
||||
}
|
||||
}
|
||||
for (def = nq_opt_funcs; def->name; def++) {
|
||||
if ((f = ED_FindFunction (pr, def->name)) != NULL)
|
||||
*(func_t *)def->field = (func_t) (f - pr->pr_functions);
|
||||
}
|
||||
for (def = nq_opt_fields; def->name; def++) {
|
||||
*(int *)def->field = ED_GetFieldIndex (pr, def->name);
|
||||
if (!resolve_globals (pr, nq_self, 0))
|
||||
ret = 0;
|
||||
if (!resolve_globals (pr, nq_defs, 1))
|
||||
ret = 0;
|
||||
if (!resolve_functions (pr, nq_funcs, 1))
|
||||
ret = 0;
|
||||
if (!resolve_fields (pr, nq_fields, 1))
|
||||
ret = 0;
|
||||
}
|
||||
resolve_globals (pr, nq_opt_defs, 0);
|
||||
resolve_functions (pr, nq_opt_funcs, 0);
|
||||
resolve_fields (pr, nq_opt_fields, 0);
|
||||
// progs engine needs these globals anyway
|
||||
sv_pr_state.globals.self = sv_globals.self;
|
||||
sv_pr_state.globals.time = sv_globals.time;
|
||||
return 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
|||
|
|
@ -335,7 +335,7 @@ PF_calltimeofday (progs_t * pr)
|
|||
date_t date;
|
||||
dfunction_t *f;
|
||||
|
||||
if ((f = ED_FindFunction (pr, "timeofday")) != NULL) {
|
||||
if ((f = PR_FindFunction (pr, "timeofday")) != NULL) {
|
||||
|
||||
Sys_TimeOfDay (&date);
|
||||
|
||||
|
|
@ -547,7 +547,7 @@ qwe_load (progs_t * pr)
|
|||
size_t i;
|
||||
|
||||
for (i = 0; i < sizeof (qwe_func_list) / sizeof (qwe_func_list[0]); i++) {
|
||||
dfunction_t *f = ED_FindFunction (pr, qwe_func_list[i].name);
|
||||
dfunction_t *f = PR_FindFunction (pr, qwe_func_list[i].name);
|
||||
|
||||
*qwe_func_list[i].field = 0;
|
||||
if (f)
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ ED_Count_f (void)
|
|||
ED_Count (&sv_pr_state);
|
||||
}
|
||||
|
||||
void
|
||||
static void
|
||||
PR_Profile_f (void)
|
||||
{
|
||||
PR_Profile (&sv_pr_state);
|
||||
|
|
@ -183,7 +183,7 @@ typedef struct sv_def_s {
|
|||
|
||||
static sv_def_t qw_self[] = {
|
||||
{ev_entity, 28, "self", &sv_globals.self},
|
||||
{ev_entity, 0, ".self", &sv_globals.self},
|
||||
{ev_entity, 28, ".self", &sv_globals.self},
|
||||
{ev_void, 0, 0},
|
||||
};
|
||||
|
||||
|
|
@ -358,66 +358,102 @@ set_address (sv_def_t *def, void *address)
|
|||
}
|
||||
}
|
||||
|
||||
static int
|
||||
resolve_globals (progs_t *pr, sv_def_t *def, int mode)
|
||||
{
|
||||
ddef_t *ddef;
|
||||
int ret = 1;
|
||||
|
||||
if (mode == 2) {
|
||||
for (; def->name; def++)
|
||||
set_address (def, &G_FLOAT (pr, def->offset));
|
||||
return 1;
|
||||
}
|
||||
for (; def->name; def++) {
|
||||
ddef = PR_FindGlobal (pr, def->name);
|
||||
if (ddef) {
|
||||
set_address (def, &G_FLOAT(pr, ddef->ofs));
|
||||
} else if (mode) {
|
||||
PR_Undefined (pr, "global", def->name);
|
||||
ret = 0;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
resolve_functions (progs_t *pr, sv_def_t *def, int mode)
|
||||
{
|
||||
dfunction_t *dfunc;
|
||||
int ret = 1;
|
||||
|
||||
if (mode == 2) {
|
||||
for (; def->name; def++)
|
||||
*(func_t *) def->field = G_FUNCTION (pr, def->offset);
|
||||
return 1;
|
||||
}
|
||||
for (; def->name; def++) {
|
||||
dfunc = PR_FindFunction (pr, def->name);
|
||||
if (dfunc) {
|
||||
*(func_t *) def->field = dfunc - pr->pr_functions;
|
||||
} else if (mode) {
|
||||
PR_Undefined (pr, "function", def->name);
|
||||
ret = 0;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
resolve_fields (progs_t *pr, sv_def_t *def, int mode)
|
||||
{
|
||||
ddef_t *ddef;
|
||||
int ret = 1;
|
||||
|
||||
if (mode == 2) {
|
||||
for (; def->name; def++)
|
||||
*(int *) def->field = def->offset;
|
||||
return 1;
|
||||
}
|
||||
for (; def->name; def++) {
|
||||
*(int *)def->field = -1;
|
||||
ddef = PR_FindField (pr, def->name);
|
||||
if (ddef) {
|
||||
*(int *)def->field = ddef->ofs;
|
||||
} else if (mode) {
|
||||
PR_Undefined (pr, "field", def->name);
|
||||
ret = 0;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
resolve (progs_t *pr)
|
||||
{
|
||||
sv_def_t *def;
|
||||
ddef_t *ddef;
|
||||
dfunction_t *f;
|
||||
void *global;
|
||||
func_t func;
|
||||
|
||||
int ret = 1;
|
||||
if (pr->progs->crc == qw_crc) {
|
||||
global = &G_FLOAT(pr, qw_self[0].offset);
|
||||
set_address (&qw_self[0], global);
|
||||
for (def = qw_defs; def->name; def++) {
|
||||
global = &G_FLOAT(pr, def->offset);
|
||||
set_address (def, global);
|
||||
}
|
||||
for (def = qw_funcs; def->name; def++) {
|
||||
func = G_FUNCTION (pr, def->offset);
|
||||
*(func_t *)def->field = func;
|
||||
}
|
||||
for (def = qw_fields; def->name; def++) {
|
||||
*(int *)def->field = def->offset;
|
||||
}
|
||||
resolve_globals (pr, qw_self, 2);
|
||||
resolve_globals (pr, qw_defs, 2);
|
||||
resolve_functions (pr, qw_funcs, 2);
|
||||
resolve_fields (pr, qw_fields, 2);
|
||||
} else {
|
||||
for (def = qw_self; def->name; def++) {
|
||||
ddef = PR_FindGlobal (&sv_pr_state, def->name);
|
||||
if (ddef) {
|
||||
global = &G_FLOAT(pr, ddef->ofs);
|
||||
set_address (def, global);
|
||||
}
|
||||
}
|
||||
for (def = qw_defs; def->name; def++) {
|
||||
global = PR_GetGlobalPointer (pr, def->name);
|
||||
set_address (def, global);
|
||||
}
|
||||
for (def = qw_funcs; def->name; def++) {
|
||||
*(func_t *)def->field = PR_GetFunctionIndex (pr, def->name);
|
||||
}
|
||||
for (def = qw_fields; def->name; def++) {
|
||||
*(int *)def->field = PR_GetFieldOffset (pr, def->name);
|
||||
}
|
||||
}
|
||||
for (def = qw_opt_defs; def->name; def++) {
|
||||
ddef = PR_FindGlobal (&sv_pr_state, def->name);
|
||||
if (ddef) {
|
||||
global = &G_FLOAT(pr, ddef->ofs);
|
||||
set_address (def, global);
|
||||
}
|
||||
}
|
||||
for (def = qw_opt_funcs; def->name; def++) {
|
||||
if ((f = ED_FindFunction (pr, def->name)) != NULL)
|
||||
*(func_t *)def->field = (func_t) (f - pr->pr_functions);
|
||||
}
|
||||
for (def = qw_opt_fields; def->name; def++) {
|
||||
*(int *)def->field = ED_GetFieldIndex (pr, def->name);
|
||||
if (!resolve_globals (pr, qw_self, 0))
|
||||
ret = 0;
|
||||
if (!resolve_globals (pr, qw_defs, 1))
|
||||
ret = 0;
|
||||
if (!resolve_functions (pr, qw_funcs, 1))
|
||||
ret = 0;
|
||||
if (!resolve_fields (pr, qw_fields, 1))
|
||||
ret = 0;
|
||||
}
|
||||
resolve_globals (pr, qw_opt_defs, 0);
|
||||
resolve_functions (pr, qw_opt_funcs, 0);
|
||||
resolve_fields (pr, qw_opt_fields, 0);
|
||||
// progs engine needs these globals anyway
|
||||
sv_pr_state.globals.self = sv_globals.self;
|
||||
sv_pr_state.globals.time = sv_globals.time;
|
||||
return 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
|||
|
|
@ -167,9 +167,12 @@ main (int argc, char **argv)
|
|||
pr_argv[i] = PR_SetTempString (&pr, argv[1 + i]);
|
||||
pr_argv[i] = 0;
|
||||
|
||||
main_func = PR_GetFunctionIndex (&pr, "main");
|
||||
P_POINTER (&pr, 0) = pr_argc;
|
||||
P_POINTER (&pr, 1) = POINTER_TO_PROG (&pr, pr_argv);
|
||||
if ((dfunc = PR_FindFunction (&pr, "main")))
|
||||
main_func = dfunc - pr.pr_functions;
|
||||
else
|
||||
PR_Undefined (&pr, "function", "main");
|
||||
P_INT (&pr, 0) = pr_argc;
|
||||
P_POINTER (&pr, 1) = PR_SetPointer (&pr, pr_argv);
|
||||
PR_ExecuteProgram (&pr, main_func);
|
||||
PR_PopFrame (&pr);
|
||||
return R_INT (&pr);
|
||||
|
|
|
|||
Loading…
Reference in a new issue