quakeforge/libs/ruamoko/rua_obj.c

/*
	rua_obj.c

	Progs Obj runtime support

	Copyright (C) 2001 Bill Currie

	Author: Bill Currie <bill@taniwha.org>
	Date: 2002/7/21

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation; either version 2
	of the License, or (at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

	See the GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to:

		Free Software Foundation, Inc.
		59 Temple Place - Suite 330
		Boston, MA  02111-1307, USA

*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif

#if defined(_WIN32) && defined(HAVE_MALLOC_H)
#include <malloc.h>
#endif

#include "qfalloca.h"

#include "QF/cvar.h"
#include "QF/dstring.h"
#include "QF/hash.h"
#include "QF/mathlib.h"
#include "QF/pr_obj.h"
#include "QF/progs.h"
#include "QF/ruamoko.h"
#include "QF/sys.h"

#include "compat.h"
#include "rua_internal.h"

#define always_inline inline __attribute__((__always_inline__))

typedef struct obj_list_s {
	struct obj_list_s *next;
	void       *data;
} obj_list;

typedef struct dtable_s {
	struct dtable_s *next;
	struct dtable_s **prev;
	size_t      size;
	func_t     *imp;
} dtable_t;

typedef struct probj_resources_s {
	progs_t    *pr;
	unsigned    selector_index;
	unsigned    selector_index_max;
	obj_list  **selector_sels;
	string_t   *selector_names;
	PR_RESMAP (dtable_t) dtables;
	dtable_t   *dtable_list;
	func_t      obj_forward;
	pr_sel_t   *forward_selector;
	dstring_t  *msg;
	hashtab_t  *selector_hash;
	hashtab_t  *classes;
	hashtab_t  *protocols;
	hashtab_t  *load_methods;
	obj_list   *unresolved_classes;
	obj_list   *unclaimed_categories;
	obj_list   *uninitialized_statics;
	obj_list   *unclaimed_proto_list;
	obj_list   *module_list;
	obj_list   *class_tree_list;
} probj_t;

static dtable_t *
dtable_new (probj_t *probj)
{
	dtable_t   *dtable = PR_RESNEW (probj->dtables);
	dtable->next = probj->dtable_list;
	dtable->prev = &probj->dtable_list;
	if (probj->dtable_list) {
		probj->dtable_list->prev = &dtable->next;
	}
	probj->dtable_list = dtable;
	return dtable;
}

static void
dtable_reset (probj_t *probj)
{
	PR_RESRESET (probj->dtables);
	probj->dtable_list = 0;
}

static inline dtable_t *
dtable_get (probj_t *probj, int index)
{
	return PR_RESGET (probj->dtables, index);
}

static inline int __attribute__((pure))
dtable_index (probj_t *probj, dtable_t *dtable)
{
	return PR_RESINDEX (probj->dtables, dtable);
}

static always_inline dtable_t * __attribute__((pure))
get_dtable (probj_t *probj, const char *name, int index)
{
	dtable_t   *dtable = dtable_get (probj, index);

	if (!dtable) {
		PR_RunError (probj->pr, "invalid dtable index in %s", name);
	}
	return dtable;
}

static obj_list *obj_list_free_list;

static obj_list *
obj_list_new (void)
{
	int         i;
	obj_list   *l;

	if (!obj_list_free_list) {
		obj_list_free_list = calloc (128, sizeof (obj_list));
		for (i = 0; i < 127; i++)
			obj_list_free_list[i].next = &obj_list_free_list[i + 1];
	}
	l = obj_list_free_list;
	obj_list_free_list = l->next;
	l->next = 0;
	return l;
}

static void
obj_list_free (obj_list *l)
{
	obj_list   *e;

	if (!l)
		return;

	for (e = l; e->next; e = e->next)
		;
	e->next = obj_list_free_list;
	obj_list_free_list = l;
}

static inline obj_list *
list_cons (void *data, obj_list *next)
{
	obj_list   *l = obj_list_new ();
	l->data = data;
	l->next = next;
	return l;
}

static inline void
list_remove (obj_list **list)
{
	if ((*list)->next) {
		obj_list   *l = *list;
		*list = (*list)->next;
		l->next = 0;
		obj_list_free (l);
	} else {
		obj_list_free (*list);
		*list = 0;
	}
}

typedef struct class_tree {
	pr_class_t *class;
	obj_list   *subclasses;
} class_tree;

class_tree *class_tree_free_list;

static class_tree *
class_tree_new (void)
{
	int         i;
	class_tree *t;

	if (!class_tree_free_list) {
		class_tree_free_list = calloc (128, sizeof (class_tree));
		for (i = 0; i < 127; i++) {
			class_tree *x = &class_tree_free_list[i];
			x->subclasses = (obj_list *) (x + 1);
		}
	}
	t = class_tree_free_list;
	class_tree_free_list = (class_tree *) t->subclasses;
	t->subclasses = 0;
	return t;
}

static int
class_is_subclass_of_class (probj_t *probj, pr_class_t *class,
							pr_class_t *superclass)
{
	while (class) {
		if (class == superclass)
			return 1;
		if (!class->super_class)
			break;
		class = Hash_Find (probj->classes,
						   PR_GetString (probj->pr, class->super_class));
	}
	return 0;
}

static class_tree *
create_tree_of_subclasses_inherited_from (probj_t *probj, pr_class_t *bottom,
										  pr_class_t *upper)
{
	progs_t    *pr = probj->pr;
	const char *super_class = PR_GetString (pr, bottom->super_class);
	pr_class_t *superclass;
	class_tree *tree, *prev;

	superclass = bottom->super_class ? Hash_Find (probj->classes, super_class)
									 : 0;
	tree = prev = class_tree_new ();
	prev->class = bottom;
	while (superclass != upper) {
		tree = class_tree_new ();
		tree->class = superclass;
		tree->subclasses = list_cons (prev, tree->subclasses);
		super_class = PR_GetString (pr, superclass->super_class);
		superclass = (superclass->super_class ? Hash_Find (probj->classes,
														   super_class)
											  : 0);
		prev = tree;
	}
	return tree;
}

static class_tree *
_obj_tree_insert_class (probj_t *probj, class_tree *tree, pr_class_t *class)
{
	progs_t    *pr = probj->pr;
	obj_list   *subclasses;
	class_tree *new_tree;

	if (!tree)
		return create_tree_of_subclasses_inherited_from (probj, class, 0);
	if (class == tree->class)
		return tree;
	if ((class->super_class ? Hash_Find (probj->classes,
										 PR_GetString (pr,
											 		   class->super_class))
							: 0) == tree->class) {
		obj_list   *list = tree->subclasses;
		class_tree *node;

		while (list) {
			if (((class_tree *) list->data)->class == class)
				return tree;
			list = list->next;
		}
		node = class_tree_new ();
		node->class = class;
		tree->subclasses = list_cons (node, tree->subclasses);
		return tree;
	}
	if (!class_is_subclass_of_class (probj, class, tree->class))
		return 0;
	for (subclasses = tree->subclasses; subclasses;
		 subclasses = subclasses->next) {
		pr_class_t *aclass = ((class_tree *)subclasses->data)->class;
		if (class_is_subclass_of_class (probj, class, aclass)) {
			subclasses->data = _obj_tree_insert_class (probj, subclasses->data,
													   class);
			return tree;
		}
	}
	new_tree = create_tree_of_subclasses_inherited_from (probj, class,
														 tree->class);
	tree->subclasses = list_cons (new_tree, tree->subclasses);
	return tree;
}

static void
obj_tree_insert_class (probj_t *probj, pr_class_t *class)
{
	obj_list   *list_node;
	class_tree *tree;

	list_node = probj->class_tree_list;
	while (list_node) {
		tree = _obj_tree_insert_class (probj, list_node->data, class);
		if (tree) {
			list_node->data = tree;
			break;
		} else {
			list_node = list_node->next;
		}
	}
	if (!list_node) {
		tree = _obj_tree_insert_class (probj, 0, class);
		probj->class_tree_list = list_cons (tree, probj->class_tree_list);
	}
}

static void
obj_create_classes_tree (probj_t *probj, pr_module_t *module)
{
	progs_t    *pr = probj->pr;
	pr_symtab_t *symtab = &G_STRUCT (pr, pr_symtab_t, module->symtab);
	int         i;

	for (i = 0; i < symtab->cls_def_cnt; i++) {
		pr_class_t *class = &G_STRUCT (pr, pr_class_t, symtab->defs[i]);
		obj_tree_insert_class (probj, class);
	}
}

static void
obj_destroy_class_tree_node (probj_t *probj, class_tree *tree, int level)
{
	tree->subclasses = (obj_list *) class_tree_free_list;
	class_tree_free_list = tree;
}

static void
obj_preorder_traverse (probj_t *probj, class_tree *tree, int level,
					   void (*func) (probj_t *, class_tree *, int))
{
	obj_list   *node;

	func (probj, tree, level);
	for (node = tree->subclasses; node; node = node->next)
		obj_preorder_traverse (probj, node->data, level + 1, func);
}

static void
obj_postorder_traverse (probj_t *probj, class_tree *tree, int level,
						void (*func) (probj_t *, class_tree *, int))
{
	obj_list   *node;

	for (node = tree->subclasses; node; node = node->next)
		obj_postorder_traverse (probj, node->data, level + 1, func);
	func (probj, tree, level);
}

static const char *
selector_get_key (const void *s, void *_probj)
{
	__auto_type probj = (probj_t *) _probj;
	return PR_GetString (probj->pr, probj->selector_names[(intptr_t) s]);
}

static const char *
class_get_key (const void *c, void *_probj)
{
	__auto_type probj = (probj_t *) _probj;
	return PR_GetString (probj->pr, ((pr_class_t *)c)->name);
}

static const char *
protocol_get_key (const void *p, void *_probj)
{
	__auto_type probj = (probj_t *) _probj;
	return PR_GetString (probj->pr, ((pr_protocol_t *)p)->protocol_name);
}

static uintptr_t
load_methods_get_hash (const void *m, void *_probj)
{
	return (uintptr_t) m;
}

static int
load_methods_compare (const void *m1, const void *m2, void *_probj)
{
	return m1 == m2;
}

static inline int
sel_eq (pr_sel_t *s1, pr_sel_t *s2)
{
	if (!s1 || !s2)
		return s1 == s2;
	return s1->sel_id == s2->sel_id;
}

static int
object_is_instance (probj_t *probj, pr_id_t *object)
{
	progs_t *pr = probj->pr;
	pr_class_t *class;

	if (object) {
		class = &G_STRUCT (pr, pr_class_t, object->class_pointer);
		return PR_CLS_ISCLASS (class);
	}
	return 0;
}

static string_t
object_get_class_name (probj_t *probj, pr_id_t *object)
{
	progs_t    *pr = probj->pr;
	pr_class_t *class;

	if (object) {
		class = &G_STRUCT (pr, pr_class_t, object->class_pointer);
		if (PR_CLS_ISCLASS (class)) {
			R_INT (pr) = class->name;
			return class->name;
		}
		if (PR_CLS_ISMETA (class)) {
			R_INT (pr) = ((pr_class_t *)object)->name;
			return ((pr_class_t *)object)->name;
		}
	}
	return PR_SetString (pr, "Nil");
}

//====================================================================

static void
finish_class (probj_t *probj, pr_class_t *class, pointer_t object_ptr)
{
	progs_t    *pr = probj->pr;
	pr_class_t *meta = &G_STRUCT (pr, pr_class_t, class->class_pointer);
	pr_class_t *val;

	meta->class_pointer = object_ptr;
	if (class->super_class) {
		const char *super_class = PR_GetString (pr, class->super_class);
		const char *class_name = PR_GetString (pr, class->name);
		val = Hash_Find (probj->classes, super_class);
		if (!val)
			PR_Error (pr, "broken class %s: super class %s not found",
					  class_name, super_class);
		meta->super_class = val->class_pointer;
		class->super_class = PR_SetPointer (pr, val);
	} else {
		pointer_t  *ml = &meta->methods;
		while (*ml)
			ml = &G_STRUCT (pr, pr_method_list_t, *ml).method_next;
		*ml = class->methods;
	}
	Sys_MaskPrintf (SYS_rua_obj, "    %x %x %x\n", meta->class_pointer,
					meta->super_class, class->super_class);
}

//====================================================================

static int
add_sel_name (probj_t *probj, const char *name)
{
	int         ind = ++probj->selector_index;
	int         size, i;

	if (probj->selector_index >= probj->selector_index_max) {
		size = probj->selector_index_max + 128;
		probj->selector_sels = realloc (probj->selector_sels,
										size * sizeof (obj_list *));
		probj->selector_names = realloc (probj->selector_names,
										 size * sizeof (string_t));
		for (i = probj->selector_index_max; i < size; i++) {
			probj->selector_sels[i] = 0;
			probj->selector_names[i] = 0;
		}
		probj->selector_index_max = size;
	}
	probj->selector_names[ind] = PR_SetString (probj->pr, name);
	return ind;
}

static pr_sel_t *
sel_register_typed_name (probj_t *probj, const char *name, const char *types,
						 pr_sel_t *sel)
{
	progs_t    *pr = probj->pr;
	intptr_t	index;
	int			is_new = 0;
	obj_list   *l;

	index = (intptr_t) Hash_Find (probj->selector_hash, name);
	if (index) {
		for (l = probj->selector_sels[index]; l; l = l->next) {
			pr_sel_t   *s = l->data;
			if (!types || !s->sel_types) {
				if (!s->sel_types && !types) {
					if (sel) {
						sel->sel_id = index;
						goto done;
					}
					return s;
				}
			} else if (strcmp (PR_GetString (pr, s->sel_types), types) == 0) {
				if (sel) {
					sel->sel_id = index;
					goto done;
				}
				return s;
			}
		}
	} else {
		Sys_MaskPrintf (SYS_rua_obj, "    Registering SEL %s %s\n",
						name, types);
		index = add_sel_name (probj, name);
		is_new = 1;
	}
	if (!sel)
		sel = PR_Zone_Malloc (pr, sizeof (pr_sel_t));

	sel->sel_id = index;
	sel->sel_types = PR_SetString (pr, types);

	l = obj_list_new ();
	l->data = sel;
	l->next = probj->selector_sels[index];
	probj->selector_sels[index] = l;

	if (is_new)
		Hash_Add (probj->selector_hash, (void *) index);
done:
	Sys_MaskPrintf (SYS_rua_obj, "        %d @ %x\n",
					sel->sel_id, PR_SetPointer (pr, sel));
	return sel;
}

static pr_sel_t *
sel_register_name (probj_t *probj, const char *name)
{
	return sel_register_typed_name (probj, name, "", 0);
}

static void
obj_register_selectors_from_description_list (probj_t *probj,
		pr_method_description_list_t *method_list)
{
	progs_t    *pr = probj->pr;
	int         i;

	if (!method_list) {
		return;
	}
	for (i = 0; i < method_list->count; i++) {
		pr_method_description_t *method = &method_list->list[i];
		const char *name = PR_GetString (pr, method->name);
		const char *types = PR_GetString (pr, method->types);
		pr_sel_t   *sel = sel_register_typed_name (probj, name, types, 0);
		method->name = PR_SetPointer (pr, sel);
	}
}

static void
obj_register_selectors_from_list (probj_t *probj,
								  pr_method_list_t *method_list)
{
	progs_t    *pr = probj->pr;
	int         i;

	for (i = 0; i < method_list->method_count; i++) {
		pr_method_t *method = &method_list->method_list[i];
		const char *name = PR_GetString (pr, method->method_name);
		const char *types = PR_GetString (pr, method->method_types);
		pr_sel_t   *sel = sel_register_typed_name (probj, name, types, 0);
		method->method_name = PR_SetPointer (pr, sel);
	}
}

static void
obj_register_selectors_from_class (probj_t *probj, pr_class_t *class)
{
	progs_t    *pr = probj->pr;
	pr_method_list_t *method_list = &G_STRUCT (pr, pr_method_list_t,
											   class->methods);
	while (method_list) {
		obj_register_selectors_from_list (probj, method_list);
		method_list = &G_STRUCT (pr, pr_method_list_t,
								 method_list->method_next);
	}
}

static void obj_init_protocols (probj_t *probj, pr_protocol_list_t *protos);

static void
obj_init_protocol (probj_t *probj, pr_class_t *proto_class,
				   pr_protocol_t *proto)
{
	progs_t    *pr = probj->pr;

	if (!proto->class_pointer) {
		const char *protocol_name = PR_GetString (pr, proto->protocol_name);
		proto->class_pointer = PR_SetPointer (pr, proto_class);
		obj_register_selectors_from_description_list (probj,
				&G_STRUCT (pr, pr_method_description_list_t,
						   proto->instance_methods));
		obj_register_selectors_from_description_list (probj,
				&G_STRUCT (pr, pr_method_description_list_t,
						   proto->class_methods));
		if (!Hash_Find (probj->protocols, protocol_name)) {
			Hash_Add (probj->protocols, proto);
		}
		obj_init_protocols (probj, &G_STRUCT (pr, pr_protocol_list_t,
											  proto->protocol_list));
	} else {
		if (proto->class_pointer != PR_SetPointer (pr, proto_class))
			PR_RunError (pr, "protocol broken");
	}
}

static void
obj_init_protocols (probj_t *probj, pr_protocol_list_t *protos)
{
	progs_t    *pr = probj->pr;
	pr_class_t *proto_class;
	pr_protocol_t *proto;
	int         i;

	if (!protos)
		return;

	if (!(proto_class = Hash_Find (probj->classes, "Protocol"))) {
		probj->unclaimed_proto_list = list_cons (protos,
												 probj->unclaimed_proto_list);
		return;
	}

	for (i = 0; i < protos->count; i++) {
		proto = &G_STRUCT (pr, pr_protocol_t, protos->list[i]);
		obj_init_protocol (probj, proto_class, proto);
	}
}

static void
class_add_method_list (probj_t *probj, pr_class_t *class,
					   pr_method_list_t *list)
{
	progs_t    *pr = probj->pr;
	int         i;

	for (i = 0; i < list->method_count; i++) {
		pr_method_t *method = &list->method_list[i];
		if (method->method_name) {
			const char *name = PR_GetString (pr, method->method_name);
			const char *types = PR_GetString (pr, method->method_types);
			pr_sel_t   *sel = sel_register_typed_name (probj, name, types, 0);
			method->method_name = PR_SetPointer (pr, sel);
		}
	}

	list->method_next = class->methods;
	class->methods = PR_SetPointer (pr, list);
}

static void
obj_class_add_protocols (probj_t *probj, pr_class_t *class,
						 pr_protocol_list_t *protos)
{
	if (!protos)
		return;

	protos->next = class->protocols;
	class->protocols = protos->next;
}

static void
finish_category (probj_t *probj, pr_category_t *category, pr_class_t *class)
{
	progs_t    *pr = probj->pr;
	pr_method_list_t *method_list;
	pr_protocol_list_t *protocol_list;

	if (category->instance_methods) {
		method_list = &G_STRUCT (pr, pr_method_list_t,
								 category->instance_methods);
		class_add_method_list (probj, class, method_list);
	}
	if (category->class_methods) {
		pr_class_t *meta = &G_STRUCT (pr, pr_class_t, class->class_pointer);
		method_list = &G_STRUCT (pr, pr_method_list_t,
								 category->class_methods);
		class_add_method_list (probj, meta, method_list);
	}
	if (category->protocols) {
		protocol_list = &G_STRUCT (pr, pr_protocol_list_t,
								   category->protocols);
		obj_init_protocols (probj, protocol_list);
		obj_class_add_protocols (probj, class, protocol_list);
	}
}

static void
obj_send_message_in_list (probj_t *probj, pr_method_list_t *method_list,
						  pr_class_t *class, pr_sel_t *op)
{
	progs_t    *pr = probj->pr;
	int         i;

	if (!method_list)
		return;

	obj_send_message_in_list (probj, &G_STRUCT (pr, pr_method_list_t,
												method_list->method_next),
							  class, op);

	for (i = 0; i < method_list->method_count; i++) {
		pr_method_t *mth = &method_list->method_list[i];
		if (mth->method_name && sel_eq (&G_STRUCT (pr, pr_sel_t,
												   mth->method_name), op)
			&& !Hash_FindElement (probj->load_methods,
								  (void *) (intptr_t) mth->method_imp)) {
			Hash_AddElement (probj->load_methods,
							 (void *) (intptr_t) mth->method_imp);
			//FIXME need to wrap in save/restore params?
			PR_ExecuteProgram (pr, mth->method_imp);
			break;
		}
	}
}

static void
send_load (probj_t *probj, class_tree *tree, int level)
{
	progs_t    *pr = probj->pr;
	pr_sel_t   *load_sel = sel_register_name (probj, "load");
	pr_class_t *class = tree->class;
	pr_class_t *meta = &G_STRUCT (pr, pr_class_t, class->class_pointer);
	pr_method_list_t *method_list = &G_STRUCT (pr, pr_method_list_t,
											   meta->methods);

	obj_send_message_in_list (probj, method_list, class, load_sel);
}

static void
obj_send_load (probj_t *probj)
{
	progs_t    *pr = probj->pr;
	obj_list   *m;

	if (probj->unresolved_classes) {
		pr_class_t *class = probj->unresolved_classes->data;
		const char *super_class = PR_GetString (pr, class->super_class);
		while (Hash_Find (probj->classes, super_class)) {
			list_remove (&probj->unresolved_classes);
			if (probj->unresolved_classes) {
				class = probj->unresolved_classes->data;
				super_class = PR_GetString (pr, class->super_class);
			} else {
				break;
			}
		}
		if (probj->unresolved_classes)
			return;
	}

	//XXX constant string stuff here (see init.c in libobjc source)

	for (m = probj->module_list; m; m = m->next)
		obj_create_classes_tree (probj, m->data);
	while (probj->class_tree_list) {
		obj_preorder_traverse (probj, probj->class_tree_list->data, 0,
							   send_load);
		obj_postorder_traverse (probj, probj->class_tree_list->data, 0,
								obj_destroy_class_tree_node);
		list_remove (&probj->class_tree_list);
	}
	//XXX callback
	//for (m = probj->module_list; m; m = m->next)
	//	obj_create_classes_tree (probj, m->data);
	obj_list_free (probj->module_list);
	probj->module_list = 0;
}

static pr_method_t *
obj_find_message (probj_t *probj, pr_class_t *class, pr_sel_t *selector)
{
	progs_t    *pr = probj->pr;
	pr_class_t *c = class;
	pr_method_list_t *method_list;
	pr_method_t *method;
	pr_sel_t   *sel;
	int         i;
	int         dev = developer->int_val;
	string_t   *names;

	if (dev & SYS_rua_msg) {
		names = probj->selector_names;
		Sys_Printf ("Searching for %s\n",
					PR_GetString (pr, names[selector->sel_id]));
	}
	while (c) {
		if (dev & SYS_rua_msg)
			Sys_Printf ("Checking class %s @ %x\n",
						PR_GetString (pr, c->name),
						PR_SetPointer (pr, c));
		method_list = &G_STRUCT (pr, pr_method_list_t, c->methods);
		while (method_list) {
			if (dev & SYS_rua_msg) {
				Sys_Printf ("method list %x\n",
							PR_SetPointer (pr, method_list));
			}
			for (i = 0, method = method_list->method_list;
				 i < method_list->method_count; i++, method++) {
				sel = &G_STRUCT (pr, pr_sel_t, method->method_name);
				if (developer->int_val & SYS_rua_msg) {
					names = probj->selector_names;
					Sys_Printf ("  %s\n",
								PR_GetString (pr, names[sel->sel_id]));
				}
				if (sel->sel_id == selector->sel_id) {
					if (dev & SYS_rua_msg) {
						names = probj->selector_names;
						Sys_Printf ("found %s: %x\n",
									PR_GetString (pr, names[selector->sel_id]),
									method->method_imp);
					}
					return method;
				}
			}
			method_list = &G_STRUCT (pr, pr_method_list_t,
									 method_list->method_next);
		}
		c = c->super_class ? &G_STRUCT (pr, pr_class_t, c->super_class) : 0;
	}
	return 0;
}

static void
obj_send_initialize (probj_t *probj, pr_class_t *class)
{
	progs_t    *pr = probj->pr;
	pr_method_list_t *method_list;
	pr_method_t *method;
	pr_sel_t   *sel;
	pr_class_t *class_pointer;
	pr_sel_t   *selector = sel_register_name (probj, "initialize");
	int         i;

	if (PR_CLS_ISINITIALIZED (class))
		return;
	class_pointer = &G_STRUCT (pr, pr_class_t, class->class_pointer);
	PR_CLS_SETINITIALIZED (class);
	PR_CLS_SETINITIALIZED (class_pointer);
	if (class->super_class)
		obj_send_initialize (probj, &G_STRUCT (pr, pr_class_t,
											   class->super_class));

	method_list = &G_STRUCT (pr, pr_method_list_t, class_pointer->methods);
	while (method_list) {
		for (i = 0, method = method_list->method_list;
			 i < method_list->method_count; i++, method++) {
			sel = &G_STRUCT (pr, pr_sel_t, method->method_name);
			if (sel->sel_id == selector->sel_id) {
				PR_PushFrame (pr);
				__auto_type params = PR_SaveParams (pr);
				// param 0 is known to be the class pointer
				P_POINTER (pr, 1) = method->method_name;
				// pr->pr_argc is known to be 2
				PR_ExecuteProgram (pr, method->method_imp);
				PR_RestoreParams (pr, params);
				PR_PopFrame (pr);
				return;
			}
		}
		method_list = &G_STRUCT (pr, pr_method_list_t,
								 method_list->method_next);
	}
}

static void
obj_install_methods_in_dtable (probj_t *probj, pr_class_t *class,
							   pr_method_list_t *method_list)
{
	progs_t    *pr = probj->pr;
	dtable_t   *dtable;

	if (!method_list) {
		return;
	}
	if (method_list->method_next) {
		obj_install_methods_in_dtable (probj, class,
									   &G_STRUCT (pr, pr_method_list_t,
												  method_list->method_next));
	}

	dtable = get_dtable (probj, __FUNCTION__, class->dtable);
	for (int i = 0; i < method_list->method_count; i++) {
		pr_method_t *method = &method_list->method_list[i];
		pr_sel_t   *sel = &G_STRUCT (pr, pr_sel_t, method->method_name);
		if (sel->sel_id < dtable->size) {
			dtable->imp[sel->sel_id] = method->method_imp;
		}
	}
}

static void
obj_install_dispatch_table_for_class (probj_t *probj, pr_class_t *class)
{
	progs_t    *pr = probj->pr;
	pr_class_t *super = &G_STRUCT (pr, pr_class_t, class->super_class);
	dtable_t   *dtable;

	Sys_MaskPrintf (SYS_rua_obj, "    install dispatch for class %s %x %d\n",
					PR_GetString (pr, class->name),
					class->methods,
					PR_CLS_ISMETA(class));

	if (super && !super->dtable) {
		obj_install_dispatch_table_for_class (probj, super);
	}

	dtable = dtable_new (probj);
	class->dtable = dtable_index (probj, dtable);
	dtable->size = probj->selector_index + 1;
	dtable->imp = calloc (dtable->size, sizeof (func_t));
	if (super) {
		dtable_t   *super_dtable = get_dtable (probj, __FUNCTION__,
											   super->dtable);
		memcpy (dtable->imp, super_dtable->imp,
				super_dtable->size * sizeof (*dtable->imp));
	}
	obj_install_methods_in_dtable (probj, class,
								   &G_STRUCT (pr, pr_method_list_t,
											  class->methods));
}

static inline dtable_t *
obj_check_dtable_installed (probj_t *probj, pr_class_t *class)
{
	if (!class->dtable) {
		obj_install_dispatch_table_for_class (probj, class);
	}
	return get_dtable (probj, __FUNCTION__, class->dtable);
}

static func_t
get_imp (probj_t *probj, pr_class_t *class, pr_sel_t *sel)
{
	func_t     imp = 0;

	if (class->dtable) {
		dtable_t   *dtable = get_dtable (probj, __FUNCTION__, class->dtable);
		if (sel->sel_id < dtable->size) {
			imp = dtable->imp[sel->sel_id];
		}
	}
	if (!imp) {
		if (!class->dtable) {
			obj_install_dispatch_table_for_class (probj, class);
			imp = get_imp (probj, class, sel);
		} else {
			imp = probj->obj_forward;
		}
	}
	return imp;
}

static int
obj_reponds_to (probj_t *probj, pr_id_t *obj, pr_sel_t *sel)
{
	progs_t    *pr = probj->pr;
	pr_class_t *class;
	dtable_t   *dtable;
	func_t      imp = 0;

	class = &G_STRUCT (pr, pr_class_t, obj->class_pointer);
	dtable = obj_check_dtable_installed (probj, class);

	if (sel->sel_id < dtable->size) {
		imp = dtable->imp[sel->sel_id];
	}
	return imp != 0;
}

static func_t
obj_msg_lookup (probj_t *probj, pr_id_t *receiver, pr_sel_t *op)
{
	progs_t    *pr = probj->pr;
	pr_class_t *class;
	if (!receiver)
		return 0;
	class = &G_STRUCT (pr, pr_class_t, receiver->class_pointer);
	if (PR_CLS_ISCLASS (class)) {
		if (!PR_CLS_ISINITIALIZED (class))
			obj_send_initialize (probj, class);
	} else if (PR_CLS_ISMETA (class)
			   && PR_CLS_ISCLASS ((pr_class_t *) receiver)) {
		if (!PR_CLS_ISINITIALIZED ((pr_class_t *) receiver))
			obj_send_initialize (probj, (pr_class_t *) receiver);
	}
	return get_imp (probj, class, op);
}

static func_t
obj_msg_lookup_super (probj_t *probj, pr_super_t *super, pr_sel_t *op)
{
	progs_t    *pr = probj->pr;
	pr_class_t *class;

	if (!super->self)
		return 0;

	class = &G_STRUCT (pr, pr_class_t, super->class);
	return get_imp (probj, class, op);
}

static void
obj_verror (probj_t *probj, pr_id_t *object, int code, const char *fmt, int count,
			pr_type_t **args)
{
	progs_t    *pr = probj->pr;
	__auto_type class = &G_STRUCT (pr, pr_class_t, object->class_pointer);
	dstring_t  *dstr = dstring_newstr ();

	PR_Sprintf (pr, dstr, "obj_verror", fmt, count, args);
	PR_RunError (pr, "%s: %s", PR_GetString (pr, class->name), dstr->str);
}

static void
dump_ivars (probj_t *probj, pointer_t _ivars)
{
	progs_t    *pr = probj->pr;
	pr_ivar_list_t *ivars;
	int         i;

	if (!_ivars)
		return;
	ivars = &G_STRUCT (pr, pr_ivar_list_t, _ivars);
	for (i = 0; i < ivars->ivar_count; i++) {
		Sys_Printf ("        %s %s %d\n",
					PR_GetString (pr, ivars->ivar_list[i].ivar_name),
					PR_GetString (pr, ivars->ivar_list[i].ivar_type),
					ivars->ivar_list[i].ivar_offset);
	}
}

static void
obj_init_statics (probj_t *probj)
{
	progs_t    *pr = probj->pr;
	obj_list  **cell = &probj->uninitialized_statics;
	pointer_t  *ptr;
	pointer_t  *inst;

	Sys_MaskPrintf (SYS_rua_obj, "Initializing statics\n");
	while (*cell) {
		int         initialized = 1;

		for (ptr = (*cell)->data; *ptr; ptr++) {
			__auto_type statics = &G_STRUCT (pr, pr_static_instances_t, *ptr);
			const char *class_name = PR_GetString (pr, statics->class_name);
			pr_class_t *class = Hash_Find (probj->classes, class_name);

			Sys_MaskPrintf (SYS_rua_obj, "    %s %p\n", class_name, class);
			if (!class) {
				initialized = 0;
				continue;
			}

			if (strcmp (class_name, "Protocol") == 0) {
				// protocols are special
				for (inst = statics->instances; *inst; inst++) {
					obj_init_protocol (probj, class,
									   &G_STRUCT (pr, pr_protocol_t, *inst));
				}
			} else {
				for (inst = statics->instances; *inst; inst++) {
					pr_id_t    *id = &G_STRUCT (pr, pr_id_t, *inst);
					id->class_pointer = PR_SetPointer (pr, class);
				}
			}
		}

		if (initialized) {
			list_remove (cell);
		} else {
			cell = &(*cell)->next;
		}
	}
}

static void
rua___obj_exec_class (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_module_t *module = &P_STRUCT (pr, pr_module_t, 0);
	pr_symtab_t *symtab;
	pr_sel_t   *sel;
	pointer_t  *ptr;
	int         i;
	obj_list  **cell;

	if (!module)
		return;
	symtab = &G_STRUCT (pr, pr_symtab_t, module->symtab);
	if (!symtab)
		return;
	Sys_MaskPrintf (SYS_rua_obj, "Initializing %s module\n"
					"symtab @ %x : %d selector%s @ %x, "
					"%d class%s and %d categor%s\n"
					"static instance lists: %s\n",
					PR_GetString (pr, module->name), module->symtab,
					symtab->sel_ref_cnt, symtab->sel_ref_cnt == 1 ? "" : "s",
					symtab->refs,
					symtab->cls_def_cnt, symtab->cls_def_cnt == 1 ? "" : "es",
					symtab->cat_def_cnt,
					symtab->cat_def_cnt == 1 ? "y" : "ies",
					symtab->defs[symtab->cls_def_cnt
								 + symtab->cat_def_cnt] ? "yes" : "no");

	probj->module_list = list_cons (module, probj->module_list);

	sel = &G_STRUCT (pr, pr_sel_t, symtab->refs);
	for (i = 0; i < symtab->sel_ref_cnt; i++) {
		const char *name, *types;
		name = PR_GetString (pr, sel->sel_id);
		types = PR_GetString (pr, sel->sel_types);
		sel_register_typed_name (probj, name, types, sel);
		sel++;
	}

	ptr = symtab->defs;
	for (i = 0; i < symtab->cls_def_cnt; i++, ptr++) {
		pr_class_t *class = &G_STRUCT (pr, pr_class_t, *ptr);
		pr_class_t *meta = &G_STRUCT (pr, pr_class_t, class->class_pointer);
		const char *super_class = PR_GetString (pr, class->super_class);

		Sys_MaskPrintf (SYS_rua_obj, "Class %s @ %x\n",
						PR_GetString (pr, class->name), *ptr);
		Sys_MaskPrintf (SYS_rua_obj, "    class pointer: %x\n",
						class->class_pointer);
		Sys_MaskPrintf (SYS_rua_obj, "    super class: %s\n",
						PR_GetString (pr, class->super_class));
		Sys_MaskPrintf (SYS_rua_obj, "    instance variables: %d @ %x\n",
						class->instance_size,
						class->ivars);
		if (developer->int_val & SYS_rua_obj)
			dump_ivars (probj, class->ivars);
		Sys_MaskPrintf (SYS_rua_obj, "    instance methods: %x\n",
						class->methods);
		Sys_MaskPrintf (SYS_rua_obj, "    protocols: %x\n", class->protocols);

		Sys_MaskPrintf (SYS_rua_obj, "    class methods: %x\n", meta->methods);
		Sys_MaskPrintf (SYS_rua_obj, "    instance variables: %d @ %x\n",
						meta->instance_size,
						meta->ivars);
		if (developer->int_val & SYS_rua_obj)
			dump_ivars (probj, meta->ivars);

		class->subclass_list = 0;

		Hash_Add (probj->classes, class);

		obj_register_selectors_from_class (probj, class);
		obj_register_selectors_from_class (probj, meta);

		if (class->protocols) {
			pr_protocol_list_t *protocol_list;
			protocol_list = &G_STRUCT (pr, pr_protocol_list_t,
									   class->protocols);
			obj_init_protocols (probj, protocol_list);
		}

		if (class->super_class && !Hash_Find (probj->classes, super_class))
			probj->unresolved_classes = list_cons (class,
												   probj->unresolved_classes);
	}

	for (i = 0; i < symtab->cat_def_cnt; i++, ptr++) {
		pr_category_t *category = &G_STRUCT (pr, pr_category_t, *ptr);
		const char *class_name = PR_GetString (pr, category->class_name);
		pr_class_t *class = Hash_Find (probj->classes, class_name);

		Sys_MaskPrintf (SYS_rua_obj, "Category %s (%s) @ %x\n",
						PR_GetString (pr, category->class_name),
						PR_GetString (pr, category->category_name), *ptr);
		Sys_MaskPrintf (SYS_rua_obj, "    instance methods: %x\n",
						category->instance_methods);
		Sys_MaskPrintf (SYS_rua_obj, "    class methods: %x\n",
						category->class_methods);
		Sys_MaskPrintf (SYS_rua_obj, "    protocols: %x\n",
						category->protocols);

		if (class) {
			finish_category (probj, category, class);
		} else {
			probj->unclaimed_categories
				= list_cons (category, probj->unclaimed_categories);
		}
	}

	if (*ptr) {
		Sys_MaskPrintf (SYS_rua_obj, "Static instances lists: %x\n", *ptr);
		probj->uninitialized_statics
			= list_cons (&G_STRUCT (pr, pointer_t, *ptr),
						 probj->uninitialized_statics);
	}
	if (probj->uninitialized_statics) {
		obj_init_statics (probj);
	}

	for (cell = &probj->unclaimed_categories; *cell; ) {
		pr_category_t *category = (*cell)->data;
		const char *class_name = PR_GetString (pr, category->class_name);
		pr_class_t *class = Hash_Find (probj->classes, class_name);

		if (class) {
			list_remove (cell);
			finish_category (probj, category, class);
		} else {
			cell = &(*cell)->next;
		}
	}

	if (probj->unclaimed_proto_list
		&& Hash_Find (probj->classes, "Protocol")) {
		for (cell = &probj->unclaimed_proto_list; *cell; ) {
			obj_init_protocols (probj, (*cell)->data);
			list_remove (cell);
		}
	}

	Sys_MaskPrintf (SYS_rua_obj, "Finished initializing %s module\n",
					PR_GetString (pr, module->name));
	obj_send_load (probj);
	Sys_MaskPrintf (SYS_rua_obj, "Leaving %s module init\n",
					PR_GetString (pr, module->name));
}

static void
rua___obj_forward (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *obj = &P_STRUCT (pr, pr_id_t, 0);
	pr_sel_t   *sel = &P_STRUCT (pr, pr_sel_t, 1);
	pr_sel_t   *fwd_sel = probj->forward_selector;
	pr_sel_t   *err_sel;
	pr_class_t *class =&G_STRUCT (pr, pr_class_t, obj->class_pointer);
	func_t      imp;

	if (!fwd_sel) {
		//FIXME sel_register_typed_name is really not the way to go about
		//looking for a selector by name
		fwd_sel = sel_register_typed_name (probj, "forward::", "", 0);
		probj->forward_selector = fwd_sel;
	}
	if (obj_reponds_to (probj, obj, fwd_sel)) {
		imp = get_imp (probj, class, fwd_sel);
		// forward:(SEL) sel :(@va_list) args
		// args is full param list
		//FIXME oh for a stack
		size_t      parm_size = pr->pr_param_size * sizeof(pr_type_t);
		size_t      size = pr->pr_argc * parm_size;
		string_t    args_block = PR_AllocTempBlock (pr, size);

		int         argc = pr->pr_argc;
		__auto_type argv = (pr_type_t *) PR_GetString (pr, args_block);
		// can't memcpy all params because 0 and 1 could be anywhere
		memcpy (argv + 0, &P_INT (pr, 0), 4 * sizeof (pr_type_t));
		memcpy (argv + 4, &P_INT (pr, 1), 4 * sizeof (pr_type_t));
		memcpy (argv + 8, &P_INT (pr, 2), (argc - 2) * parm_size);

		PR_RESET_PARAMS (pr);
		P_POINTER (pr, 0) = PR_SetPointer (pr, obj);
		P_POINTER (pr, 1) = PR_SetPointer (pr, fwd_sel);
		P_POINTER (pr, 2) = PR_SetPointer (pr, sel);
		P_PACKED  (pr, pr_va_list_t, 3).count = argc;
		P_PACKED  (pr, pr_va_list_t, 3).list = PR_SetPointer (pr, argv);
		PR_PushTempString (pr, args_block);
		PR_CallFunction (pr, imp);
		return;
	}
	//FIXME ditto
	err_sel = sel_register_typed_name (probj, "doesNotRecognize:", "", 0);
	if (obj_reponds_to (probj, obj, err_sel)) {
		imp = get_imp (probj, class, err_sel);
		PR_RESET_PARAMS (pr);
		P_POINTER (pr, 0) = PR_SetPointer (pr, obj);
		P_POINTER (pr, 1) = PR_SetPointer (pr, err_sel);
		P_POINTER (pr, 2) = PR_SetPointer (pr, sel);
		pr->pr_argc = 3;
		PR_CallFunction (pr, imp);
		return;
	}

	dsprintf (probj->msg, "(%s) %s does not recognize %s",
			  PR_CLS_ISMETA (class) ? "class" : "instance",
			  PR_GetString (pr, class->name),
			  PR_GetString (pr, probj->selector_names[sel->sel_id]));

	//FIXME ditto
	err_sel = sel_register_typed_name (probj, "error:", "", 0);
	if (obj_reponds_to (probj, obj, err_sel)) {
		imp = get_imp (probj, class, err_sel);
		PR_RESET_PARAMS (pr);
		P_POINTER (pr, 0) = PR_SetPointer (pr, obj);
		P_POINTER (pr, 1) = PR_SetPointer (pr, err_sel);
		P_POINTER (pr, 2) = PR_SetTempString (pr, probj->msg->str);
		pr->pr_argc = 3;
		PR_CallFunction (pr, imp);
		return;
	}

	PR_RunError (pr, "%s", probj->msg->str);
}

static void
rua___obj_responds_to (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *obj = &P_STRUCT (pr, pr_id_t, 0);
	pr_sel_t   *sel = &P_STRUCT (pr, pr_sel_t, 1);

	R_INT (pr) = obj_reponds_to (probj, obj, sel);
}

static void
rua_obj_error (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);
	int         code = P_INT (pr, 1);
	const char *fmt = P_GSTRING (pr, 2);
	int         count = pr->pr_argc - 3;
	pr_type_t **args = &pr->pr_params[3];

	obj_verror (probj, object, code, fmt, count, args);
}

static void
rua_obj_verror (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);
	int         code = P_INT (pr, 1);
	const char *fmt = P_GSTRING (pr, 2);
	pr_va_list_t *val = (pr_va_list_t *) pr->pr_params[3];
	pr_type_t  *params = &G_STRUCT (pr, pr_type_t, val->list);
	pr_type_t **args = alloca (val->count * sizeof (pr_type_t *));
	int         i;

	for (i = 0; i < val->count; i++)
		args[i] = params + i * pr->pr_param_size;
	obj_verror (probj, object, code, fmt, val->count, args);
}

static void
rua_obj_set_error_handler (progs_t *pr)
{
	//probj_t    *probj = pr->pr_objective_resources;
	//func_t      func = P_INT (pr, 0);
	//arglist
	//XXX
	PR_RunError (pr, "%s, not implemented", __FUNCTION__);
}

static void
rua_obj_msg_lookup (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *receiver = &P_STRUCT (pr, pr_id_t, 0);
	pr_sel_t   *op = &P_STRUCT (pr, pr_sel_t, 1);

	R_INT (pr) = obj_msg_lookup (probj, receiver, op);
}

static void
rua_obj_msg_lookup_super (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_super_t *super = &P_STRUCT (pr, pr_super_t, 0);
	pr_sel_t   *_cmd = &P_STRUCT (pr, pr_sel_t, 1);

	R_INT (pr) = obj_msg_lookup_super (probj, super, _cmd);
}

static void
rua_obj_msg_sendv (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pointer_t   obj = P_POINTER (pr, 0);
	pr_id_t    *receiver = &P_STRUCT (pr, pr_id_t, 0);
	pointer_t   sel = P_POINTER (pr, 1);
	pr_sel_t   *op = &P_STRUCT (pr, pr_sel_t, 1);
	func_t      imp = obj_msg_lookup (probj, receiver, op);

	__auto_type args = &P_PACKED (pr, pr_va_list_t, 2);
	int         count = args->count;
	pr_type_t  *params = G_GPOINTER (pr, args->list);

	if (count < 2 || count > MAX_PARMS) {
		PR_RunError (pr, "bad args count in obj_msg_sendv: %d", count);
	}
	if (pr_boundscheck->int_val) {
		PR_BoundsCheckSize (pr, args->list, count * pr->pr_param_size);
	}

	if (!imp) {
		PR_RunError (pr, "%s does not respond to %s",
					 PR_GetString (pr, object_get_class_name (probj, receiver)),
					 PR_GetString (pr, probj->selector_names[op->sel_id]));
	}

	pr->pr_argc = count;
	// skip over the first two parameters because receiver and op will
	// replace them
	count -= 2;
	params += 2 * pr->pr_param_size;
	PR_RESET_PARAMS (pr);
	P_POINTER (pr, 0) = obj;
	P_POINTER (pr, 1) = sel;
	if (count) {
		memcpy (&P_INT (pr, 2), params,
				count * sizeof (pr_type_t) * pr->pr_param_size);
	}
	PR_CallFunction (pr, imp);
}

static void
rua_obj_increment_retaincount (progs_t *pr)
{
	pr_type_t  *obj = &P_STRUCT (pr, pr_type_t, 0);
	R_INT (pr) = ++(*--obj).integer_var;
}

static void
rua_obj_decrement_retaincount (progs_t *pr)
{
	pr_type_t  *obj = &P_STRUCT (pr, pr_type_t, 0);
	R_INT (pr) = --(*--obj).integer_var;
}

static void
rua_obj_get_retaincount (progs_t *pr)
{
	pr_type_t  *obj = &P_STRUCT (pr, pr_type_t, 0);
	R_INT (pr) = (*--obj).integer_var;
}

static void
rua_obj_malloc (progs_t *pr)
{
	int         size = P_INT (pr, 0) * sizeof (pr_type_t);
	void       *mem = PR_Zone_Malloc (pr, size);

	RETURN_POINTER (pr, mem);
}

static void
rua_obj_atomic_malloc (progs_t *pr)
{
	int         size = P_INT (pr, 0) * sizeof (pr_type_t);
	void       *mem = PR_Zone_Malloc (pr, size);

	RETURN_POINTER (pr, mem);
}

static void
rua_obj_valloc (progs_t *pr)
{
	int         size = P_INT (pr, 0) * sizeof (pr_type_t);
	void       *mem = PR_Zone_Malloc (pr, size);

	RETURN_POINTER (pr, mem);
}

static void
rua_obj_realloc (progs_t *pr)
{
	void       *mem = (void*)P_GPOINTER (pr, 0);
	int         size = P_INT (pr, 1) * sizeof (pr_type_t);

	mem = PR_Zone_Realloc (pr, mem, size);
	RETURN_POINTER (pr, mem);
}

static void
rua_obj_calloc (progs_t *pr)
{
	int         size = P_INT (pr, 0) * P_INT (pr, 1) * sizeof (pr_type_t);
	void       *mem = PR_Zone_Malloc (pr, size);

	memset (mem, 0, size);
	RETURN_POINTER (pr, mem);
}

static void
rua_obj_free (progs_t *pr)
{
	void       *mem = (void*)P_GPOINTER (pr, 0);

	PR_Zone_Free (pr, mem);
}

static void
rua_obj_get_uninstalled_dtable (progs_t *pr)
{
	//probj_t    *probj = pr->pr_objective_resources;
	//XXX
	PR_RunError (pr, "%s, not implemented", __FUNCTION__);
}

static void
rua_obj_msgSend (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *self = &P_STRUCT (pr, pr_id_t, 0);
	pr_sel_t   *_cmd = &P_STRUCT (pr, pr_sel_t, 1);
	func_t      imp;

	if (!self) {
		R_INT (pr) = P_INT (pr, 0);
		return;
	}
	if (!_cmd)
		PR_RunError (pr, "null selector");
	imp = obj_msg_lookup (probj, self, _cmd);
	if (!imp)
		PR_RunError (pr, "%s does not respond to %s",
					 PR_GetString (pr, object_get_class_name (probj, self)),
					 PR_GetString (pr, probj->selector_names[_cmd->sel_id]));

	PR_CallFunction (pr, imp);
}

static void
rua_obj_msgSend_super (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_super_t *super = &P_STRUCT (pr, pr_super_t, 0);
	pr_sel_t   *_cmd = &P_STRUCT (pr, pr_sel_t, 1);
	func_t      imp;

	imp = obj_msg_lookup_super (probj, super, _cmd);
	if (!imp) {
		pr_id_t    *self = &G_STRUCT (pr, pr_id_t, super->self);
		PR_RunError (pr, "%s does not respond to %s",
					 PR_GetString (pr, object_get_class_name (probj, self)),
					 PR_GetString (pr, probj->selector_names[_cmd->sel_id]));
	}
	pr->pr_params[0] = pr->pr_real_params[0];
	P_POINTER (pr, 0) = super->self;
	PR_CallFunction (pr, imp);
}

static void
rua_obj_get_class (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	const char *name = P_GSTRING (pr, 0);
	pr_class_t *class;

	class = Hash_Find (probj->classes, name);
	if (!class)
		PR_RunError (pr, "could not find class %s", name);
	RETURN_POINTER (pr, class);
}

static void
rua_obj_lookup_class (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	const char *name = P_GSTRING (pr, 0);
	pr_class_t *class;

	class = Hash_Find (probj->classes, name);
	RETURN_POINTER (pr, class);
}

static void
rua_obj_next_class (progs_t *pr)
{
	//probj_t    *probj = pr->pr_objective_resources;
	//XXX
	PR_RunError (pr, "%s, not implemented", __FUNCTION__);
}

//====================================================================

static void
rua_sel_get_name (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_sel_t   *sel = &P_STRUCT (pr, pr_sel_t, 0);

	if (sel->sel_id > 0 && sel->sel_id <= probj->selector_index)
		R_STRING (pr) = probj->selector_names[sel->sel_id];
	else
		R_STRING (pr) = 0;
}

static void
rua_sel_get_type (progs_t *pr)
{
	pr_sel_t   *sel = &P_STRUCT (pr, pr_sel_t, 0);

	R_INT (pr) = sel->sel_types;
}

static void
rua_sel_get_uid (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	const char *name = P_GSTRING (pr, 0);

	RETURN_POINTER (pr, sel_register_typed_name (probj, name, "", 0));
}

static void
rua_sel_register_name (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	const char *name = P_GSTRING (pr, 0);

	RETURN_POINTER (pr, sel_register_typed_name (probj, name, "", 0));
}

static void
rua_sel_is_mapped (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	// FIXME might correspond to a string
	pr_sel_t   *sel = &P_STRUCT (pr, pr_sel_t, 0);
	R_INT (pr) = sel->sel_id > 0 && sel->sel_id <= probj->selector_index;
}

//====================================================================

static void
rua_class_get_class_method (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	pr_sel_t   *aSel = &P_STRUCT (pr, pr_sel_t, 1);
	pr_method_t *method;
	class = &G_STRUCT (pr, pr_class_t, class->class_pointer);
	method = obj_find_message (probj, class, aSel);
	RETURN_POINTER (pr, method);
}

static void
rua_class_get_instance_method (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	pr_sel_t   *aSel = &P_STRUCT (pr, pr_sel_t, 1);
	pr_method_t *method = obj_find_message (probj, class, aSel);
	RETURN_POINTER (pr, method);
}

#define CLASSOF(x) (&G_STRUCT (pr, pr_class_t, (x)->class_pointer))

static void
rua_class_pose_as (progs_t *pr)
{
	pr_class_t *impostor = &P_STRUCT (pr, pr_class_t, 0);
	pr_class_t *superclass = &P_STRUCT (pr, pr_class_t, 1);
	pointer_t  *subclass;

	subclass = &superclass->subclass_list;
	while (*subclass) {
		pr_class_t *sub = &P_STRUCT (pr, pr_class_t, *subclass);
		pointer_t   nextSub = sub->sibling_class;
		if (sub != impostor) {
			sub->sibling_class = impostor->subclass_list;
			sub->super_class = P_POINTER (pr, 0);	// impostor
			impostor->subclass_list = *subclass;	// sub
			CLASSOF (sub)->sibling_class = CLASSOF (impostor)->sibling_class;
			CLASSOF (sub)->super_class = impostor->class_pointer;
			CLASSOF (impostor)->subclass_list = sub->class_pointer;
		}
		*subclass = nextSub;
	}
	superclass->subclass_list = P_POINTER (pr, 0);	// impostor
	CLASSOF (superclass)->subclass_list = impostor->class_pointer;

	impostor->sibling_class = 0;
	CLASSOF (impostor)->sibling_class = 0;

	//XXX how much do I need to do here?!?
	//class_table_replace (super_class, impostor);
	R_INT (pr) = P_POINTER (pr, 0);	// impostor
}
#undef CLASSOF

static inline pr_id_t *
class_create_instance (progs_t *pr, pr_class_t *class)
{
	int         size = (class->instance_size + 1) * sizeof (pr_type_t);
	pr_type_t  *mem;
	pr_id_t    *id = 0;

	mem = PR_Zone_TagMalloc (pr, size, class->name);
	if (mem) {
		memset (mem, 0, size);
		id = (pr_id_t *) (mem + 1);
		id->class_pointer = PR_SetPointer (pr, class);
	}
	return id;
}

static void
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);

	RETURN_POINTER (pr, id);
}

static void
rua_class_get_class_name (progs_t *pr)
{
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	R_INT (pr) = PR_CLS_ISCLASS (class) ? class->name
										: PR_SetString (pr, "Nil");
}

static void
rua_class_get_instance_size (progs_t *pr)
{
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	R_INT (pr) = PR_CLS_ISCLASS (class) ? class->instance_size : 0;
}

static void
rua_class_get_meta_class (progs_t *pr)
{
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	R_INT (pr) = PR_CLS_ISCLASS (class) ? class->class_pointer : 0;
}

static void
rua_class_get_super_class (progs_t *pr)
{
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	R_INT (pr) = PR_CLS_ISCLASS (class) ? class->super_class : 0;
}

static void
rua_class_get_version (progs_t *pr)
{
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	R_INT (pr) = PR_CLS_ISCLASS (class) ? class->version : -1;
}

static void
rua_class_is_class (progs_t *pr)
{
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	R_INT (pr) = PR_CLS_ISCLASS (class);
}

static void
rua_class_is_meta_class (progs_t *pr)
{
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	R_INT (pr) = PR_CLS_ISMETA (class);
}

static void
rua_class_set_version (progs_t *pr)
{
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	if (PR_CLS_ISCLASS (class))
		class->version = P_INT (pr, 1);
}

static void
rua_class_get_gc_object_type (progs_t *pr)
{
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	R_INT (pr) = PR_CLS_ISCLASS (class) ? class->gc_object_type : 0;
}

static void
rua_class_ivar_set_gcinvisible (progs_t *pr)
{
	//probj_t    *probj = pr->pr_objective_resources;
	//pr_class_t *impostor = &P_STRUCT (pr, pr_class_t, 0);
	//const char *ivarname = P_GSTRING (pr, 1);
	//int         gcInvisible = P_INT (pr, 2);
	//XXX
	PR_RunError (pr, "%s, not implemented", __FUNCTION__);
}

//====================================================================

static void
rua_method_get_imp (progs_t *pr)
{
	pr_method_t *method = &P_STRUCT (pr, pr_method_t, 0);

	R_INT (pr) = method ? method->method_imp : 0;
}

static void
rua_get_imp (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	pr_sel_t   *sel = &P_STRUCT (pr, pr_sel_t, 1);

	R_INT (pr) = get_imp (probj, class, sel);
}

//====================================================================

static void
rua_object_dispose (progs_t *pr)
{
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);
	pr_type_t  *mem = (pr_type_t *) object;
	PR_Zone_Free (pr, mem - 1);
}

static void
rua_object_copy (progs_t *pr)
{
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);
	pr_class_t *class = &G_STRUCT (pr, pr_class_t, object->class_pointer);
	pr_id_t    *id;

	id = class_create_instance (pr, class);
	if (id) {
		memcpy (id, object, sizeof (pr_type_t) * class->instance_size);
		// copy the retain count
		((pr_type_t *) id)[-1] = ((pr_type_t *) object)[-1];
	}
	RETURN_POINTER (pr, id);
}

static void
rua_object_get_class (progs_t *pr)
{
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);
	pr_class_t *class;

	if (object) {
		class = &G_STRUCT (pr, pr_class_t, object->class_pointer);
		if (PR_CLS_ISCLASS (class)) {
			RETURN_POINTER (pr, class);
			return;
		}
		if (PR_CLS_ISMETA (class)) {
			R_INT (pr) = P_INT (pr, 0);
			return;
		}
	}
	R_INT (pr) = 0;
}

static void
rua_object_get_super_class (progs_t *pr)
{
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);
	pr_class_t *class;

	if (object) {
		class = &G_STRUCT (pr, pr_class_t, object->class_pointer);
		if (PR_CLS_ISCLASS (class)) {
			R_INT (pr) = class->super_class;
			return;
		}
		if (PR_CLS_ISMETA (class)) {
			R_INT (pr) = ((pr_class_t *)object)->super_class;
			return;
		}
	}
	R_INT (pr) = 0;
}

static void
rua_object_get_meta_class (progs_t *pr)
{
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);
	pr_class_t *class;

	if (object) {
		class = &G_STRUCT (pr, pr_class_t, object->class_pointer);
		if (PR_CLS_ISCLASS (class)) {
			R_INT (pr) = class->class_pointer;
			return;
		}
		if (PR_CLS_ISMETA (class)) {
			R_INT (pr) = ((pr_class_t *)object)->class_pointer;
			return;
		}
	}
	R_INT (pr) = 0;
}

static void
rua_object_get_class_name (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);

	R_STRING (pr) = object_get_class_name (probj, object);
}

static void
rua_object_is_class (progs_t *pr)
{
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);

	if (object) {
		R_INT (pr) = PR_CLS_ISCLASS ((pr_class_t*)object);
		return;
	}
	R_INT (pr) = 0;
}

static void
rua_object_is_instance (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);

	R_INT (pr) = object_is_instance (probj, object);
}

static void
rua_object_is_meta_class (progs_t *pr)
{
	pr_id_t    *object = &P_STRUCT (pr, pr_id_t, 0);

	if (object) {
		R_INT (pr) = PR_CLS_ISMETA ((pr_class_t*)object);
		return;
	}
	R_INT (pr) = 0;
}

//====================================================================

static void
rua__i_Object__hash (progs_t *pr)
{
	R_INT (pr) = P_INT (pr, 0);
}

static void
rua__i_Object_error_error_ (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *self = &P_STRUCT (pr, pr_id_t, 0);
	const char *fmt = P_GSTRING (pr, 2);
	dstring_t  *dstr = dstring_new ();
	int         count = pr->pr_argc - 3;
	pr_type_t **args = &pr->pr_params[3];

	dsprintf (dstr, "error: %s (%s)\n%s",
			  PR_GetString (pr, object_get_class_name (probj, self)),
			  object_is_instance (probj, self) ? "instance" : "class", fmt);
	obj_verror (probj, self, 0, dstr->str, count, args);
}

static int
obj_protocol_conformsToProtocol (probj_t *probj, pr_protocol_t *proto,
								 pr_protocol_t *protocol)
{
	progs_t    *pr = probj->pr;

	pr_protocol_list_t *proto_list;

	if (!proto || !protocol) {
		return 0;
	}
	if (proto == protocol) {
		return 1;
	}
	if (proto->protocol_name == protocol->protocol_name
		|| strcmp (PR_GetString (pr, proto->protocol_name),
				   PR_GetString (pr, protocol->protocol_name)) == 0) {
		return 1;
	}
	proto_list = &G_STRUCT (pr, pr_protocol_list_t, proto->protocol_list);
	while (proto_list) {
		Sys_MaskPrintf (SYS_rua_obj, "%x %x %d\n",
						PR_SetPointer (pr, proto_list), proto_list->next,
						proto_list->count);
		for (int i = 0; i < proto_list->count; i++) {
			proto = &G_STRUCT (pr, pr_protocol_t, proto_list->list[i]);
			if (proto == protocol
				|| obj_protocol_conformsToProtocol (probj, proto, protocol)) {
				return 1;
			}
		}

		proto_list = &G_STRUCT (pr, pr_protocol_list_t, proto_list->next);
	}
	return 0;
}

static void
rua__c_Object__conformsToProtocol_ (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	// class points to _OBJ_CLASS_foo, and class->class_pointer points to
	// _OBJ_METACLASS_foo
	pr_class_t *class = &P_STRUCT (pr, pr_class_t, 0);
	// protocol->class_pointer must point to _OBJ_CLASS_Protocol (ie, if
	// protocol is not actually a protocol, then the class cannot conform
	// to it)
	pr_protocol_t *protocol = &P_STRUCT (pr, pr_protocol_t, 2);
	pr_protocol_list_t *proto_list;

	if (!class || !protocol) {
		goto not_conforms;
	}
	if (protocol->class_pointer != PR_SetPointer (pr,
												  Hash_Find (probj->classes,
															 "Protocol"))) {
		goto not_conforms;
	}
	proto_list = &G_STRUCT (pr, pr_protocol_list_t, class->protocols);
	while (proto_list) {
		Sys_MaskPrintf (SYS_rua_obj, "%x %x %d\n",
						PR_SetPointer (pr, proto_list), proto_list->next,
						proto_list->count);
		for (int i = 0; i < proto_list->count; i++) {
			__auto_type proto = &G_STRUCT (pr, pr_protocol_t,
										   proto_list->list[i]);
			if (proto == protocol
				|| obj_protocol_conformsToProtocol (probj, proto, protocol)) {
				goto conforms;
			}
		}

		proto_list = &G_STRUCT (pr, pr_protocol_list_t, proto_list->next);
	}
not_conforms:
	Sys_MaskPrintf (SYS_rua_obj, "does not conform\n");
	R_INT (pr) = 0;
	return;
conforms:
	Sys_MaskPrintf (SYS_rua_obj, "conforms\n");
	R_INT (pr) = 1;
	return;
}

static void
rua_PR_FindGlobal (progs_t *pr)
{
	const char *name = P_GSTRING (pr, 0);
	pr_def_t   *def;

	R_POINTER (pr) = 0;
	def = PR_FindGlobal (pr, name);
	if (def)
		R_POINTER (pr) = def->ofs;
}

//====================================================================

static builtin_t obj_methods [] = {
	{"__obj_exec_class",			rua___obj_exec_class,			-1},
	{"__obj_forward",				rua___obj_forward,				-1},
	{"__obj_responds_to",			rua___obj_responds_to,			-1},

	{"obj_error",					rua_obj_error,					-1},
	{"obj_verror",					rua_obj_verror,					-1},
	{"obj_set_error_handler",		rua_obj_set_error_handler,		-1},
	{"obj_msg_lookup",				rua_obj_msg_lookup,				-1},
	{"obj_msg_lookup_super",		rua_obj_msg_lookup_super,		-1},
	{"obj_msg_sendv",				rua_obj_msg_sendv,				-1},
	{"obj_increment_retaincount",	rua_obj_increment_retaincount,	-1},
	{"obj_decrement_retaincount",	rua_obj_decrement_retaincount,	-1},
	{"obj_get_retaincount",			rua_obj_get_retaincount,		-1},
	{"obj_malloc",					rua_obj_malloc,					-1},
	{"obj_atomic_malloc",			rua_obj_atomic_malloc,			-1},
	{"obj_valloc",					rua_obj_valloc,					-1},
	{"obj_realloc",					rua_obj_realloc,				-1},
	{"obj_calloc",					rua_obj_calloc,					-1},
	{"obj_free",					rua_obj_free,					-1},
	{"obj_get_uninstalled_dtable",	rua_obj_get_uninstalled_dtable,	-1},
	{"obj_msgSend",					rua_obj_msgSend,				-1},
	{"obj_msgSend_super",			rua_obj_msgSend_super,			-1},

	{"obj_get_class",				rua_obj_get_class,				-1},
	{"obj_lookup_class",			rua_obj_lookup_class,			-1},
	{"obj_next_class",				rua_obj_next_class,				-1},

	{"sel_get_name",				rua_sel_get_name,				-1},
	{"sel_get_type",				rua_sel_get_type,				-1},
	{"sel_get_uid",					rua_sel_get_uid,				-1},
	{"sel_register_name",			rua_sel_register_name,			-1},
	{"sel_is_mapped",				rua_sel_is_mapped,				-1},

	{"class_get_class_method",		rua_class_get_class_method,		-1},
	{"class_get_instance_method",	rua_class_get_instance_method,	-1},
	{"class_pose_as",				rua_class_pose_as,				-1},
	{"class_create_instance",		rua_class_create_instance,		-1},
	{"class_get_class_name",		rua_class_get_class_name,		-1},
	{"class_get_instance_size",		rua_class_get_instance_size,	-1},
	{"class_get_meta_class",		rua_class_get_meta_class,		-1},
	{"class_get_super_class",		rua_class_get_super_class,		-1},
	{"class_get_version",			rua_class_get_version,			-1},
	{"class_is_class",				rua_class_is_class,				-1},
	{"class_is_meta_class",			rua_class_is_meta_class,		-1},
	{"class_set_version",			rua_class_set_version,			-1},
	{"class_get_gc_object_type",	rua_class_get_gc_object_type,	-1},
	{"class_ivar_set_gcinvisible",	rua_class_ivar_set_gcinvisible,	-1},

	{"method_get_imp",				rua_method_get_imp,				-1},
	{"get_imp",						rua_get_imp,					-1},

	{"object_copy",					rua_object_copy,				-1},
	{"object_dispose",				rua_object_dispose,				-1},
	{"object_get_class",			rua_object_get_class,			-1},
	{"object_get_class_name",		rua_object_get_class_name,		-1},
	{"object_get_meta_class",		rua_object_get_meta_class,		-1},
	{"object_get_super_class",		rua_object_get_super_class,		-1},
	{"object_is_class",				rua_object_is_class,			-1},
	{"object_is_instance",			rua_object_is_instance,			-1},
	{"object_is_meta_class",		rua_object_is_meta_class,		-1},

	{"_i_Object__hash",				rua__i_Object__hash,			-1},
	{"_i_Object_error_error_",		rua__i_Object_error_error_,		-1},
	{"_c_Object__conformsToProtocol_", rua__c_Object__conformsToProtocol_, -1},

	{"PR_FindGlobal",				rua_PR_FindGlobal,				-1},//FIXME
	{0}
};

static int
rua_init_finish (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_class_t **class_list, **class;

	class_list = (pr_class_t **) Hash_GetList (probj->classes);
	if (*class_list) {
		pr_class_t *object_class;
		pointer_t   object_ptr;

		object_class = Hash_Find (probj->classes, "Object");
		if (object_class && !object_class->super_class)
			object_ptr = (pr_type_t *)object_class - pr->pr_globals;
		else
			PR_Error (pr, "root class Object not found");
		for (class = class_list; *class; class++)
			finish_class (probj, *class, object_ptr);
	}
	free (class_list);

	return 1;
}

static int
rua_obj_init_runtime (progs_t *pr)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_def_t   *def;
	dfunction_t *obj_forward;

	if ((def = PR_FindField (pr, ".this")))
		pr->fields.this = def->ofs;

	probj->obj_forward = 0;
	if ((obj_forward = PR_FindFunction (pr, "__obj_forward"))) {
		probj->obj_forward = (intptr_t) (obj_forward - pr->pr_functions);
	}

	PR_AddLoadFinishFunc (pr, rua_init_finish);
	return 1;
}

static void
rua_obj_cleanup (progs_t *pr, void *data)
{
	unsigned    i;

	__auto_type probj = (probj_t *) data;
	pr->pr_objective_resources = probj;

	Hash_FlushTable (probj->selector_hash);
	probj->selector_index = 0;
	for (i = 0; i < probj->selector_index_max; i++) {
		obj_list_free (probj->selector_sels[i]);
		probj->selector_sels[i] = 0;
		probj->selector_names[i] = 0;
	}

	for (dtable_t *dtable = probj->dtable_list; dtable;
		 dtable = dtable->next) {
		free (dtable->imp);
	}
	dtable_reset (probj);

	Hash_FlushTable (probj->classes);
	Hash_FlushTable (probj->protocols);
	Hash_FlushTable (probj->load_methods);
	probj->unresolved_classes = 0;
	probj->unclaimed_categories = 0;
	probj->unclaimed_proto_list = 0;
	probj->module_list = 0;
	probj->class_tree_list = 0;
}

void
RUA_Obj_Init (progs_t *pr, int secure)
{
	probj_t    *probj = calloc (1, sizeof (*probj));

	probj->pr = pr;
	probj->selector_hash = Hash_NewTable (1021, selector_get_key, 0, probj,
										  pr->hashlink_freelist);
	probj->classes = Hash_NewTable (1021, class_get_key, 0, probj,
									pr->hashlink_freelist);
	probj->protocols = Hash_NewTable (1021, protocol_get_key, 0, probj,
									  pr->hashlink_freelist);
	probj->load_methods = Hash_NewTable (1021, 0, 0, probj,
										 pr->hashlink_freelist);
	probj->msg = dstring_newstr();
	Hash_SetHashCompare (probj->load_methods, load_methods_get_hash,
						 load_methods_compare);

	PR_Resources_Register (pr, "RUA_ObjectiveQuakeC", probj, rua_obj_cleanup);

	PR_RegisterBuiltins (pr, obj_methods);

	PR_AddLoadFunc (pr, rua_obj_init_runtime);
}

func_t
RUA_Obj_msg_lookup (progs_t *pr, pointer_t _self, pointer_t __cmd)
{
	probj_t    *probj = pr->pr_objective_resources;
	pr_id_t    *self = &G_STRUCT (pr, pr_id_t, _self);
	pr_sel_t   *_cmd = &G_STRUCT (pr, pr_sel_t, __cmd);
	func_t      imp;

	if (!self)
		return 0;
	if (!_cmd)
		PR_RunError (pr, "null selector");
	imp = obj_msg_lookup (probj, self, _cmd);
	if (!imp)
		PR_RunError (pr, "%s does not respond to %s",
					 PR_GetString (pr, object_get_class_name (probj, self)),
					 PR_GetString (pr, probj->selector_names[_cmd->sel_id]));

	return imp;
}

int
RUA_obj_increment_retaincount (progs_t *pr)
{
	rua_obj_increment_retaincount (pr);
	return R_INT (pr);
}

int
RUA_obj_decrement_retaincount (progs_t *pr)
{
	rua_obj_decrement_retaincount (pr);
	return R_INT (pr);
}