clean up some redundant progs functions (may be broken for a while)

This is an imperfect revision of history.

include/QF/progs.h

@@ -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 *PR_FieldAtOfs (progs_t *pr, int ofs);
-ddef_t *ED_FindField (progs_t *pr, const char *name);
+ddef_t *PR_GlobalAtOfs (progs_t *pr, int ofs);
-int ED_GetFieldIndex (progs_t *pr, const char *name);
-dfunction_t *ED_FindFunction (progs_t *pr, const char *name);
 
-int PR_AccessField (progs_t *pr, const char *name, etype_t type,
+ddef_t *PR_FindField (progs_t *pr, const char *name);
-					const char *file, int line);
+ddef_t *PR_FindGlobal (progs_t *pr, const char *name);
-
+dfunction_t *PR_FindFunction (progs_t *pr, const char *name);
-//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);
 
 #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;
 }

libs/console/menu.c

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

libs/gamecode/builtins/pr_cmds.c

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

libs/gamecode/engine/pr_debug.c

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

libs/gamecode/engine/pr_edict.c

@@ -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");
+	solid_def = PR_FindField (pr, "solid");
-	model_def = ED_FindField (pr, "model");
+	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)
+ED_NumForEdict (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)
 {
 	int		b;
 

libs/gamecode/engine/pr_parse.c

@@ -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 = PR_FindField (pr, "classname");
-		def = ED_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);

libs/gamecode/engine/pr_resolve.c

@@ -55,11 +55,8 @@ static __attribute__ ((unused)) const char rcsid[] =
 #include "compat.h"
 
 
-/*
+ddef_t *
-	ED_GlobalAtOfs
+PR_GlobalAtOfs (progs_t * pr, int ofs)
-*/
-ddef_t     *
-ED_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;
 }
 
-/*
+ddef_t *
-	ED_FieldAtOfs
+PR_FieldAtOfs (progs_t * pr, int ofs)
-*/
-ddef_t     *
-ED_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;
 }
 
-/*
+ddef_t *
-	ED_FindField
+PR_FindField (progs_t * pr, const char *name)
-*/
-ddef_t     *
-ED_FindField (progs_t * pr, const char *name)
 {
 	return  Hash_Find (pr->field_hash, name);
 }
 
-int
+ddef_t *
-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     *
 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);

libs/ruamoko/rua_obj.c

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

nq/source/sv_progs.c

@@ -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;
+	int         ret = 1;
-	ddef_t     *ddef;
-	dfunction_t *f;
-	void       *global;
-	func_t      func;
-
 	if (pr->progs->crc == nq_crc) {
-		global = &G_FLOAT(pr, nq_self[0].offset);
+		resolve_globals (pr, nq_self, 2);
-		set_address (&nq_self[0], global);
+		resolve_globals (pr, nq_defs, 2);
-		for (def = nq_defs; def->name; def++) {
+		resolve_functions (pr, nq_funcs, 2);
-			global = &G_FLOAT(pr, def->offset);
+		resolve_fields (pr, nq_fields, 2);
-			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;
-		}
 	} else {
-		for (def = nq_self; def->name; def++) {
+		if (!resolve_globals (pr, nq_self, 0))
-			ddef = PR_FindGlobal (&sv_pr_state, def->name);
+			ret = 0;
-			if (ddef) {
+		if (!resolve_globals (pr, nq_defs, 1))
-				global = &G_FLOAT(pr, ddef->ofs);
+			ret = 0;
-				set_address (def, global);
+		if (!resolve_functions (pr, nq_funcs, 1))
-			}
+			ret = 0;
-		}
+		if (!resolve_fields (pr, nq_fields, 1))
-		for (def = nq_defs; def->name; def++) {
+			ret = 0;
-			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);
 	}
+	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

qw/source/sv_pr_qwe.c

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

qw/source/sv_progs.c

@@ -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;
+	int         ret = 1;
-	ddef_t     *ddef;
-	dfunction_t *f;
-	void       *global;
-	func_t      func;
-
 	if (pr->progs->crc == qw_crc) {
-		global = &G_FLOAT(pr, qw_self[0].offset);
+		resolve_globals (pr, qw_self, 2);
-		set_address (&qw_self[0], global);
+		resolve_globals (pr, qw_defs, 2);
-		for (def = qw_defs; def->name; def++) {
+		resolve_functions (pr, qw_funcs, 2);
-			global = &G_FLOAT(pr, def->offset);
+		resolve_fields (pr, qw_fields, 2);
-			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;
-		}
 	} else {
-		for (def = qw_self; def->name; def++) {
+		if (!resolve_globals (pr, qw_self, 0))
-			ddef = PR_FindGlobal (&sv_pr_state, def->name);
+			ret = 0;
-			if (ddef) {
+		if (!resolve_globals (pr, qw_defs, 1))
-				global = &G_FLOAT(pr, ddef->ofs);
+			ret = 0;
-				set_address (def, global);
+		if (!resolve_functions (pr, qw_funcs, 1))
-			}
+			ret = 0;
-		}
+		if (!resolve_fields (pr, qw_fields, 1))
-		for (def = qw_defs; def->name; def++) {
+			ret = 0;
-			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);
 	}
+	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

tools/qwaq/main.c

@@ -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");
+	if ((dfunc = PR_FindFunction (&pr, "main")))
-	P_POINTER (&pr, 0) = pr_argc;
+		main_func = dfunc - pr.pr_functions;
-	P_POINTER (&pr, 1) = POINTER_TO_PROG (&pr, pr_argv);
+	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);