qf
/
quakeforge
mirror of https://git.code.sf.net/p/quake/quakeforge
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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 2004-11-05 11:49:00 +00:00 committed by Jeff Teunissen
parent b46cff08aa
commit f5bc90a53a
12 changed files with 245 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
include/QF/progs.h
View File

@ -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;
}

6
libs/console/menu.c
View File

@ -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;
}

2
libs/gamecode/builtins/pr_cmds.c
View File

@ -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;

6
libs/gamecode/engine/pr_debug.c
View File

@ -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

23
libs/gamecode/engine/pr_edict.c
View File

@ -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;

20
libs/gamecode/engine/pr_parse.c
View File

@ -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);

91
libs/gamecode/engine/pr_resolve.c
View File

@ -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);

24
libs/ruamoko/rua_obj.c
View File

@ -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)) {

140
nq/source/sv_progs.c
View File

@ -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

4
qw/source/sv_pr_qwe.c
View File

@ -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)

142
qw/source/sv_progs.c
View File

@ -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

9
tools/qwaq/main.c
View File

@ -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);